ByteOperatorsTests.java

/*******************************************************************************
 *  Copyright (c) 2002, 2008 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.debug.tests.eval;

import org.eclipse.debug.core.model.IValue;
import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
import org.eclipse.jdt.internal.debug.core.model.JDIObjectValue;

public class ByteOperatorsTests extends Tests {

	public ByteOperatorsTests(String arg) {
		super(arg);
	}

	protected void init() throws Exception {
		initializeFrame("EvalSimpleTests",15,1);
	}

	protected void end() throws Exception {
		destroyFrame();
	}

	// byte + {byte, char, short, int, long, float, double}

	public void testBytePlusByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus byte : wrong result : ", xByteValue + yByteValue, intValue);

		value = eval(yByte + plusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus byte : wrong result : ", yByteValue + xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testBytePlusChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus char : wrong result : ", xByteValue + yCharValue, intValue);

		value = eval(yByte + plusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus char : wrong result : ", yByteValue + xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testBytePlusShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus short : wrong result : ", xByteValue + yShortValue, intValue);

		value = eval(yByte + plusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus short : wrong result : ", yByteValue + xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testBytePlusInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus int : wrong result : ", xByteValue + yIntValue, intValue);

		value = eval(yByte + plusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte plus int : wrong result : ", yByteValue + xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testBytePlusLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte plus long : wrong result : ", xByteValue + yLongValue, longValue);

		value = eval(yByte + plusOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte plus long : wrong result : ", yByteValue + xLongValue, longValue);
		} finally {
		end();
		}
	}

	public void testBytePlusFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus float : wrong type : ", "float", typeName);
		float floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte plus float : wrong result : ", xByteValue + yFloatValue, floatValue, 0);

		value = eval(yByte + plusOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte plus float : wrong result : ", yByteValue + xFloatValue, floatValue, 0);
		} finally {
		end();
		}
	}

	public void testBytePlusDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus double : wrong type : ", "double", typeName);
		double doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte plus double : wrong result : ", xByteValue + yDoubleValue, doubleValue, 0);

		value = eval(yByte + plusOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte plus double : wrong result : ", yByteValue + xDoubleValue, doubleValue, 0);
		} finally {
		end();
		}
	}

	public void testBytePlusString() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + plusOp + yString);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte plus java.lang.String : wrong type : ", "java.lang.String", typeName);
		String stringValue = ((JDIObjectValue)value).getValueString();
		assertEquals("byte plus java.lang.String : wrong result : ", xByteValue + yStringValue, stringValue);

		value = eval(yByte + plusOp + xString);
		typeName = value.getReferenceTypeName();
		assertEquals("byte plus java.lang.String : wrong type : ", "java.lang.String", typeName);
		stringValue = ((JDIObjectValue)value).getValueString();
		assertEquals("byte plus java.lang.String : wrong result : ", yByteValue + xStringValue, stringValue);
		} finally {
		end();
		}
	}

	// byte - {byte, char, short, int, long, float, double}

	public void testByteMinusByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus byte : wrong result : ", xByteValue - yByteValue, intValue);

		value = eval(yByte + minusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus byte : wrong result : ", yByteValue - xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMinusChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus char : wrong result : ", xByteValue - yCharValue, intValue);

		value = eval(yByte + minusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus char : wrong result : ", yByteValue - xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMinusShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus short : wrong result : ", xByteValue - yShortValue, intValue);

		value = eval(yByte + minusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus short : wrong result : ", yByteValue - xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMinusInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus int : wrong result : ", xByteValue - yIntValue, intValue);

		value = eval(yByte + minusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte minus int : wrong result : ", yByteValue - xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMinusLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte minus long : wrong result : ", xByteValue - yLongValue, longValue);

		value = eval(yByte + minusOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte minus long : wrong result : ", yByteValue - xLongValue, longValue);
		} finally {
		end();
		}
	}

	public void testByteMinusFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus float : wrong type : ", "float", typeName);
		float floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte minus float : wrong result : ", xByteValue - yFloatValue, floatValue, 0);

		value = eval(yByte + minusOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte minus float : wrong result : ", yByteValue - xFloatValue, floatValue, 0);
		} finally {
		end();
		}
	}

	public void testByteMinusDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + minusOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte minus double : wrong type : ", "double", typeName);
		double doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte minus double : wrong result : ", xByteValue - yDoubleValue, doubleValue, 0);

		value = eval(yByte + minusOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte minus double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte minus double : wrong result : ", yByteValue - xDoubleValue, doubleValue, 0);
		} finally {
		end();
		}
	}

	// byte * {byte, char, short, int, long, float, double}

	public void testByteMultiplyByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply byte : wrong result : ", xByteValue * yByteValue, intValue);

		value = eval(yByte + multiplyOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply byte : wrong result : ", yByteValue * xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMultiplyChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply char : wrong result : ", xByteValue * yCharValue, intValue);

		value = eval(yByte + multiplyOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply char : wrong result : ", yByteValue * xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMultiplyShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply short : wrong result : ", xByteValue * yShortValue, intValue);

		value = eval(yByte + multiplyOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply short : wrong result : ", yByteValue * xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMultiplyInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply int : wrong result : ", xByteValue * yIntValue, intValue);

		value = eval(yByte + multiplyOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte multiply int : wrong result : ", yByteValue * xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteMultiplyLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte multiply long : wrong result : ", xByteValue * yLongValue, longValue);

		value = eval(yByte + multiplyOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte multiply long : wrong result : ", yByteValue * xLongValue, longValue);
		} finally {
		end();
		}
	}

	public void testByteMultiplyFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply float : wrong type : ", "float", typeName);
		float floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte multiply float : wrong result : ", xByteValue * yFloatValue, floatValue, 0);

		value = eval(yByte + multiplyOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte multiply float : wrong result : ", yByteValue * xFloatValue, floatValue, 0);
		} finally {
		end();
		}
	}

	public void testByteMultiplyDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + multiplyOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte multiply double : wrong type : ", "double", typeName);
		double doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte multiply double : wrong result : ", xByteValue * yDoubleValue, doubleValue, 0);

		value = eval(yByte + multiplyOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte multiply double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte multiply double : wrong result : ", yByteValue * xDoubleValue, doubleValue, 0);
		} finally {
		end();
		}
	}

	// byte / {byte, char, short, int, long, float, double}

	public void testByteDivideByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide byte : wrong result : ", xByteValue / yByteValue, intValue);

		value = eval(yByte + divideOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide byte : wrong result : ", yByteValue / xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteDivideChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide char : wrong result : ", xByteValue / yCharValue, intValue);

		value = eval(yByte + divideOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide char : wrong result : ", yByteValue / xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteDivideShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide short : wrong result : ", xByteValue / yShortValue, intValue);

		value = eval(yByte + divideOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide short : wrong result : ", yByteValue / xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteDivideInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide int : wrong result : ", xByteValue / yIntValue, intValue);

		value = eval(yByte + divideOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte divide int : wrong result : ", yByteValue / xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteDivideLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte divide long : wrong result : ", xByteValue / yLongValue, longValue);

		value = eval(yByte + divideOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte divide long : wrong result : ", yByteValue / xLongValue, longValue);
		} finally {
		end();
		}
	}

	public void testByteDivideFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide float : wrong type : ", "float", typeName);
		float floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte divide float : wrong result : ", xByteValue / yFloatValue, floatValue, 0);

		value = eval(yByte + divideOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte divide float : wrong result : ", yByteValue / xFloatValue, floatValue, 0);
		} finally {
		end();
		}
	}

	public void testByteDivideDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + divideOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte divide double : wrong type : ", "double", typeName);
		double doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte divide double : wrong result : ", xByteValue / yDoubleValue, doubleValue, 0);

		value = eval(yByte + divideOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte divide double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte divide double : wrong result : ", yByteValue / xDoubleValue, doubleValue, 0);
		} finally {
		end();
		}
	}

	// byte % {byte, char, short, int, long, float, double}

	public void testByteRemainderByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder byte : wrong result : ", xByteValue % yByteValue, intValue);

		value = eval(yByte + remainderOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder byte : wrong result : ", yByteValue % xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRemainderChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder char : wrong result : ", xByteValue % yCharValue, intValue);

		value = eval(yByte + remainderOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder char : wrong result : ", yByteValue % xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRemainderShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder short : wrong result : ", xByteValue % yShortValue, intValue);

		value = eval(yByte + remainderOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder short : wrong result : ", yByteValue % xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRemainderInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder int : wrong result : ", xByteValue % yIntValue, intValue);

		value = eval(yByte + remainderOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte remainder int : wrong result : ", yByteValue % xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRemainderLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte remainder long : wrong result : ", xByteValue % yLongValue, longValue);

		value = eval(yByte + remainderOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte remainder long : wrong result : ", yByteValue % xLongValue, longValue);
		} finally {
		end();
		}
	}

	public void testByteRemainderFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder float : wrong type : ", "float", typeName);
		float floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte remainder float : wrong result : ", xByteValue % yFloatValue, floatValue, 0);

		value = eval(yByte + remainderOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("byte remainder float : wrong result : ", yByteValue % xFloatValue, floatValue, 0);
		} finally {
		end();
		}
	}

	public void testByteRemainderDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + remainderOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte remainder double : wrong type : ", "double", typeName);
		double doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte remainder double : wrong result : ", xByteValue % yDoubleValue, doubleValue, 0);

		value = eval(yByte + remainderOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte remainder double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("byte remainder double : wrong result : ", yByteValue % xDoubleValue, doubleValue, 0);
		} finally {
		end();
		}
	}

	// byte > {byte, char, short, int, long, float, double}

	public void testByteGreaterByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater byte : wrong result : ", xByteValue > yByteValue, booleanValue);

		value = eval(yByte + greaterOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater byte : wrong result : ", yByteValue > xByteValue, booleanValue);

		value = eval(xByte + greaterOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater byte : wrong result : ", xByteValue > xByteValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater char : wrong result : ", xByteValue > yCharValue, booleanValue);

		value = eval(yByte + greaterOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater char : wrong result : ", yByteValue > xCharValue, booleanValue);

		value = eval(xByte + greaterOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater char : wrong result : ", xByteValue > xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater short : wrong result : ", xByteValue > yShortValue, booleanValue);

		value = eval(yByte + greaterOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater short : wrong result : ", yByteValue > xShortValue, booleanValue);

		value = eval(xByte + greaterOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater short : wrong result : ", xByteValue > xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater int : wrong result : ", xByteValue > yIntValue, booleanValue);

		value = eval(yByte + greaterOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater int : wrong result : ", yByteValue > xIntValue, booleanValue);

		value = eval(xByte + greaterOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater int : wrong result : ", xByteValue > xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater long : wrong result : ", xByteValue > yLongValue, booleanValue);

		value = eval(yByte + greaterOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater long : wrong result : ", yByteValue > xLongValue, booleanValue);

		value = eval(xByte + greaterOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater long : wrong result : ", xByteValue > xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater float : wrong result : ", xByteValue > yFloatValue, booleanValue);

		value = eval(yByte + greaterOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater float : wrong result : ", yByteValue > xFloatValue, booleanValue);

		value = eval(xByte + greaterOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater float : wrong result : ", xByteValue > xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greater double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater double : wrong result : ", xByteValue > yDoubleValue, booleanValue);

		value = eval(yByte + greaterOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater double : wrong result : ", yByteValue > xDoubleValue, booleanValue);

		value = eval(xByte + greaterOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greater double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greater double : wrong result : ", xByteValue > xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte >= {byte, char, short, int, long, float, double}

	public void testByteGreaterEqualByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual byte : wrong result : ", xByteValue >= yByteValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual byte : wrong result : ", yByteValue >= xByteValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual byte : wrong result : ", xByteValue >= xByteValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual char : wrong result : ", xByteValue >= yCharValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual char : wrong result : ", yByteValue >= xCharValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual char : wrong result : ", xByteValue >= xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual short : wrong result : ", xByteValue >= yShortValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual short : wrong result : ", yByteValue >= xShortValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual short : wrong result : ", xByteValue >= xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual int : wrong result : ", xByteValue >= yIntValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual int : wrong result : ", yByteValue >= xIntValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual int : wrong result : ", xByteValue >= xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual long : wrong result : ", xByteValue >= yLongValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual long : wrong result : ", yByteValue >= xLongValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual long : wrong result : ", xByteValue >= xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual float : wrong result : ", xByteValue >= yFloatValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual float : wrong result : ", yByteValue >= xFloatValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual float : wrong result : ", xByteValue >= xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteGreaterEqualDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + greaterEqualOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual double : wrong result : ", xByteValue >= yDoubleValue, booleanValue);

		value = eval(yByte + greaterEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual double : wrong result : ", yByteValue >= xDoubleValue, booleanValue);

		value = eval(xByte + greaterEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte greaterEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte greaterEqual double : wrong result : ", xByteValue >= xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte < {byte, char, short, int, long, float, double}

	public void testByteLessByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less byte : wrong result : ", xByteValue < yByteValue, booleanValue);

		value = eval(yByte + lessOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less byte : wrong result : ", yByteValue < xByteValue, booleanValue);

		value = eval(xByte + lessOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less byte : wrong result : ", xByteValue < xByteValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less char : wrong result : ", xByteValue < yCharValue, booleanValue);

		value = eval(yByte + lessOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less char : wrong result : ", yByteValue < xCharValue, booleanValue);

		value = eval(xByte + lessOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less char : wrong result : ", xByteValue < xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less short : wrong result : ", xByteValue < yShortValue, booleanValue);

		value = eval(yByte + lessOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less short : wrong result : ", yByteValue < xShortValue, booleanValue);

		value = eval(xByte + lessOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less short : wrong result : ", xByteValue < xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less int : wrong result : ", xByteValue < yIntValue, booleanValue);

		value = eval(yByte + lessOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less int : wrong result : ", yByteValue < xIntValue, booleanValue);

		value = eval(xByte + lessOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less int : wrong result : ", xByteValue < xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less long : wrong result : ", xByteValue < yLongValue, booleanValue);

		value = eval(yByte + lessOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less long : wrong result : ", yByteValue < xLongValue, booleanValue);

		value = eval(xByte + lessOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less long : wrong result : ", xByteValue < xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less float : wrong result : ", xByteValue < yFloatValue, booleanValue);

		value = eval(yByte + lessOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less float : wrong result : ", yByteValue < xFloatValue, booleanValue);

		value = eval(xByte + lessOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less float : wrong result : ", xByteValue < xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte less double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less double : wrong result : ", xByteValue < yDoubleValue, booleanValue);

		value = eval(yByte + lessOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less double : wrong result : ", yByteValue < xDoubleValue, booleanValue);

		value = eval(xByte + lessOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte less double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte less double : wrong result : ", xByteValue < xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte <= {byte, char, short, int, long, float, double}

	public void testByteLessEqualByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual byte : wrong result : ", xByteValue <= yByteValue, booleanValue);

		value = eval(yByte + lessEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual byte : wrong result : ", yByteValue <= xByteValue, booleanValue);

		value = eval(xByte + lessEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual byte : wrong result : ", xByteValue <= xByteValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual char : wrong result : ", xByteValue <= yCharValue, booleanValue);

		value = eval(yByte + lessEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual char : wrong result : ", yByteValue <= xCharValue, booleanValue);

		value = eval(xByte + lessEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual char : wrong result : ", xByteValue <= xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual short : wrong result : ", xByteValue <= yShortValue, booleanValue);

		value = eval(yByte + lessEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual short : wrong result : ", yByteValue <= xShortValue, booleanValue);

		value = eval(xByte + lessEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual short : wrong result : ", xByteValue <= xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual int : wrong result : ", xByteValue <= yIntValue, booleanValue);

		value = eval(yByte + lessEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual int : wrong result : ", yByteValue <= xIntValue, booleanValue);

		value = eval(xByte + lessEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual int : wrong result : ", xByteValue <= xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual long : wrong result : ", xByteValue <= yLongValue, booleanValue);

		value = eval(yByte + lessEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual long : wrong result : ", yByteValue <= xLongValue, booleanValue);

		value = eval(xByte + lessEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual long : wrong result : ", xByteValue <= xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual float : wrong result : ", xByteValue <= yFloatValue, booleanValue);

		value = eval(yByte + lessEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual float : wrong result : ", yByteValue <= xFloatValue, booleanValue);

		value = eval(xByte + lessEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual float : wrong result : ", xByteValue <= xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteLessEqualDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + lessEqualOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual double : wrong result : ", xByteValue <= yDoubleValue, booleanValue);

		value = eval(yByte + lessEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual double : wrong result : ", yByteValue <= xDoubleValue, booleanValue);

		value = eval(xByte + lessEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte lessEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte lessEqual double : wrong result : ", xByteValue <= xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte == {byte, char, short, int, long, float, double}

	public void testByteEqualEqualByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual byte : wrong result : ", xByteValue == yByteValue, booleanValue);

		value = eval(yByte + equalEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual byte : wrong result : ", yByteValue == xByteValue, booleanValue);

		value = eval(xByte + equalEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual byte : wrong result : ", true, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual char : wrong result : ", xByteValue == yCharValue, booleanValue);

		value = eval(yByte + equalEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual char : wrong result : ", yByteValue == xCharValue, booleanValue);

		value = eval(xByte + equalEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual char : wrong result : ", xByteValue == xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual short : wrong result : ", xByteValue == yShortValue, booleanValue);

		value = eval(yByte + equalEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual short : wrong result : ", yByteValue == xShortValue, booleanValue);

		value = eval(xByte + equalEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual short : wrong result : ", xByteValue == xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual int : wrong result : ", xByteValue == yIntValue, booleanValue);

		value = eval(yByte + equalEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual int : wrong result : ", yByteValue == xIntValue, booleanValue);

		value = eval(xByte + equalEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual int : wrong result : ", xByteValue == xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual long : wrong result : ", xByteValue == yLongValue, booleanValue);

		value = eval(yByte + equalEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual long : wrong result : ", yByteValue == xLongValue, booleanValue);

		value = eval(xByte + equalEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual long : wrong result : ", xByteValue == xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual float : wrong result : ", xByteValue == yFloatValue, booleanValue);

		value = eval(yByte + equalEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual float : wrong result : ", yByteValue == xFloatValue, booleanValue);

		value = eval(xByte + equalEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual float : wrong result : ", xByteValue == xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteEqualEqualDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + equalEqualOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual double : wrong result : ", xByteValue == yDoubleValue, booleanValue);

		value = eval(yByte + equalEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual double : wrong result : ", yByteValue == xDoubleValue, booleanValue);

		value = eval(xByte + equalEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte equalEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte equalEqual double : wrong result : ", xByteValue == xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte != {byte, char, short, int, long, float, double}

	public void testByteNotEqualByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual byte : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual byte : wrong result : ", xByteValue != yByteValue, booleanValue);

		value = eval(yByte + notEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual byte : wrong result : ", yByteValue != xByteValue, booleanValue);

		value = eval(xByte + notEqualOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual byte : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual byte : wrong result : ", false, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual char : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual char : wrong result : ", xByteValue != yCharValue, booleanValue);

		value = eval(yByte + notEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual char : wrong result : ", yByteValue != xCharValue, booleanValue);

		value = eval(xByte + notEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual char : wrong result : ", xByteValue != xCharValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual short : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual short : wrong result : ", xByteValue != yShortValue, booleanValue);

		value = eval(yByte + notEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual short : wrong result : ", yByteValue != xShortValue, booleanValue);

		value = eval(xByte + notEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual short : wrong result : ", xByteValue != xShortValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual int : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual int : wrong result : ", xByteValue != yIntValue, booleanValue);

		value = eval(yByte + notEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual int : wrong result : ", yByteValue != xIntValue, booleanValue);

		value = eval(xByte + notEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual int : wrong result : ", xByteValue != xIntValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual long : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual long : wrong result : ", xByteValue != yLongValue, booleanValue);

		value = eval(yByte + notEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual long : wrong result : ", yByteValue != xLongValue, booleanValue);

		value = eval(xByte + notEqualOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual long : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual long : wrong result : ", xByteValue != xLongValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualFloat() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yFloat);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual float : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual float : wrong result : ", xByteValue != yFloatValue, booleanValue);

		value = eval(yByte + notEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual float : wrong result : ", yByteValue != xFloatValue, booleanValue);

		value = eval(xByte + notEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual float : wrong result : ", xByteValue != xFloatValue, booleanValue);
		} finally {
		end();
		}
	}

	public void testByteNotEqualDouble() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + notEqualOp + yDouble);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual double : wrong type : ", "boolean", typeName);
		boolean booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual double : wrong result : ", xByteValue != yDoubleValue, booleanValue);

		value = eval(yByte + notEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual double : wrong result : ", yByteValue != xDoubleValue, booleanValue);

		value = eval(xByte + notEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("byte notEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("byte notEqual double : wrong result : ", xByteValue != xDoubleValue, booleanValue);
		} finally {
		end();
		}
	}

	// byte << {byte, char, short, int, long}

	public void testByteLeftShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + leftShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift byte : wrong result : ", xByteValue << yByteValue, intValue);

		value = eval(yByte + leftShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift byte : wrong result : ", yByteValue << xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteLeftShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + leftShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift char : wrong result : ", xByteValue << yCharValue, intValue);

		value = eval(yByte + leftShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift char : wrong result : ", yByteValue << xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteLeftShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + leftShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift short : wrong result : ", xByteValue << yShortValue, intValue);

		value = eval(yByte + leftShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift short : wrong result : ", yByteValue << xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteLeftShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + leftShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift int : wrong result : ", xByteValue << yIntValue, intValue);

		value = eval(yByte + leftShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift int : wrong result : ", yByteValue << xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteLeftShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + leftShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift long : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift long : wrong result : ", xByteValue << yLongValue, intValue);

		value = eval(yByte + leftShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte leftShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte leftShift long : wrong result : ", yByteValue << xLongValue, intValue);
		} finally {
		end();
		}
	}

	// byte >> {byte, char, short, int, long}

	public void testByteRightShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + rightShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift byte : wrong result : ", xByteValue >> yByteValue, intValue);

		value = eval(yByte + rightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift byte : wrong result : ", yByteValue >> xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRightShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + rightShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift char : wrong result : ", xByteValue >> yCharValue, intValue);

		value = eval(yByte + rightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift char : wrong result : ", yByteValue >> xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRightShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + rightShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift short : wrong result : ", xByteValue >> yShortValue, intValue);

		value = eval(yByte + rightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift short : wrong result : ", yByteValue >> xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRightShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + rightShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift int : wrong result : ", xByteValue >> yIntValue, intValue);

		value = eval(yByte + rightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift int : wrong result : ", yByteValue >> xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteRightShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + rightShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift long : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift long : wrong result : ", xByteValue >> yLongValue, intValue);

		value = eval(yByte + rightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte rightShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte rightShift long : wrong result : ", yByteValue >> xLongValue, intValue);
		} finally {
		end();
		}
	}

	// byte >>> {byte, char, short, int, long}

	public void testByteUnsignedRightShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + unsignedRightShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift byte : wrong result : ", xByteValue >>> yByteValue, intValue);

		value = eval(yByte + unsignedRightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift byte : wrong result : ", yByteValue >>> xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteUnsignedRightShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + unsignedRightShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift char : wrong result : ", xByteValue >>> yCharValue, intValue);

		value = eval(yByte + unsignedRightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift char : wrong result : ", yByteValue >>> xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteUnsignedRightShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + unsignedRightShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift short : wrong result : ", xByteValue >>> yShortValue, intValue);

		value = eval(yByte + unsignedRightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift short : wrong result : ", yByteValue >>> xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteUnsignedRightShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + unsignedRightShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift int : wrong result : ", xByteValue >>> yIntValue, intValue);

		value = eval(yByte + unsignedRightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift int : wrong result : ", yByteValue >>> xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteUnsignedRightShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + unsignedRightShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift long : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift long : wrong result : ", xByteValue >>> yLongValue, intValue);

		value = eval(yByte + unsignedRightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte unsignedRightShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte unsignedRightShift long : wrong result : ", yByteValue >>> xLongValue, intValue);
		} finally {
		end();
		}
	}

	// byte | {byte, char, short, int, long}

	public void testByteOrByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + orOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte or byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or byte : wrong result : ", xByteValue | yByteValue, intValue);

		value = eval(yByte + orOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte or byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or byte : wrong result : ", yByteValue | xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteOrChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + orOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte or char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or char : wrong result : ", xByteValue | yCharValue, intValue);

		value = eval(yByte + orOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte or char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or char : wrong result : ", yByteValue | xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteOrShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + orOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte or short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or short : wrong result : ", xByteValue | yShortValue, intValue);

		value = eval(yByte + orOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte or short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or short : wrong result : ", yByteValue | xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteOrInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + orOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte or int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or int : wrong result : ", xByteValue | yIntValue, intValue);

		value = eval(yByte + orOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte or int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte or int : wrong result : ", yByteValue | xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteOrLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + orOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte or long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte or long : wrong result : ", xByteValue | yLongValue, longValue);

		value = eval(yByte + orOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte or long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte or long : wrong result : ", yByteValue | xLongValue, longValue);
		} finally {
		end();
		}
	}

	// byte & {byte, char, short, int, long}

	public void testByteAndByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + andOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte and byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and byte : wrong result : ", xByteValue & yByteValue, intValue);

		value = eval(yByte + andOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte and byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and byte : wrong result : ", yByteValue & xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteAndChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + andOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte and char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and char : wrong result : ", xByteValue & yCharValue, intValue);

		value = eval(yByte + andOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte and char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and char : wrong result : ", yByteValue & xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteAndShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + andOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte and short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and short : wrong result : ", xByteValue & yShortValue, intValue);

		value = eval(yByte + andOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte and short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and short : wrong result : ", yByteValue & xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteAndInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + andOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte and int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and int : wrong result : ", xByteValue & yIntValue, intValue);

		value = eval(yByte + andOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte and int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte and int : wrong result : ", yByteValue & xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteAndLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + andOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte and long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte and long : wrong result : ", xByteValue & yLongValue, longValue);

		value = eval(yByte + andOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte and long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte and long : wrong result : ", yByteValue & xLongValue, longValue);
		} finally {
		end();
		}
	}

	// byte ^ {byte, char, short, int, long}

	public void testByteXorByte() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + xorOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte xor byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor byte : wrong result : ", xByteValue ^ yByteValue, intValue);

		value = eval(yByte + xorOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("byte xor byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor byte : wrong result : ", yByteValue ^ xByteValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteXorChar() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + xorOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte xor char : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor char : wrong result : ", xByteValue ^ yCharValue, intValue);

		value = eval(yByte + xorOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("byte xor char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor char : wrong result : ", yByteValue ^ xCharValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteXorShort() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + xorOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte xor short : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor short : wrong result : ", xByteValue ^ yShortValue, intValue);

		value = eval(yByte + xorOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("byte xor short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor short : wrong result : ", yByteValue ^ xShortValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteXorInt() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + xorOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte xor int : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor int : wrong result : ", xByteValue ^ yIntValue, intValue);

		value = eval(yByte + xorOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("byte xor int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("byte xor int : wrong result : ", yByteValue ^ xIntValue, intValue);
		} finally {
		end();
		}
	}

	public void testByteXorLong() throws Throwable {
		try {
		init();
		IValue value = eval(xByte + xorOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("byte xor long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte xor long : wrong result : ", xByteValue ^ yLongValue, longValue);

		value = eval(yByte + xorOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("byte xor long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("byte xor long : wrong result : ", yByteValue ^ xLongValue, longValue);
		} finally {
		end();
		}
	}

	// + byte

	public void testPlusByte() throws Throwable {
		try {
		init();
		IValue value = eval(plusOp + xByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("plus byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("plus byte : wrong result : ", + xByteValue, intValue);

		value = eval(plusOp + yByte);
		typeName = value.getReferenceTypeName();
		assertEquals("plus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("plus byte : wrong result : ", + yByteValue, intValue);
		} finally {
		end();
		}
	}

	// - byte

	public void testMinusByte() throws Throwable {
		try {
		init();
		IValue value = eval(minusOp + xByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("minus byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("minus byte : wrong result : ", - xByteValue, intValue);

		value = eval(minusOp + yByte);
		typeName = value.getReferenceTypeName();
		assertEquals("minus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("minus byte : wrong result : ", - yByteValue, intValue);
		} finally {
		end();
		}
	}

	// ~ byte

	public void testTwiddleByte() throws Throwable {
		try {
		init();
		IValue value = eval(twiddleOp + xByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("twiddle byte : wrong type : ", "int", typeName);
		int intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("twiddle byte : wrong result : ", ~ xByteValue, intValue);

		value = eval(twiddleOp + yByte);
		typeName = value.getReferenceTypeName();
		assertEquals("twiddle byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("twiddle byte : wrong result : ", ~ yByteValue, intValue);
		} finally {
		end();
		}
	}


}