/*******************************************************************************
 * Copyright (c) 2009, 2010 Nokia and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Nokia - Initial API and implementation
 *******************************************************************************/
package org.eclipse.cdt.debug.edc.debugger.tests;

import org.eclipse.cdt.debug.edc.internal.eval.ast.engine.ASTEvalMessages;
import org.junit.Test;

public class ExpressionsAggregatesAndEnums extends BaseExpressionTest {

	/*
	 *	Note: This assumes you are at a breakpoint where:
	 *	typedef struct {
	 *		char achar;
	 *		UCHAR auchar;
	 *		SCHAR aschar;
	 *		short ashort;
	 *		USHORT aushort;
	 *		SSHORT asshort;
	 *		int aint;
	 *		UINT auint;
	 *		SINT asint;
	 *		long along;
	 *		ULONG aulong;
	 *		SLONG aslong;
	 *		ULONGLONG aulonglong;
	 *		SLONGLONG aslonglong;
	 *		float afloat;
	 *		double adouble;
	 *	} struct_type;
	 *
	 *	struct_type lstruct;
	 *
	 *	lstruct.achar = '1';
	 *	lstruct.auchar = 2;
	 *	lstruct.aschar = '3';
	 *	lstruct.ashort = 4;
	 *	lstruct.aushort = 5;
	 *	lstruct.asshort = 6;
	 *	lstruct.aint = 7;
	 *	lstruct.auint = 8;
	 *	lstruct.asint = 9;
	 *	lstruct.along = 10;
	 *	lstruct.aulong = 11;
	 *	lstruct.aslong = 12;
	 *	lstruct.aulonglong = 13;
	 *	lstruct.aslonglong = 14;
	 *	lstruct.afloat = 15.0;
	 *	lstruct.adouble = 16.0;
	 */
	@Test
	public void testExpressionsWithStructs() throws Exception {
		openSnapshotAndWaitForSuspendedContext(0);

		checkExprNoError("lstruct");
		checkExpr("49 ('1')", "lstruct.achar");
		checkExpr("2 ('\\002')", "lstruct.auchar");
		checkExpr("51 ('3')", "lstruct.aschar");
		checkExpr("4", "lstruct.ashort");
		checkExpr("5", "lstruct.aushort");
		checkExpr("6", "lstruct.asshort");
		checkExpr("7", "lstruct.aint");
		checkExpr("8", "lstruct.auint");
		checkExpr("9", "lstruct.asint");
		checkExpr("10", "lstruct.along");
		checkExpr("11", "lstruct.aulong");
		checkExpr("12", "lstruct.aslong");
		checkExpr("13", "lstruct.aulonglong");
		checkExpr("14", "lstruct.aslonglong");
		checkExpr("15.0", "lstruct.afloat");
		checkExpr("16.0", "lstruct.adouble");

		// logical operations
		// ==
		checkExpr("true", "lstruct.achar == 49");
		checkExpr("true", "lstruct.ashort == 4");
		checkExpr("true", "lstruct.aint == 7");
		checkExpr("true", "10 == lstruct.along");
		checkExpr("true", "lstruct.aslonglong == 14");
		checkExpr("true", "lstruct.afloat == lstruct.afloat"); // for precision
		checkExpr("true", "lstruct.adouble == lstruct.adouble"); // for precision
		checkExpr("false", "lstruct.achar == lstruct.auchar");
		checkExpr("false", "lstruct.ashort == lstruct.aushort");
		checkExpr("false", "lstruct.aint == lstruct.asint");
		checkExpr("false", "lstruct.along == lstruct.aulong");
		checkExpr("false", "lstruct.aulonglong == lstruct.aslonglong");
		checkExpr("false", "lstruct.afloat == lstruct.adouble");
		// !=
		checkExpr("false", "lstruct.achar != 49");
		checkExpr("false", "lstruct.ashort != 4");
		checkExpr("false", "7 != lstruct.aint");
		checkExpr("false", "lstruct.along != 10");
		checkExpr("false", "lstruct.aslonglong != 14");
		checkExpr("false", "15.0F != lstruct.afloat");
		checkExpr("false", "lstruct.adouble != 16.0");
		checkExpr("true", "lstruct.achar != lstruct.aschar");
		checkExpr("true", "lstruct.ashort != lstruct.aushort");
		checkExpr("true", "lstruct.aint != lstruct.asint");
		checkExpr("true", "lstruct.along != lstruct.aulong");
		checkExpr("true", "lstruct.aulonglong != lstruct.aslonglong");
		checkExpr("true", "lstruct.afloat != lstruct.adouble");
		// >=
		checkExpr("true", "lstruct.achar >= 49");
		checkExpr("true", "lstruct.ashort >= 4");
		checkExpr("true", "lstruct.aint >= 7");
		checkExpr("true", "lstruct.along >= 10");
		checkExpr("true", "lstruct.aslonglong >= 14");
		checkExpr("true", "lstruct.afloat >= 15.0F");
		checkExpr("true", "lstruct.adouble >= 16.0");
		checkExpr("false", "lstruct.achar >= lstruct.aschar");
		checkExpr("false", "lstruct.ashort >= lstruct.aushort");
		checkExpr("false", "lstruct.aint >= lstruct.asint");
		checkExpr("false", "lstruct.along >= lstruct.aulong");
		checkExpr("false", "lstruct.aulonglong >= lstruct.aslonglong");
		checkExpr("false", "lstruct.afloat >= lstruct.adouble");
		// >
		checkExpr("false", "lstruct.achar > 49");
		checkExpr("false", "lstruct.ashort > 4");
		checkExpr("false", "lstruct.aint > 7");
		checkExpr("false", "lstruct.along > 10");
		checkExpr("false", "lstruct.aslonglong > 14");
		checkExpr("false", "lstruct.afloat > 15.0F");
		checkExpr("false", "lstruct.adouble > 16.0");
		checkExpr("false", "lstruct.achar > lstruct.aschar");
		checkExpr("false", "lstruct.ashort > lstruct.aushort");
		checkExpr("false", "lstruct.aint > lstruct.asint");
		checkExpr("false", "lstruct.along > lstruct.aulong");
		checkExpr("false", "lstruct.aulonglong > lstruct.aslonglong");
		checkExpr("false", "lstruct.afloat > lstruct.adouble");
		// <=
		checkExpr("true", "lstruct.achar <= 49");
		checkExpr("true", "lstruct.ashort <= 4");
		checkExpr("true", "lstruct.aint <= 7");
		checkExpr("true", "lstruct.along <= 10");
		checkExpr("true", "lstruct.aslonglong <= 14");
		checkExpr("true", "lstruct.afloat <= 15.0F");
		checkExpr("true", "lstruct.adouble <= 16.0");
		checkExpr("true", "lstruct.achar <= lstruct.aschar");
		checkExpr("true", "lstruct.ashort <= lstruct.aushort");
		checkExpr("true", "lstruct.aint <= lstruct.asint");
		checkExpr("true", "lstruct.along <= lstruct.aulong");
		checkExpr("true", "lstruct.aulonglong <= lstruct.aslonglong");
		checkExpr("true", "lstruct.afloat <= lstruct.adouble");
		// <
		checkExpr("false", "lstruct.achar < 49");
		checkExpr("false", "lstruct.ashort < 4");
		checkExpr("false", "lstruct.aint < 7");
		checkExpr("false", "lstruct.along < 10");
		checkExpr("false", "lstruct.aslonglong < 14");
		checkExpr("false", "lstruct.afloat < 15.0F");
		checkExpr("false", "lstruct.adouble < 16.0");
		checkExpr("true", "lstruct.achar < lstruct.aschar");
		checkExpr("true", "lstruct.ashort < lstruct.aushort");
		checkExpr("true", "lstruct.aint < lstruct.asint");
		checkExpr("true", "lstruct.along < lstruct.aulong");
		checkExpr("true", "lstruct.aulonglong < lstruct.aslonglong");
		checkExpr("true", "lstruct.afloat < lstruct.adouble");
		// &&
		checkExpr("true", "lstruct.achar && 49");
		checkExpr("true", "lstruct.ashort && 4");
		checkExpr("true", "lstruct.aint && 7");
		checkExpr("true", "lstruct.along && 10");
		checkExpr("true", "lstruct.aslonglong && 14");
		checkExpr("true", "lstruct.afloat && 15.0F");
		checkExpr("true", "lstruct.adouble && 16.0");
		checkExpr("true", "lstruct.achar || lstruct.aschar");
		checkExpr("true", "lstruct.ashort || lstruct.aushort");
		checkExpr("true", "lstruct.aint || lstruct.asint");
		checkExpr("true", "lstruct.along || lstruct.aulong");
		checkExpr("true", "lstruct.aulonglong || lstruct.aslonglong");
		checkExpr("true", "lstruct.afloat || lstruct.adouble");
		// ||
		checkExpr("true", "lstruct.achar || 49");
		checkExpr("true", "lstruct.ashort || 4");
		checkExpr("true", "lstruct.aint || 7");
		checkExpr("true", "lstruct.along || 10");
		checkExpr("true", "lstruct.aslonglong || 14");
		checkExpr("true", "lstruct.afloat || 15.0F");
		checkExpr("true", "lstruct.adouble || 16.0");
		checkExpr("true", "lstruct.achar || lstruct.aschar");
		checkExpr("true", "lstruct.ashort || lstruct.aushort");
		checkExpr("true", "lstruct.aint || lstruct.asint");
		checkExpr("true", "lstruct.along || lstruct.aulong");
		checkExpr("true", "lstruct.aulonglong || lstruct.aslonglong");
		checkExpr("true", "lstruct.afloat || lstruct.adouble");

		// arithmetic operations
		// &
		checkExpr("49", "lstruct.achar & 49");
		checkExpr("4", "lstruct.ashort & 4");
		checkExpr("7", "lstruct.aint & 7");
		checkExpr("10", "lstruct.along & 10");
		checkExpr("14", "lstruct.aslonglong & 14");
		checkExpr("0.0", "lstruct.afloat & 15.0F");
		checkExpr("0.0", "lstruct.adouble & 16.0");
		// |
		checkExpr("49", "lstruct.achar | 0");
		checkExpr("4", "lstruct.ashort | 0");
		checkExpr("7", "lstruct.aint | 0");
		checkExpr("10", "lstruct.along | 0");
		checkExpr("14", "lstruct.aslonglong | 0");
		checkExpr("0.0", "lstruct.afloat | 0.0F");
		checkExpr("0.0", "lstruct.adouble | 0.0");
		// ^
		checkExpr("49", "lstruct.achar ^ 0");
		checkExpr("4", "lstruct.ashort ^ 0");
		checkExpr("7", "lstruct.aint ^ 0");
		checkExpr("10", "lstruct.along ^ 0");
		checkExpr("14", "lstruct.aslonglong ^ 0");
		checkExpr("0.0", "lstruct.afloat ^ 0.0F");
		checkExpr("0.0", "lstruct.adouble ^ 0.0");
		// +
		checkExpr("50", "lstruct.achar + 1");
		checkExpr("5", "lstruct.ashort + 1");
		checkExpr("8", "lstruct.aint + 1");
		checkExpr("11", "lstruct.along + 1");
		checkExpr("15", "lstruct.aslonglong + 1");
		checkExpr("16.0", "lstruct.afloat + 1.0F");
		checkExpr("17.0", "lstruct.adouble + 1.0");
		// -
		checkExpr("48", "lstruct.achar - 1");
		checkExpr("3", "lstruct.ashort - 1");
		checkExpr("6", "lstruct.aint - 1");
		checkExpr("9", "lstruct.along - 1");
		checkExpr("13", "lstruct.aslonglong - 1");
		checkExpr("14.0", "lstruct.afloat - 1.0F");
		checkExpr("15.0", "lstruct.adouble - 1.0");
		// *
		checkExpr("98", "lstruct.achar * 2");
		checkExpr("8", "lstruct.ashort * 2");
		checkExpr("14", "lstruct.aint * 2");
		checkExpr("20", "lstruct.along * 2");
		checkExpr("28", "lstruct.aslonglong * 2");
		checkExpr("30.0", "lstruct.afloat * 2.0F");
		checkExpr("32.0", "lstruct.adouble * 2.0");
		// /
		checkExpr("24", "lstruct.achar / 2");
		checkExpr("2", "lstruct.ashort / 2");
		checkExpr("3", "lstruct.aint / 2");
		checkExpr("5", "lstruct.along / 2");
		checkExpr("7", "lstruct.aslonglong / 2");
		checkExpr("7.5", "lstruct.afloat / 2.0F");
		checkExpr("8.0", "lstruct.adouble / 2.0");
		// %
		checkExpr("1", "lstruct.achar % 2");
		checkExpr("0", "lstruct.ashort % 2");
		checkExpr("1", "lstruct.aint % 2");
		checkExpr("0", "lstruct.along % 2");
		checkExpr("0", "lstruct.aslonglong % 2");
		checkExpr("1.0", "lstruct.afloat % 2.0F");
		checkExpr("0.0", "lstruct.adouble % 2.0");
		// <<
		checkExpr("98", "lstruct.achar << 1");
		checkExpr("8", "lstruct.ashort << 1");
		checkExpr("14", "lstruct.aint << 1");
		checkExpr("20", "lstruct.along << 1");
		checkExpr("28", "lstruct.aslonglong << 1");
		checkExpr("0.0", "lstruct.afloat << 1");
		checkExpr("0.0", "lstruct.adouble << 1");
		// >>
		checkExpr("24", "lstruct.achar >> 1");
		checkExpr("2", "lstruct.ashort >> 1");
		checkExpr("3", "lstruct.aint >> 1");
		checkExpr("5", "lstruct.along >> 1");
		checkExpr("7", "lstruct.aslonglong >> 1");
		checkExpr("0.0", "lstruct.afloat >> 1");
		checkExpr("0.0", "lstruct.adouble >> 1");

		// unary operations
		// +
		checkExpr(intType, "49", "+lstruct.achar");
		checkExpr(intType, "4", "+lstruct.ashort");
		checkExpr(intType, "7", "+lstruct.aint");
		checkExpr(longType, "10", "+lstruct.along");
		checkExpr("14", "+lstruct.aslonglong");
		checkExpr(floatType, "15.0", "+lstruct.afloat");
		checkExpr(doubleType, "16.0", "+lstruct.adouble");
		// -
		checkExpr(intType, "-49", "-lstruct.achar");
		checkExpr("-4", "-lstruct.ashort");
		checkExpr("-7", "-lstruct.aint");
		checkExpr("-10", "-lstruct.along");
		checkExpr("-14", "-lstruct.aslonglong");
		checkExpr("-15.0", "-lstruct.afloat");
		checkExpr("-16.0", "-lstruct.adouble");
		// !
		checkExpr("false", "!lstruct.achar");
		checkExpr("false", "!lstruct.ashort");
		checkExpr("false", "!lstruct.aint");
		checkExpr("false", "!lstruct.along");
		checkExpr("false", "!lstruct.aslonglong");
		checkExpr("false", "!lstruct.afloat");
		checkExpr("false", "!lstruct.adouble");
		// ~
		checkExpr("-5", "~lstruct.ashort");
		checkExpr("-8", "~lstruct.aint");
		checkExpr("-11", "~lstruct.along");
		checkExpr("-15", "~lstruct.aslonglong");
		checkExpr("0.0", "~lstruct.afloat");
		checkExpr("0.0", "~lstruct.adouble");
	}

	/*
	 * Note: This assumes you are at a breakpoint where:
	 * 
	 * int larray[40];
	 * 
	 * larray[0] = 40;
	 * larray[1] = 39;
	 * larray[2] = 38;
	 * ....
	 * larray[37] = 3;
	 * larray[38] = 2;
	 * larray[39] = 1;
	 * l2darray[0,0] = 791555372;
	 * l2darray[0,1] = 858927408;
	 * l2darray[0,2] = 926299444;
	 * l2darray[0,3] = 993671480;
	 * l2darray[0,4] = 4072408;
	 * l2darray[0,5] = 1128415552;
	 * l2darray[0,6] = 2089865082;
	 * l2darray[0,7] = 2089919139;
	 * l2darray[0,8] = 4294967295;
	 * l2darray[0,9] = 2291288;
	 */
	@Test
	public void testExpressionsWithArrays() throws Exception {
		openSnapshotAndWaitForSuspendedContext(1);

		checkExprNoError("larray");
		checkExprNoError("&larray");
		checkExprNoError("l2darray");
		checkExprNoError("&l2darray");

		checkExpr("0", "larray[0]");
		checkExpr("1", "larray[1]");
		checkExpr("2", "larray[2]");
		checkExpr("37", "larray[37]");
		checkExpr("38", "larray[38]");
		checkExpr("39", "larray[39]");
		checkExpr("2089865082", "l2darray[0][6]");

		// logical operations
		// ==
		checkExpr("true", "larray[0] == 0");
		checkExpr("false", "larray[0] == 1");
		checkExpr("true", "39 == larray[39]");
		checkExpr("false", "larray[39] == 40");
		checkExpr("false", "larray[0] == larray[39]");
		checkExpr("true", "4294967295 == l2darray[0][8]");
		// !=
		checkExpr("true", "larray[0] != 1");
		checkExpr("false", "larray[0] != 0");
		checkExpr("true", "40 != larray[39]");
		checkExpr("false", "larray[39] != 39");
		checkExpr("true", "larray[0] != larray[39]");
		// >=
		checkExpr("true", "larray[0] >= 0");
		checkExpr("false", "larray[0] >= 41");
		checkExpr("true", "larray[39] >= 1");
		checkExpr("false", "38 >= larray[39]");
		checkExpr("false", "larray[0] >= larray[39]");
		// >
		checkExpr("true", "larray[0] > -1");
		checkExpr("false", "larray[0] > 40");
		checkExpr("true", "larray[39] > 0");
		checkExpr("false", "38 > larray[39]");
		checkExpr("false", "larray[0] > larray[39]");
		// <=
		checkExpr("true", "larray[0] <= 40");
		checkExpr("false", "larray[0] <= -1");
		checkExpr("true", "38 <= larray[39]");
		checkExpr("false", "larray[39] <= 0");
		checkExpr("true", "larray[0] <= larray[39]");
		// <
		checkExpr("true", "larray[0] < 41");
		checkExpr("false", "larray[0] < -1");
		checkExpr("true", "larray[39] < 40");
		checkExpr("false", "larray[39] < 1");
		checkExpr("true", "larray[0] < larray[39]");
		// &&
		checkExpr("false", "larray[0] && 40");
		checkExpr("true", "1 && larray[39]");
		checkExpr("false", "larray[0] && larray[39]");
		// ||
		checkExpr("true", "larray[0] || 40");
		checkExpr("true", "larray[39] || 1");
		checkExpr("true", "larray[0] || larray[39]");

		// arithmetic operations
		// &
		checkExpr("1", "larray[39] & 1");
		checkExpr("0", "larray[0] & larray[39]");
		// |
		checkExpr("0", "larray[0] | 0");
		checkExpr("39", "0 | larray[39]");
		checkExpr("39", "larray[1] | larray[38]");
		// ^
		checkExpr("0", "larray[0] ^ 0");
		checkExpr("39", "larray[39] ^ 0");
		checkExpr("38", "larray[1] ^ larray[39]");
		// +
		checkExpr("1", "larray[0] + 1");
		checkExpr("40", "1 + larray[39]");
		checkExpr("39", "larray[0] + larray[39]");
		// -
		checkExpr("-1", "larray[0] - 1");
		checkExpr("38", "larray[39] - 1");
		checkExpr("-39", "larray[0] - larray[39]");
		// *
		checkExpr("2", "larray[1] * 2");
		checkExpr("78", "2 * larray[39]");
		checkExpr("39", "larray[1] * larray[39]");
		// /
		checkExpr("0", "larray[0] / 2");
		checkExpr("19", "larray[39] / 2");
		checkExpr("39", "larray[39] / larray[1]");
		// %
		checkExpr("0", "larray[0] % 2");
		checkExpr("1", "larray[39] % 2");
		checkExpr("1", "larray[1] % larray[39]");
		// <<
		checkExpr("0", "larray[0] << 1");
		checkExpr("78", "larray[39] << 1");
		checkExpr("16", "larray[2] << larray[3]");
		// >>
		checkExpr("0", "larray[0] >> 1");
		checkExpr("19", "larray[39] >> 1");
		checkExpr("4", "larray[39] >> larray[3]");

		// unary operations
		// +
		checkExpr("0", "+larray[0]");
		checkExpr("39", "+larray[39]");
		// -
		checkExpr("0", "-larray[0]");
		checkExpr("-39", "-larray[39]");
		// !
		checkExpr("true", "!larray[0]");
		checkExpr("false", "!larray[39]");
		// ~
		checkExpr("-2", "~larray[1]");
		checkExpr("-40", "~larray[39]");
	}

	/*
	 *	Note: This assumes you are at a breakpoint where:
	 *
	 *	typedef union {
	 *		volatile int x;
	 *		volatile long y;
	 *	} union_type;
	 *
	 *	union_type lunion;
	 *
	 *	lunion.x = 2;
	 *	lunion.y = 2;
	 */
	@Test
	public void testExpressionsWithUnions() throws Exception {
		openSnapshotAndWaitForSuspendedContext(2);

		checkExprNoError("lunion");
		checkExprNoError("&lunion");
		checkExpr("2", "lunion.x");
		checkExpr("2", "lunion.y");

		// logical operations
		// ==
		checkExpr("true", "lunion.x == 2");
		checkExpr("false", "lunion.x == 1");
		checkExpr("true", "lunion.y == 2");
		checkExpr("false", "lunion.y == 1");
		checkExpr("true", "lunion.x == lunion.y");
		// !=
		checkExpr("false", "lunion.x != 2");
		checkExpr("true", "lunion.x != 1");
		checkExpr("false", "lunion.y != 2");
		checkExpr("true", "lunion.y != 1");
		checkExpr("false", "lunion.x != lunion.y");
		// >=
		checkExpr("true", "lunion.x >= 2");
		checkExpr("false", "lunion.x >= 3");
		checkExpr("true", "lunion.y >= 2");
		checkExpr("true", "2 >= lunion.y");
		checkExpr("false", "lunion.y >= 3");
		checkExpr("true", "lunion.x >= lunion.y");
		// >
		checkExpr("false", "lunion.x > 2");
		checkExpr("true", "lunion.x > 1");
		checkExpr("false", "lunion.y > 2");
		checkExpr("true", "lunion.y > 1");
		checkExpr("false", "lunion.x > lunion.y");
		// <=
		checkExpr("true", "lunion.x <= 2");
		checkExpr("false", "lunion.x <= 1");
		checkExpr("true", "lunion.y <= 2");
		checkExpr("false", "lunion.y <= 1");
		checkExpr("true", "lunion.x <= lunion.y");
		// <
		checkExpr("false", "lunion.x < 2");
		checkExpr("true", "lunion.x < 3");
		checkExpr("false", "lunion.y < 2");
		checkExpr("true", "lunion.y < 3");
		checkExpr("false", "lunion.x < lunion.y");
		// &&
		checkExpr("true", "lunion.x && 2");
		checkExpr("true", "1 && lunion.x");
		checkExpr("false", "lunion.x && 0");
		checkExpr("false", "0 && lunion.x");
		checkExpr("true", "lunion.y && 2");
		checkExpr("true", "1 && lunion.y");
		checkExpr("true", "lunion.x && lunion.y");
		// ||
		checkExpr("true", "lunion.x || 2");
		checkExpr("true", "lunion.x || 1");
		checkExpr("true", "lunion.y || 2");
		checkExpr("true", "lunion.y || 1");
		checkExpr("true", "lunion.x || lunion.y");

		// arithmetic operations
		// &
		checkExpr("2", "lunion.x & 2");
		checkExpr("0", "lunion.x & 1");
		checkExpr("2", "lunion.y & 2");
		checkExpr("0", "lunion.y & 1");
		checkExpr("2", "lunion.x & lunion.y");
		// |
		checkExpr("2", "lunion.x | 2");
		checkExpr("3", "lunion.x | 1");
		checkExpr("2", "lunion.y | 2");
		checkExpr("3", "lunion.y | 1");
		checkExpr("2", "lunion.x | lunion.y");
		// ^
		checkExpr("0", "lunion.x ^ 2");
		checkExpr("3", "lunion.x ^ 1");
		checkExpr("0", "lunion.y ^ 2");
		checkExpr("3", "lunion.y ^ 1");
		checkExpr("0", "lunion.x ^ lunion.y");
		// +
		checkExpr("4", "lunion.x + 2");
		checkExpr("3", "lunion.x + 1");
		checkExpr("4", "lunion.y + 2");
		checkExpr("3", "lunion.y + 1");
		checkExpr("4", "lunion.x + lunion.y");
		// -
		checkExpr("0", "lunion.x - 2");
		checkExpr("1", "lunion.x - 1");
		checkExpr("0", "lunion.y - 2");
		checkExpr("1", "lunion.y - 1");
		checkExpr("0", "lunion.x - lunion.y");
		// *
		checkExpr("4", "lunion.x * 2");
		checkExpr("2", "lunion.x * 1");
		checkExpr("4", "lunion.y * 2");
		checkExpr("2", "lunion.y * 1");
		checkExpr("4", "lunion.x * lunion.y");
		// /
		checkExpr("1", "lunion.x / 2");
		checkExpr("2", "lunion.x / 1");
		checkExpr("1", "lunion.y / 2");
		checkExpr("2", "lunion.y / 1");
		checkExpr("1", "lunion.x / lunion.y");
		// %
		checkExpr("0", "lunion.x % 2");
		checkExpr("0", "lunion.x % 1");
		checkExpr("0", "lunion.y % 2");
		checkExpr("0", "lunion.y % 1");
		checkExpr("0", "lunion.x % lunion.y");
		// <<
		checkExpr("8", "lunion.x << 2");
		checkExpr("4", "lunion.x << 1");
		checkExpr("8", "lunion.y << 2");
		checkExpr("4", "lunion.y << 1");
		checkExpr("8", "lunion.x << lunion.y");
		// >>
		checkExpr("0", "lunion.x >> 2");
		checkExpr("1", "lunion.x >> 1");
		checkExpr("0", "lunion.y >> 2");
		checkExpr("1", "lunion.y >> 1");
		checkExpr("0", "lunion.x >> lunion.y");

		// unary operations
		// +
		checkExpr("2", "+lunion.x");
		checkExpr("2", "+lunion.y");
		// -
		checkExpr("-2", "-lunion.x");
		checkExpr("-2", "-lunion.y");
		// !
		checkExpr("false", "!lunion.x");
		checkExpr("false", "!lunion.y");
		checkExpr("true", "!!lunion.y");
		// ~
		checkExpr("-3", "~lunion.x");
		checkExpr("-3", "~lunion.y");
	}

	/*
	 *	Note: This assumes you are at a breakpoint where:
	 *
	 *	typedef struct {
	 *		volatile unsigned x:1;
	 *		volatile unsigned y:2;
	 *		volatile unsigned z:3;
	 *		volatile unsigned w:16;
	 *	} bitfield_type;
	 *
	 *	bitfield_type lbitfield;
	 *
	 *	lbitfield.x = 1;
	 *	lbitfield.y = 2;
	 *	lbitfield.z = 3;
	 *	lbitfield.w = 26;
	 */
	@Test
	public void testExpressionsWithBitfields() throws Exception {
		openSnapshotAndWaitForSuspendedContext(3);

		checkExprNoError("lbitfield");
		checkExpr("1", "lbitfield.x");
		checkExpr("2", "lbitfield.y");
		checkExpr("3", "lbitfield.z");
		checkExpr("26", "lbitfield.w");

		// logical operations
		// ==
		checkExpr("true", "lbitfield.x == 1");
		checkExpr("false", "lbitfield.x == 0");
		checkExpr("true", "lbitfield.y == 2");
		checkExpr("false", "lbitfield.y == 0");
		checkExpr("false", "lbitfield.x == lbitfield.y");
		// !=
		checkExpr("true", "lbitfield.x != 0");
		checkExpr("false", "lbitfield.x != 1");
		checkExpr("true", "lbitfield.y != 0");
		checkExpr("false", "lbitfield.y != 2");
		checkExpr("true", "lbitfield.x != lbitfield.y");
		// >=
		checkExpr("true", "lbitfield.x >= 1");
		checkExpr("false", "lbitfield.x >= 2");
		checkExpr("true", "lbitfield.y >= 2");
		checkExpr("false", "lbitfield.y >= 3");
		checkExpr("false", "lbitfield.x >= lbitfield.y");
		// >
		checkExpr("true", "lbitfield.x > 0");
		checkExpr("false", "lbitfield.x > 1");
		checkExpr("true", "lbitfield.y > 1");
		checkExpr("false", "lbitfield.y > 2");
		checkExpr("false", "lbitfield.x > lbitfield.y");
		// <=
		checkExpr("true", "lbitfield.x <= 1");
		checkExpr("false", "lbitfield.x <= 0");
		checkExpr("true", "lbitfield.y <= 2");
		checkExpr("false", "lbitfield.y <= 1");
		checkExpr("true", "lbitfield.x <= lbitfield.y");
		// <
		checkExpr("true", "lbitfield.x < 2");
		checkExpr("false", "lbitfield.x < 1");
		checkExpr("true", "lbitfield.y < 3");
		checkExpr("false", "lbitfield.y < 2");
		checkExpr("true", "lbitfield.x < lbitfield.y");
		// &&
		checkExpr("true", "lbitfield.x && 2");
		checkExpr("true", "lbitfield.x && 1");
		checkExpr("true", "lbitfield.y && 3");
		checkExpr("true", "lbitfield.y && 2");
		checkExpr("true", "lbitfield.x && lbitfield.y");
		// ||
		checkExpr("true", "lbitfield.x || 2");
		checkExpr("true", "lbitfield.x || 1");
		checkExpr("true", "lbitfield.y || 3");
		checkExpr("true", "lbitfield.y || 2");
		checkExpr("true", "lbitfield.x || lbitfield.y");

		// arithmetic operations
		// &
		checkExpr("0", "lbitfield.x & 0");
		checkExpr("1", "lbitfield.x & 1");
		checkExpr("0", "lbitfield.y & 0");
		checkExpr("2", "lbitfield.y & 2");
		checkExpr("0", "lbitfield.x & lbitfield.y");
		// |
		checkExpr("1", "lbitfield.x | 0");
		checkExpr("1", "lbitfield.x | 1");
		checkExpr("2", "lbitfield.y | 0");
		checkExpr("2", "lbitfield.y | 2");
		checkExpr("3", "lbitfield.x | lbitfield.y");
		// ^
		checkExpr("1", "lbitfield.x ^ 0");
		checkExpr("0", "lbitfield.x ^ 1");
		checkExpr("2", "lbitfield.y ^ 0");
		checkExpr("0", "lbitfield.y ^ 2");
		checkExpr("3", "lbitfield.x ^ lbitfield.y");
		// +
		checkExpr("0", "lbitfield.x + (-1)");
		checkExpr("2", "lbitfield.x + 1");
		checkExpr("1", "lbitfield.y + (-1)");
		checkExpr("3", "lbitfield.y + 1");
		checkExpr("3", "lbitfield.x + lbitfield.y");
		// -
		checkExpr("2", "lbitfield.x - (-1)");
		checkExpr("0", "lbitfield.x - 1");
		checkExpr("3", "lbitfield.y - (-1)");
		checkExpr("1", "lbitfield.y - 1");
		checkExpr("-1", "lbitfield.x - lbitfield.y");
		// *
		checkExpr("0", "lbitfield.x * 0");
		checkExpr("1", "lbitfield.x * 1");
		checkExpr("0", "lbitfield.y * 0");
		checkExpr("4", "lbitfield.y * 2");
		checkExpr("2", "lbitfield.x * lbitfield.y");
		// /
		checkExprError(ASTEvalMessages.DivideByZero, "lbitfield.x / 0");
		checkExpr("1", "lbitfield.x / 1");
		checkExprError(ASTEvalMessages.DivideByZero, "lbitfield.y / 0");
		checkExpr("1", "lbitfield.y / 2");
		checkExpr("0", "lbitfield.x / lbitfield.y");
		// %
		checkExprError(ASTEvalMessages.DivideByZero, "lbitfield.x % 0");
		checkExpr("0", "lbitfield.x % 1");
		checkExprError(ASTEvalMessages.DivideByZero, "lbitfield.y % 0");
		checkExpr("0", "lbitfield.y % 2");
		checkExpr("1", "lbitfield.x % lbitfield.y");
		// <<
		checkExpr("1", "lbitfield.x << 0");
		checkExpr("2", "lbitfield.x << 1");
		checkExpr("2", "lbitfield.y << 0");
		checkExpr("4", "lbitfield.y << 1");
		checkExpr("4", "lbitfield.x << lbitfield.y");
		// >>
		checkExpr("1", "lbitfield.x >> 0");
		checkExpr("0", "lbitfield.x >> 1");
		checkExpr("2", "lbitfield.y >> 0");
		checkExpr("1", "lbitfield.y >> 1");
		checkExpr("0", "lbitfield.x >> lbitfield.y");

		// unary operations
		// +
		checkExpr("1", "+lbitfield.x");
		checkExpr("2", "+lbitfield.y");
		checkExpr("3", "+lbitfield.z");
		checkExpr("26", "+lbitfield.w");
		// -
		checkExpr("-1", "-lbitfield.x");
		checkExpr("-2", "-lbitfield.y");
		checkExpr("-3", "-lbitfield.z");
		checkExpr("-26", "-lbitfield.w");
		// !
		checkExpr("false", "!lbitfield.x");
		checkExpr("false", "!lbitfield.y");
		checkExpr("false", "!lbitfield.z");
		checkExpr("false", "!lbitfield.w");
		checkExpr("true", "!!lbitfield.w");
		// ~
		checkExpr("-2", "~lbitfield.x");
		checkExpr("-3", "~lbitfield.y");
		checkExpr("-4", "~lbitfield.z");
		checkExpr("-27", "~lbitfield.w");
	}

	/*
	 *	Note: This assumes you are at a breakpoint where:
	 *
	 *	enum enum_type { zero, one, two, three, four };
	 *
	 *	enum enum_type lenum;
	 *
	 *	lenum = three;
	 */
	@Test
	public void testExpressionsWithEnums() throws Exception {
		openSnapshotAndWaitForSuspendedContext(4);

		checkExprNoError("lenum");
		checkExpr("three [3]", "lenum");

		// logical operations
		// ==
		checkExpr("true", "lenum == 3");
		checkExpr("true", "lenum == three");
		checkExpr("false", "lenum == 4");
		checkExpr("false", "lenum == four");
		// !=
		checkExpr("true", "lenum != 4");
		checkExpr("true", "lenum != four");
		checkExpr("false", "lenum != 3");
		checkExpr("false", "lenum != three");
		// >=
		checkExpr("true", "lenum >= 3");
		checkExpr("true", "lenum >= three");
		checkExpr("false", "lenum >= 5");
		// >
		checkExpr("true", "lenum > 2");
		checkExpr("true", "lenum > two");
		checkExpr("false", "lenum > 4");
		checkExpr("false", "lenum > four");
		// <=
		checkExpr("true", "lenum <= 3");
		checkExpr("false", "lenum <= 2");
		// <
		checkExpr("true", "lenum < 5");
		checkExpr("false", "lenum < 3");
		// &&
		checkExpr("true", "lenum && 4");
		checkExpr("true", "lenum && 1");
		// ||
		checkExpr("true", "lenum || 4");
		checkExpr("true", "lenum || 1");

		// arithmetic operations
		// &
		checkExpr("0", "lenum & 4");
		checkExpr("3", "lenum & 3");
		// |
		checkExpr("7", "lenum | 4");
		checkExpr("3", "lenum | 3");
		// ^
		checkExpr("7", "lenum ^ 4");
		checkExpr("0", "lenum ^ 3");
		// +
		checkExpr("7", "lenum + 4");
		checkExpr("6", "lenum + 3");
		checkExpr("6", "lenum + three");
		// -
		checkExpr("-1", "lenum - 4");
		checkExpr("0", "lenum - 3");
		// *
		checkExpr("12", "lenum * 4");
		checkExpr("9", "lenum * 3");
		// /
		checkExpr("0", "lenum / 4");
		checkExpr("1", "lenum / 3");
		// %
		checkExpr("3", "lenum % 4");
		checkExpr("0", "lenum % 3");
		// <<
		checkExpr("12", "lenum << 2");
		checkExpr("24", "lenum << three");
		// >>
		checkExpr("0", "lenum >> 4");
		checkExpr("0", "lenum >> 3");

		// unary operations
		// +
		checkExpr("3", "+lenum");
		// -
		checkExpr("-3", "-lenum");
		// !
		checkExpr("false", "!lenum");
		checkExpr("true", "!!lenum");
		// ~
		checkExpr("-4", "~lenum");
	}


	@Override
	public String getAlbumName() {
		return "ExpressionsAggregatesAndEnums.dsa";
	}

}