org.eclipse.jdt.apt.tests/src/org/eclipse/jdt/apt/tests/annotations/valueconversion/ValueConversionProcessor.java - jdt/eclipse.jdt.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2007 BEA Systems, Inc.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    tyeung@bea.com - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.apt.tests.annotations.valueconversion;

 import java.util.Collection;
 import java.util.List;
 import java.util.Map;

 import junit.framework.TestCase;

 import org.eclipse.jdt.apt.tests.annotations.BaseProcessor;

 import com.sun.mirror.apt.AnnotationProcessorEnvironment;
 import com.sun.mirror.apt.Messager;
 import com.sun.mirror.declaration.AnnotationMirror;
 import com.sun.mirror.declaration.AnnotationTypeElementDeclaration;
 import com.sun.mirror.declaration.AnnotationValue;
 import com.sun.mirror.declaration.TypeDeclaration;
 import com.sun.mirror.type.AnnotationType;

 public class ValueConversionProcessor extends BaseProcessor {

 	public static final Byte BYTE_49 = 49;
 	public static final Byte BYTE_50 = 50;
 	public static final Character CHAR_ONE = '1';
 	public static final Character CHAR_TWO = '2';
 	public static final Double DOUBLE_49 = 49d;
 	public static final Double DOUBLE_50 = 50d;
 	public static final Float FLOAT_49 = 49f;
 	public static final Float FLOAT_50 = 50f;
 	public static final Integer INTEGER_49 = 49;
 	public static final Integer INTEGER_50 = 50;
 	public static final Long LONG_49 = 49l;
 	public static final Long LONG_50 = 50l;
 	public static final Short SHORT_49 = 49;
 	public static final Short SHORT_50 = 50;

 	public ValueConversionProcessor(AnnotationProcessorEnvironment env)
 	{
 		super(env);
 	}

 	@SuppressWarnings("nls")
 	public void process()
 	{
 		final TypeDeclaration test = _env.getTypeDeclaration("sample.Test");
 		if( test == null )
 			TestCase.assertNotNull("failed to locate type 'sample.Test'", test);

 		testCompilerAPIPath(test);
 		testReflectionPath(test);
 	}

 	private void testCompilerAPIPath(TypeDeclaration test){
 		final Collection<AnnotationMirror> annotations = test.getAnnotationMirrors();
 		final int numAnnotations = annotations == null ? 0 : annotations.size();
 		TestCase.assertEquals("annotation number mismatch", 1, numAnnotations);

 		final AnnotationMirror annotation = annotations.iterator().next();
 		final AnnotationType annotationType = annotation.getAnnotationType();
 		final String annoTypeName = annotationType.getDeclaration().getQualifiedName();
 		if( !Annotation.class.getName().equals( annoTypeName ) &&
 			!AnnotationWithArray.class.getName().equals( annoTypeName ))
 			return;

 		final Map<AnnotationTypeElementDeclaration, AnnotationValue> elementValues =
 			annotation.getElementValues();

 		for( Map.Entry<AnnotationTypeElementDeclaration, AnnotationValue> entry :
 			 elementValues.entrySet() ){
 			AnnotationTypeElementDeclaration elementDecl = entry.getKey();
 			final String name = elementDecl.getSimpleName();
 			final AnnotationValue value = entry.getValue();
 			compare(name, value.getValue());
 		}
 	}

 	private void testReflectionPath(TypeDeclaration test){
 		final RefAnnotation refAnno = test.getAnnotation(RefAnnotation.class);
 		if( refAnno != null ){
 			assertValueMatch("z", refAnno.z(), true);
 			assertValueMatch("b", refAnno.b(), (byte)49);
 			assertValueMatch("c", refAnno.c(), '1');
 			assertValueMatch("d", refAnno.d(), 49);
 			assertValueMatch("f", refAnno.f(), 49);
 			assertValueMatch("i", refAnno.i(), 49);
 			assertValueMatch("l", refAnno.l(), 49);
 			assertValueMatch("s", refAnno.s(), (short)49);
 		}
 		final RefAnnotationWithArray refAnnoArray = test.getAnnotation(RefAnnotationWithArray.class);
 		if( refAnnoArray != null ){
 			assertArrayValueMatch("booleans", refAnnoArray.booleans(), new boolean[]{true, true});
 			assertArrayValueMatch("bytes", refAnnoArray.bytes(), new byte[]{49, 50} );
 			assertArrayValueMatch("chars", refAnnoArray.chars(), new char[]{'1', '2'});
 			assertArrayValueMatch("doubles", refAnnoArray.doubles(), new double[]{49d, 50d});
 			assertArrayValueMatch("floats", refAnnoArray.floats(), new float[]{49f, 50f});
 			assertArrayValueMatch("ints", refAnnoArray.ints(), new int[]{49, 50});
 			assertArrayValueMatch("longs", refAnnoArray.longs(), new long[]{49l, 50l});
 			assertArrayValueMatch("shorts", refAnnoArray.shorts(), new short[]{49, 50});
 			compare("str", refAnnoArray.str());
 		}
 	}

 	private void compare(final String name, final Object actualValue){
 		if( name.length() == 1 )
 		{
 			final Class<?> expectedType;
 			final Object expectedValue;
 			switch(name.charAt(0))
 			{
 			case 'z':
 				expectedType = Boolean.class;
 				expectedValue = Boolean.TRUE;
 				break;
 			case 'b':
 				expectedType = Byte.class;
 				expectedValue = BYTE_49;
 				break;
 			case 'c':
 				expectedType = Character.class;
 				expectedValue = CHAR_ONE;
 				break;
 			case 's':
 				expectedType = Short.class;
 				expectedValue = SHORT_49;
 				break;
 			case 'i':
 				expectedType = Integer.class;
 				expectedValue = INTEGER_49;
 				break;
 			case 'l':
 				expectedType = Long.class;
 				expectedValue = LONG_49;
 				break;
 			case 'f':
 				expectedType = Float.class;
 				expectedValue = FLOAT_49;
 				break;
 			case 'd':
 				expectedType = Double.class;
 				expectedValue = DOUBLE_49;
 				break;
 			default:
 				TestCase.assertNotNull("unexpected member " + name, null);
 				throw new IllegalStateException(); // won't get here.
 			}
 			assertValueTypeMatch(name, actualValue, expectedType, expectedValue);
 		}
 		else{
 			final Class<?> expectedElementType;
 			final Object[] expectedElementValues;
 			if( "booleans".equals(name) ){
 				expectedElementType = Boolean.class;
 				expectedElementValues = new Object[]{Boolean.TRUE, Boolean.TRUE};
 			}
 			else if( "chars".equals(name) ){
 				expectedElementType = Character.class;
 				expectedElementValues = new Object[]{CHAR_ONE, CHAR_TWO};
 			}
 			else if( "bytes".equals(name) ){
 				expectedElementType = Byte.class;
 				expectedElementValues = new Object[]{BYTE_49, BYTE_50};
 			}
 			else if( "shorts".equals(name) ){
 				expectedElementType = Short.class;
 				expectedElementValues = new Object[]{SHORT_49, SHORT_50};
 			}
 			else if( "ints".equals(name) ){
 				expectedElementType = Integer.class;
 				expectedElementValues = new Object[]{INTEGER_49, INTEGER_50};
 			}
 			else if( "longs".equals(name) ){
 				expectedElementType = Long.class;
 				expectedElementValues = new Object[]{LONG_49, LONG_50};
 			}
 			else if( "floats".equals(name) ){
 				expectedElementType = Float.class;
 				expectedElementValues = new Object[]{FLOAT_49, FLOAT_50};

 			}
 			else if( "doubles".equals(name) ){
 				expectedElementType = Double.class;
 				expectedElementValues = new Object[]{DOUBLE_49, DOUBLE_50};
 			}
 			else if( "str".equals(name) ){
 				assertValueTypeMatch(name, actualValue, String.class, "string");
 				return;
 			}
 			else{
 				TestCase.assertNotNull("unexpected member " + name, null);
 				throw new IllegalStateException(); // won't get here.
 			}
 			@SuppressWarnings("unchecked")
 			List<AnnotationValue> actualList = (List<AnnotationValue>)actualValue;
 			assertArrayValueTypeMatch(name, actualList, expectedElementType, expectedElementValues);
 		}
 	}

 	private void assertValueTypeMatch(
 			final String name,
 			final Object actualValue,
 			final Class<?> expectedType,
 			final Object expectedValue)
 	{
 		if( actualValue != null && expectedType != actualValue.getClass() ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("type mismatch for member " + name +
 					" expected " + expectedType.getName() + " but got " + actualValue.getClass().getName());
 		}
 		else if( !expectedValue.equals(actualValue) ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expectedValue + " but got " + actualValue);
 		}
 	}

 	private void assertArrayValueTypeMatch(
 			final String name,
 			final List<AnnotationValue> actualValues,
 			final Class<?> expectedElementType,
 			final Object[] expectedValues)
 	{
 		int i=0;
 		for( AnnotationValue av : actualValues ){
 			assertValueTypeMatch(name, av.getValue(), expectedElementType, expectedValues[i] );
 			i++;
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final boolean actual,
 			final boolean expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final byte actual,
 			final byte expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final char actual,
 			final char expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final double actual,
 			final double expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final float actual,
 			final float expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final int actual,
 			final int expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final long actual,
 			final long expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}

 	private void assertValueMatch(
 			final String name,
 			final short actual,
 			final short expected){

 		if( actual != expected ){
 			final Messager msgr = _env.getMessager();
 			msgr.printError("value mismatch for member " + name +
 					" expected " + expected + " but got " + actual);
 		}
 	}


 	private void assertArrayValueMatch(
 			final String name,
 			final boolean[] actual,
 			final boolean[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( boolean a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final byte[] actual,
 			final byte[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( byte a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final char[] actual,
 			final char[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( char a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final double[] actual,
 			final double[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( double a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final float[] actual,
 			final float[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( float a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final int[] actual,
 			final int[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( int a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final long[] actual,
 			final long[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( long a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}

 	private void assertArrayValueMatch(
 			final String name,
 			final short[] actual,
 			final short[] expected){

 		int i=0;
 		final Messager msgr = _env.getMessager();
 		for( short a : actual ){
 			if( a != expected[i] ){
 				msgr.printError("value mismatch for member " + name +
 						" expected " + expected[i] + " but got " + a);
 			}
 			i++;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2007 BEA Systems, Inc.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* tyeung@bea.com - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.apt.tests.annotations.valueconversion;

	import java.util.Collection;
	import java.util.List;
	import java.util.Map;

	import junit.framework.TestCase;

	import org.eclipse.jdt.apt.tests.annotations.BaseProcessor;

	import com.sun.mirror.apt.AnnotationProcessorEnvironment;
	import com.sun.mirror.apt.Messager;
	import com.sun.mirror.declaration.AnnotationMirror;
	import com.sun.mirror.declaration.AnnotationTypeElementDeclaration;
	import com.sun.mirror.declaration.AnnotationValue;
	import com.sun.mirror.declaration.TypeDeclaration;
	import com.sun.mirror.type.AnnotationType;

	public class ValueConversionProcessor extends BaseProcessor {

	public static final Byte BYTE_49 = 49;
	public static final Byte BYTE_50 = 50;
	public static final Character CHAR_ONE = '1';
	public static final Character CHAR_TWO = '2';
	public static final Double DOUBLE_49 = 49d;
	public static final Double DOUBLE_50 = 50d;
	public static final Float FLOAT_49 = 49f;
	public static final Float FLOAT_50 = 50f;
	public static final Integer INTEGER_49 = 49;
	public static final Integer INTEGER_50 = 50;
	public static final Long LONG_49 = 49l;
	public static final Long LONG_50 = 50l;
	public static final Short SHORT_49 = 49;
	public static final Short SHORT_50 = 50;

	public ValueConversionProcessor(AnnotationProcessorEnvironment env)
	{
	super(env);
	}

	@SuppressWarnings("nls")
	public void process()
	{
	final TypeDeclaration test = _env.getTypeDeclaration("sample.Test");
	if( test == null )
	TestCase.assertNotNull("failed to locate type 'sample.Test'", test);

	testCompilerAPIPath(test);
	testReflectionPath(test);
	}

	private void testCompilerAPIPath(TypeDeclaration test){
	final Collection<AnnotationMirror> annotations = test.getAnnotationMirrors();
	final int numAnnotations = annotations == null ? 0 : annotations.size();
	TestCase.assertEquals("annotation number mismatch", 1, numAnnotations);

	final AnnotationMirror annotation = annotations.iterator().next();
	final AnnotationType annotationType = annotation.getAnnotationType();
	final String annoTypeName = annotationType.getDeclaration().getQualifiedName();
	if( !Annotation.class.getName().equals( annoTypeName ) &&
	!AnnotationWithArray.class.getName().equals( annoTypeName ))
	return;

	final Map<AnnotationTypeElementDeclaration, AnnotationValue> elementValues =
	annotation.getElementValues();

	for( Map.Entry<AnnotationTypeElementDeclaration, AnnotationValue> entry :
	elementValues.entrySet() ){
	AnnotationTypeElementDeclaration elementDecl = entry.getKey();
	final String name = elementDecl.getSimpleName();
	final AnnotationValue value = entry.getValue();
	compare(name, value.getValue());
	}
	}

	private void testReflectionPath(TypeDeclaration test){
	final RefAnnotation refAnno = test.getAnnotation(RefAnnotation.class);
	if( refAnno != null ){
	assertValueMatch("z", refAnno.z(), true);
	assertValueMatch("b", refAnno.b(), (byte)49);
	assertValueMatch("c", refAnno.c(), '1');
	assertValueMatch("d", refAnno.d(), 49);
	assertValueMatch("f", refAnno.f(), 49);
	assertValueMatch("i", refAnno.i(), 49);
	assertValueMatch("l", refAnno.l(), 49);
	assertValueMatch("s", refAnno.s(), (short)49);
	}
	final RefAnnotationWithArray refAnnoArray = test.getAnnotation(RefAnnotationWithArray.class);
	if( refAnnoArray != null ){
	assertArrayValueMatch("booleans", refAnnoArray.booleans(), new boolean[]{true, true});
	assertArrayValueMatch("bytes", refAnnoArray.bytes(), new byte[]{49, 50} );
	assertArrayValueMatch("chars", refAnnoArray.chars(), new char[]{'1', '2'});
	assertArrayValueMatch("doubles", refAnnoArray.doubles(), new double[]{49d, 50d});
	assertArrayValueMatch("floats", refAnnoArray.floats(), new float[]{49f, 50f});
	assertArrayValueMatch("ints", refAnnoArray.ints(), new int[]{49, 50});
	assertArrayValueMatch("longs", refAnnoArray.longs(), new long[]{49l, 50l});
	assertArrayValueMatch("shorts", refAnnoArray.shorts(), new short[]{49, 50});
	compare("str", refAnnoArray.str());
	}
	}

	private void compare(final String name, final Object actualValue){
	if( name.length() == 1 )
	{
	final Class<?> expectedType;
	final Object expectedValue;
	switch(name.charAt(0))
	{
	case 'z':
	expectedType = Boolean.class;
	expectedValue = Boolean.TRUE;
	break;
	case 'b':
	expectedType = Byte.class;
	expectedValue = BYTE_49;
	break;
	case 'c':
	expectedType = Character.class;
	expectedValue = CHAR_ONE;
	break;
	case 's':
	expectedType = Short.class;
	expectedValue = SHORT_49;
	break;
	case 'i':
	expectedType = Integer.class;
	expectedValue = INTEGER_49;
	break;
	case 'l':
	expectedType = Long.class;
	expectedValue = LONG_49;
	break;
	case 'f':
	expectedType = Float.class;
	expectedValue = FLOAT_49;
	break;
	case 'd':
	expectedType = Double.class;
	expectedValue = DOUBLE_49;
	break;
	default:
	TestCase.assertNotNull("unexpected member " + name, null);
	throw new IllegalStateException(); // won't get here.
	}
	assertValueTypeMatch(name, actualValue, expectedType, expectedValue);
	}
	else{
	final Class<?> expectedElementType;
	final Object[] expectedElementValues;
	if( "booleans".equals(name) ){
	expectedElementType = Boolean.class;
	expectedElementValues = new Object[]{Boolean.TRUE, Boolean.TRUE};
	}
	else if( "chars".equals(name) ){
	expectedElementType = Character.class;
	expectedElementValues = new Object[]{CHAR_ONE, CHAR_TWO};
	}
	else if( "bytes".equals(name) ){
	expectedElementType = Byte.class;
	expectedElementValues = new Object[]{BYTE_49, BYTE_50};
	}
	else if( "shorts".equals(name) ){
	expectedElementType = Short.class;
	expectedElementValues = new Object[]{SHORT_49, SHORT_50};
	}
	else if( "ints".equals(name) ){
	expectedElementType = Integer.class;
	expectedElementValues = new Object[]{INTEGER_49, INTEGER_50};
	}
	else if( "longs".equals(name) ){
	expectedElementType = Long.class;
	expectedElementValues = new Object[]{LONG_49, LONG_50};
	}
	else if( "floats".equals(name) ){
	expectedElementType = Float.class;
	expectedElementValues = new Object[]{FLOAT_49, FLOAT_50};

	}
	else if( "doubles".equals(name) ){
	expectedElementType = Double.class;
	expectedElementValues = new Object[]{DOUBLE_49, DOUBLE_50};
	}
	else if( "str".equals(name) ){
	assertValueTypeMatch(name, actualValue, String.class, "string");
	return;
	}
	else{
	TestCase.assertNotNull("unexpected member " + name, null);
	throw new IllegalStateException(); // won't get here.
	}
	@SuppressWarnings("unchecked")
	List<AnnotationValue> actualList = (List<AnnotationValue>)actualValue;
	assertArrayValueTypeMatch(name, actualList, expectedElementType, expectedElementValues);
	}
	}

	private void assertValueTypeMatch(
	final String name,
	final Object actualValue,
	final Class<?> expectedType,
	final Object expectedValue)
	{
	if( actualValue != null && expectedType != actualValue.getClass() ){
	final Messager msgr = _env.getMessager();
	msgr.printError("type mismatch for member " + name +
	" expected " + expectedType.getName() + " but got " + actualValue.getClass().getName());
	}
	else if( !expectedValue.equals(actualValue) ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expectedValue + " but got " + actualValue);
	}
	}

	private void assertArrayValueTypeMatch(
	final String name,
	final List<AnnotationValue> actualValues,
	final Class<?> expectedElementType,
	final Object[] expectedValues)
	{
	int i=0;
	for( AnnotationValue av : actualValues ){
	assertValueTypeMatch(name, av.getValue(), expectedElementType, expectedValues[i] );
	i++;
	}
	}

	private void assertValueMatch(
	final String name,
	final boolean actual,
	final boolean expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final byte actual,
	final byte expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final char actual,
	final char expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final double actual,
	final double expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final float actual,
	final float expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final int actual,
	final int expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final long actual,
	final long expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}

	private void assertValueMatch(
	final String name,
	final short actual,
	final short expected){

	if( actual != expected ){
	final Messager msgr = _env.getMessager();
	msgr.printError("value mismatch for member " + name +
	" expected " + expected + " but got " + actual);
	}
	}


	private void assertArrayValueMatch(
	final String name,
	final boolean[] actual,
	final boolean[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( boolean a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final byte[] actual,
	final byte[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( byte a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final char[] actual,
	final char[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( char a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final double[] actual,
	final double[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( double a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final float[] actual,
	final float[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( float a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final int[] actual,
	final int[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( int a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final long[] actual,
	final long[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( long a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}

	private void assertArrayValueMatch(
	final String name,
	final short[] actual,
	final short[] expected){

	int i=0;
	final Messager msgr = _env.getMessager();
	for( short a : actual ){
	if( a != expected[i] ){
	msgr.printError("value mismatch for member " + name +
	" expected " + expected[i] + " but got " + a);
	}
	i++;
	}
	}
	}