package org.eclipse.jdt.debug.tests.eval;

/**********************************************************************
Copyright (c) 2000, 2002 IBM Corp. and others.
All rights reserved. This program and the accompanying materials
are made available under the terms of the Common Public License v0.5
which accompanies this distribution, and is available at
http://www.eclipse.org/legal/cpl-v05.html

Contributors:
    IBM Corporation - Initial implementation
*********************************************************************/

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 ShortOperatorsTests extends Tests {

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

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

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

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

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

		value = eval(yShort + plusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short plus byte : wrong result : ", yShortValue + xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short plus char : wrong result : ", yShortValue + xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short plus short : wrong result : ", yShortValue + xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short plus int : wrong result : ", yShortValue + xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short plus long : wrong result : ", yShortValue + xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("short plus float : wrong result : ", yShortValue + xFloatValue, floatValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("short plus double : wrong result : ", yShortValue + xDoubleValue, doubleValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + plusOp + xString);
		typeName = value.getReferenceTypeName();
		assertEquals("short plus java.lang.String : wrong type : ", "java.lang.String", typeName);
		stringValue = ((JDIObjectValue)value).getValueString();
		assertEquals("short plus java.lang.String : wrong result : ", yShortValue + xStringValue, stringValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + minusOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short minus byte : wrong result : ", yShortValue - xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short minus char : wrong result : ", yShortValue - xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short minus short : wrong result : ", yShortValue - xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short minus int : wrong result : ", yShortValue - xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short minus long : wrong result : ", yShortValue - xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("short minus float : wrong result : ", yShortValue - xFloatValue, floatValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + minusOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short minus double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("short minus double : wrong result : ", yShortValue - xDoubleValue, doubleValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + multiplyOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short multiply byte : wrong result : ", yShortValue * xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short multiply char : wrong result : ", yShortValue * xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short multiply short : wrong result : ", yShortValue * xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short multiply int : wrong result : ", yShortValue * xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short multiply long : wrong result : ", yShortValue * xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("short multiply float : wrong result : ", yShortValue * xFloatValue, floatValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + multiplyOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short multiply double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("short multiply double : wrong result : ", yShortValue * xDoubleValue, doubleValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + divideOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short divide byte : wrong result : ", yShortValue / xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short divide char : wrong result : ", yShortValue / xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short divide short : wrong result : ", yShortValue / xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short divide int : wrong result : ", yShortValue / xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short divide long : wrong result : ", yShortValue / xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("short divide float : wrong result : ", yShortValue / xFloatValue, floatValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + divideOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short divide double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("short divide double : wrong result : ", yShortValue / xDoubleValue, doubleValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + remainderOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short remainder byte : wrong result : ", yShortValue % xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short remainder char : wrong result : ", yShortValue % xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short remainder short : wrong result : ", yShortValue % xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short remainder int : wrong result : ", yShortValue % xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short remainder long : wrong result : ", yShortValue % xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder float : wrong type : ", "float", typeName);
		floatValue = ((IJavaPrimitiveValue)value).getFloatValue();
		assertEquals("short remainder float : wrong result : ", yShortValue % xFloatValue, floatValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + remainderOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short remainder double : wrong type : ", "double", typeName);
		doubleValue = ((IJavaPrimitiveValue)value).getDoubleValue();
		assertEquals("short remainder double : wrong result : ", yShortValue % xDoubleValue, doubleValue, 0);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + greaterOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short greater char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greater char : wrong result : ", xShortValue > xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short greater short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greater short : wrong result : ", xShortValue > xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short greater int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greater int : wrong result : ", xShortValue > xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + greaterOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short greater float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greater float : wrong result : ", xShortValue > xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short greater double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greater double : wrong result : ", xShortValue > xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + greaterEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short greaterEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greaterEqual char : wrong result : ", xShortValue >= xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short greaterEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greaterEqual short : wrong result : ", xShortValue >= xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short greaterEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greaterEqual int : wrong result : ", xShortValue >= xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + greaterEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short greaterEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greaterEqual float : wrong result : ", xShortValue >= xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + greaterEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short greaterEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short greaterEqual double : wrong result : ", xShortValue >= xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + lessOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short less char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short less char : wrong result : ", xShortValue < xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short less short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short less short : wrong result : ", xShortValue < xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short less int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short less int : wrong result : ", xShortValue < xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + lessOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short less float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short less float : wrong result : ", xShortValue < xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short less double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short less double : wrong result : ", xShortValue < xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + lessEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short lessEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short lessEqual char : wrong result : ", xShortValue <= xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short lessEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short lessEqual short : wrong result : ", xShortValue <= xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short lessEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short lessEqual int : wrong result : ", xShortValue <= xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + lessEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short lessEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short lessEqual float : wrong result : ", xShortValue <= xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + lessEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short lessEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short lessEqual double : wrong result : ", xShortValue <= xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + equalEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short equalEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short equalEqual char : wrong result : ", xShortValue == xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + equalEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short equalEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short equalEqual short : wrong result : ", xShortValue == xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + equalEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short equalEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short equalEqual int : wrong result : ", xShortValue == xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + equalEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short equalEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short equalEqual float : wrong result : ", xShortValue == xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + equalEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short equalEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short equalEqual double : wrong result : ", xShortValue == xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

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

		value = eval(xShort + notEqualOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short notEqual char : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short notEqual char : wrong result : ", xShortValue != xCharValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + notEqualOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short notEqual short : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short notEqual short : wrong result : ", xShortValue != xShortValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + notEqualOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short notEqual int : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short notEqual int : wrong result : ", xShortValue != xIntValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

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

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

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

		value = eval(xShort + notEqualOp + xFloat);
		typeName = value.getReferenceTypeName();
		assertEquals("short notEqual float : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short notEqual float : wrong result : ", xShortValue != xFloatValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(xShort + notEqualOp + xDouble);
		typeName = value.getReferenceTypeName();
		assertEquals("short notEqual double : wrong type : ", "boolean", typeName);
		booleanValue = ((IJavaPrimitiveValue)value).getBooleanValue();
		assertEquals("short notEqual double : wrong result : ", xShortValue != xDoubleValue, booleanValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + leftShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short leftShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short leftShift byte : wrong result : ", yShortValue << xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + leftShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short leftShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short leftShift char : wrong result : ", yShortValue << xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + leftShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short leftShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short leftShift short : wrong result : ", yShortValue << xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + leftShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short leftShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short leftShift int : wrong result : ", yShortValue << xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + leftShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short leftShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short leftShift long : wrong result : ", yShortValue << xLongValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + rightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short rightShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short rightShift byte : wrong result : ", yShortValue >> xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + rightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short rightShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short rightShift char : wrong result : ", yShortValue >> xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + rightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short rightShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short rightShift short : wrong result : ", yShortValue >> xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + rightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short rightShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short rightShift int : wrong result : ", yShortValue >> xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + rightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short rightShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short rightShift long : wrong result : ", yShortValue >> xLongValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + unsignedRightShiftOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short unsignedRightShift byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short unsignedRightShift byte : wrong result : ", yShortValue >>> xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + unsignedRightShiftOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short unsignedRightShift char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short unsignedRightShift char : wrong result : ", yShortValue >>> xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + unsignedRightShiftOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short unsignedRightShift short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short unsignedRightShift short : wrong result : ", yShortValue >>> xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + unsignedRightShiftOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short unsignedRightShift int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short unsignedRightShift int : wrong result : ", yShortValue >>> xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + unsignedRightShiftOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short unsignedRightShift long : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short unsignedRightShift long : wrong result : ", yShortValue >>> xLongValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + orOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short or byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short or byte : wrong result : ", yShortValue | xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + orOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short or char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short or char : wrong result : ", yShortValue | xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + orOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short or short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short or short : wrong result : ", yShortValue | xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + orOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short or int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short or int : wrong result : ", yShortValue | xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + orOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short or long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short or long : wrong result : ", yShortValue | xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + andOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short and byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short and byte : wrong result : ", yShortValue & xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + andOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short and char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short and char : wrong result : ", yShortValue & xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + andOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short and short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short and short : wrong result : ", yShortValue & xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + andOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short and int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short and int : wrong result : ", yShortValue & xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + andOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short and long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short and long : wrong result : ", yShortValue & xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

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

		value = eval(yShort + xorOp + xByte);
		typeName = value.getReferenceTypeName();
		assertEquals("short xor byte : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short xor byte : wrong result : ", yShortValue ^ xByteValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + xorOp + xChar);
		typeName = value.getReferenceTypeName();
		assertEquals("short xor char : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short xor char : wrong result : ", yShortValue ^ xCharValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + xorOp + xShort);
		typeName = value.getReferenceTypeName();
		assertEquals("short xor short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short xor short : wrong result : ", yShortValue ^ xShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + xorOp + xInt);
		typeName = value.getReferenceTypeName();
		assertEquals("short xor int : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("short xor int : wrong result : ", yShortValue ^ xIntValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

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

		value = eval(yShort + xorOp + xLong);
		typeName = value.getReferenceTypeName();
		assertEquals("short xor long : wrong type : ", "long", typeName);
		longValue = ((IJavaPrimitiveValue)value).getLongValue();
		assertEquals("short xor long : wrong result : ", yShortValue ^ xLongValue, longValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

	// + short

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

		value = eval(plusOp + yShort);
		typeName = value.getReferenceTypeName();
		assertEquals("plus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("plus short : wrong result : ", + yShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

	// - short

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

		value = eval(minusOp + yShort);
		typeName = value.getReferenceTypeName();
		assertEquals("minus short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("minus short : wrong result : ", - yShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}

	// ~ short

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

		value = eval(twiddleOp + yShort);
		typeName = value.getReferenceTypeName();
		assertEquals("twiddle short : wrong type : ", "int", typeName);
		intValue = ((IJavaPrimitiveValue)value).getIntValue();
		assertEquals("twiddle short : wrong result : ", ~ yShortValue, intValue);
		} catch (Throwable e) {
		e.printStackTrace(); throw e;
		} finally {;
		end();
		}
	}


}