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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// + char

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

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

	// - char

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

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

	// ~ char

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

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


}