LongOperatorsTests.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 LongOperatorsTests extends Tests {

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

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

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

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

	public void testLongPlusByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + plusOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long plus byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus byte : wrong result : ", xLongValue + yByteValue, longValue);

		value = eval(yLong + plusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long plus byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus byte : wrong result : ", yLongValue + xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongPlusChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + plusOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long plus char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus char : wrong result : ", xLongValue + yCharValue, longValue);

		value = eval(yLong + plusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long plus char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus char : wrong result : ", yLongValue + xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongPlusShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + plusOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long plus short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus short : wrong result : ", xLongValue + yShortValue, longValue);

		value = eval(yLong + plusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long plus short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus short : wrong result : ", yLongValue + xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongPlusInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + plusOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long plus int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus int : wrong result : ", xLongValue + yIntValue, longValue);

		value = eval(yLong + plusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long plus int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long plus int : wrong result : ", yLongValue + xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

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

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

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

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

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

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

	public void testLongMinusByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + minusOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long minus byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus byte : wrong result : ", xLongValue - yByteValue, longValue);

		value = eval(yLong + minusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long minus byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus byte : wrong result : ", yLongValue - xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMinusChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + minusOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long minus char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus char : wrong result : ", xLongValue - yCharValue, longValue);

		value = eval(yLong + minusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long minus char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus char : wrong result : ", yLongValue - xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMinusShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + minusOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long minus short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus short : wrong result : ", xLongValue - yShortValue, longValue);

		value = eval(yLong + minusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long minus short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus short : wrong result : ", yLongValue - xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMinusInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + minusOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long minus int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus int : wrong result : ", xLongValue - yIntValue, longValue);

		value = eval(yLong + minusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long minus int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long minus int : wrong result : ", yLongValue - xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

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

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

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

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

	public void testLongMultiplyByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + multiplyOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long multiply byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply byte : wrong result : ", xLongValue * yByteValue, longValue);

		value = eval(yLong + multiplyOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long multiply byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply byte : wrong result : ", yLongValue * xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMultiplyChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + multiplyOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long multiply char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply char : wrong result : ", xLongValue * yCharValue, longValue);

		value = eval(yLong + multiplyOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long multiply char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply char : wrong result : ", yLongValue * xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMultiplyShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + multiplyOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long multiply short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply short : wrong result : ", xLongValue * yShortValue, longValue);

		value = eval(yLong + multiplyOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long multiply short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply short : wrong result : ", yLongValue * xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongMultiplyInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + multiplyOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long multiply int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply int : wrong result : ", xLongValue * yIntValue, longValue);

		value = eval(yLong + multiplyOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long multiply int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long multiply int : wrong result : ", yLongValue * xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

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

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

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

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

	public void testLongDivideByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + divideOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long divide byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide byte : wrong result : ", xLongValue / yByteValue, longValue);

		value = eval(yLong + divideOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long divide byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide byte : wrong result : ", yLongValue / xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongDivideChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + divideOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long divide char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide char : wrong result : ", xLongValue / yCharValue, longValue);

		value = eval(yLong + divideOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long divide char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide char : wrong result : ", yLongValue / xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongDivideShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + divideOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long divide short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide short : wrong result : ", xLongValue / yShortValue, longValue);

		value = eval(yLong + divideOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long divide short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide short : wrong result : ", yLongValue / xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongDivideInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + divideOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long divide int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide int : wrong result : ", xLongValue / yIntValue, longValue);

		value = eval(yLong + divideOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long divide int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long divide int : wrong result : ", yLongValue / xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

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

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

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

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

	public void testLongRemainderByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + remainderOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long remainder byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder byte : wrong result : ", xLongValue % yByteValue, longValue);

		value = eval(yLong + remainderOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long remainder byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder byte : wrong result : ", yLongValue % xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRemainderChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + remainderOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long remainder char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder char : wrong result : ", xLongValue % yCharValue, longValue);

		value = eval(yLong + remainderOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long remainder char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder char : wrong result : ", yLongValue % xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRemainderShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + remainderOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long remainder short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder short : wrong result : ", xLongValue % yShortValue, longValue);

		value = eval(yLong + remainderOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long remainder short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder short : wrong result : ", yLongValue % xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRemainderInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + remainderOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long remainder int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder int : wrong result : ", xLongValue % yIntValue, longValue);

		value = eval(yLong + remainderOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long remainder int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long remainder int : wrong result : ", yLongValue % xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	public void testLongLeftShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + leftShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long leftShift byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift byte : wrong result : ", xLongValue << yByteValue, longValue);

		value = eval(yLong + leftShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long leftShift byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift byte : wrong result : ", yLongValue << xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongLeftShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + leftShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long leftShift char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift char : wrong result : ", xLongValue << yCharValue, longValue);

		value = eval(yLong + leftShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long leftShift char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift char : wrong result : ", yLongValue << xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongLeftShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + leftShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long leftShift short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift short : wrong result : ", xLongValue << yShortValue, longValue);

		value = eval(yLong + leftShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long leftShift short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift short : wrong result : ", yLongValue << xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongLeftShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + leftShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long leftShift int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift int : wrong result : ", xLongValue << yIntValue, longValue);

		value = eval(yLong + leftShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long leftShift int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift int : wrong result : ", yLongValue << xIntValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongLeftShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + leftShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("long leftShift long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift long : wrong result : ", xLongValue << yLongValue, longValue);

		value = eval(yLong + leftShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("long leftShift long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long leftShift long : wrong result : ", yLongValue << xLongValue, longValue);
		} finally {
		end();
		}
	}

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

	public void testLongRightShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + rightShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long rightShift byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift byte : wrong result : ", xLongValue >> yByteValue, longValue);

		value = eval(yLong + rightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long rightShift byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift byte : wrong result : ", yLongValue >> xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRightShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + rightShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long rightShift char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift char : wrong result : ", xLongValue >> yCharValue, longValue);

		value = eval(yLong + rightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long rightShift char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift char : wrong result : ", yLongValue >> xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRightShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + rightShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long rightShift short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift short : wrong result : ", xLongValue >> yShortValue, longValue);

		value = eval(yLong + rightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long rightShift short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift short : wrong result : ", yLongValue >> xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRightShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + rightShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long rightShift int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift int : wrong result : ", xLongValue >> yIntValue, longValue);

		value = eval(yLong + rightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long rightShift int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift int : wrong result : ", yLongValue >> xIntValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongRightShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + rightShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("long rightShift long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift long : wrong result : ", xLongValue >> yLongValue, longValue);

		value = eval(yLong + rightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("long rightShift long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long rightShift long : wrong result : ", yLongValue >> xLongValue, longValue);
		} finally {
		end();
		}
	}

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

	public void testLongUnsignedRightShiftByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + unsignedRightShiftOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift byte : wrong result : ", xLongValue >>> yByteValue, longValue);

		value = eval(yLong + unsignedRightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift byte : wrong result : ", yLongValue >>> xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongUnsignedRightShiftChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + unsignedRightShiftOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift char : wrong result : ", xLongValue >>> yCharValue, longValue);

		value = eval(yLong + unsignedRightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift char : wrong result : ", yLongValue >>> xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongUnsignedRightShiftShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + unsignedRightShiftOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift short : wrong result : ", xLongValue >>> yShortValue, longValue);

		value = eval(yLong + unsignedRightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift short : wrong result : ", yLongValue >>> xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongUnsignedRightShiftInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + unsignedRightShiftOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift int : wrong result : ", xLongValue >>> yIntValue, longValue);

		value = eval(yLong + unsignedRightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift int : wrong result : ", yLongValue >>> xIntValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongUnsignedRightShiftLong() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + unsignedRightShiftOp + yLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift long : wrong result : ", xLongValue >>> yLongValue, longValue);

		value = eval(yLong + unsignedRightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("long unsignedRightShift long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long unsignedRightShift long : wrong result : ", yLongValue >>> xLongValue, longValue);
		} finally {
		end();
		}
	}

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

	public void testLongOrByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + orOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long or byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or byte : wrong result : ", xLongValue | yByteValue, longValue);

		value = eval(yLong + orOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long or byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or byte : wrong result : ", yLongValue | xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongOrChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + orOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long or char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or char : wrong result : ", xLongValue | yCharValue, longValue);

		value = eval(yLong + orOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long or char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or char : wrong result : ", yLongValue | xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongOrShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + orOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long or short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or short : wrong result : ", xLongValue | yShortValue, longValue);

		value = eval(yLong + orOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long or short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or short : wrong result : ", yLongValue | xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongOrInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + orOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long or int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or int : wrong result : ", xLongValue | yIntValue, longValue);

		value = eval(yLong + orOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long or int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long or int : wrong result : ", yLongValue | xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

	public void testLongAndByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + andOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long and byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and byte : wrong result : ", xLongValue & yByteValue, longValue);

		value = eval(yLong + andOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long and byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and byte : wrong result : ", yLongValue & xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongAndChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + andOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long and char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and char : wrong result : ", xLongValue & yCharValue, longValue);

		value = eval(yLong + andOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long and char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and char : wrong result : ", yLongValue & xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongAndShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + andOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long and short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and short : wrong result : ", xLongValue & yShortValue, longValue);

		value = eval(yLong + andOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long and short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and short : wrong result : ", yLongValue & xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongAndInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + andOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long and int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and int : wrong result : ", xLongValue & yIntValue, longValue);

		value = eval(yLong + andOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long and int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long and int : wrong result : ", yLongValue & xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

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

	public void testLongXorByte() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + xorOp + yByte);
		String typeName = value.getReferenceTypeName();
		assertEquals("long xor byte : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor byte : wrong result : ", xLongValue ^ yByteValue, longValue);

		value = eval(yLong + xorOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("long xor byte : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor byte : wrong result : ", yLongValue ^ xByteValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongXorChar() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + xorOp + yChar);
		String typeName = value.getReferenceTypeName();
		assertEquals("long xor char : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor char : wrong result : ", xLongValue ^ yCharValue, longValue);

		value = eval(yLong + xorOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("long xor char : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor char : wrong result : ", yLongValue ^ xCharValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongXorShort() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + xorOp + yShort);
		String typeName = value.getReferenceTypeName();
		assertEquals("long xor short : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor short : wrong result : ", xLongValue ^ yShortValue, longValue);

		value = eval(yLong + xorOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("long xor short : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor short : wrong result : ", yLongValue ^ xShortValue, longValue);
		} finally {
		end();
		}
	}

	public void testLongXorInt() throws Throwable {
		try {
		init();
		IValue value = eval(xLong + xorOp + yInt);
		String typeName = value.getReferenceTypeName();
		assertEquals("long xor int : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor int : wrong result : ", xLongValue ^ yIntValue, longValue);

		value = eval(yLong + xorOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("long xor int : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("long xor int : wrong result : ", yLongValue ^ xIntValue, longValue);
		} finally {
		end();
		}
	}

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

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

	// + long

	public void testPlusLong() throws Throwable {
		try {
		init();
		IValue value = eval(plusOp + xLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("plus long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("plus long : wrong result : ", + xLongValue, longValue);

		value = eval(plusOp + yLong);
		typeName = value.getReferenceTypeName();
		assertEquals("plus long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("plus long : wrong result : ", + yLongValue, longValue);
		} finally {
		end();
		}
	}

	// - long

	public void testMinusLong() throws Throwable {
		try {
		init();
		IValue value = eval(minusOp + xLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("minus long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("minus long : wrong result : ", - xLongValue, longValue);

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

	// ~ long

	public void testTwiddleLong() throws Throwable {
		try {
		init();
		IValue value = eval(twiddleOp + xLong);
		String typeName = value.getReferenceTypeName();
		assertEquals("twiddle long : wrong type : ", "long", typeName);
		long longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("twiddle long : wrong result : ", ~ xLongValue, longValue);

		value = eval(twiddleOp + yLong);
		typeName = value.getReferenceTypeName();
		assertEquals("twiddle long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("twiddle long : wrong result : ", ~ yLongValue, longValue);
		} finally {
		end();
		}
	}


}