tests/org.eclipse.jem.tests/javatests/org/eclipse/jem/tests/JDK5ReflectionTests.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jem.tests;

 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.*;

 import junit.framework.TestCase;

 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
 import org.eclipse.jdt.core.*;

 import org.eclipse.jem.internal.adapters.jdom.JavaJDOMAdapterFactory;
 import org.eclipse.jem.java.*;

 /**
  * Test case for testing the reflection of concepts
  * from JDK 5.
  * @since 1.2.2
  *
  */
 public class JDK5ReflectionTests extends TestCase {

 	private static final String PROJECT_NAME = "JDK5Tests"; //$NON-NLS-1$
 	private IJavaProject javaProject;
 	private ResourceSet resourceSet;

 	private boolean oldAutoBuildingState; // autoBuilding state before we started.

 	protected boolean isReflectingSource;

 	/**
 	 *
 	 */
 	public JDK5ReflectionTests() {
 		isReflectingSource = true;
 	}

 	/**
 	 * @param name
 	 */
 	public JDK5ReflectionTests(String name) {
 		super(name);
 		isReflectingSource = true;
 	}

 	protected void setUp() throws Exception {
 		super.setUp();
 		if (isReflectingSource)
 			setUpForSource();
 		else
 			setUpForNoSource();
 	}

 	protected void setUpForSource() throws CoreException, IOException, MalformedURLException {
 		oldAutoBuildingState = JavaProjectUtil.setAutoBuild(true);
 		URL installURL = JavaTestsPlugin.getPlugin().getBundle().getEntry("/");
 		String[] zipPaths = new String[1];
 		zipPaths[0] = FileLocator.toFileURL(new URL(installURL, "testdata/JDK5Tests.zip")).getFile();
 		IProject[] projects =
 			JavaProjectUtil.importProjects(
 				new String[] { PROJECT_NAME },
 				zipPaths);
 		assertNotNull(projects[0]);
 		JavaProjectUtil.waitForAutoBuild();
 		javaProject = JavaCore.create(projects[0]);
 		javaProject.setOption(JavaCore.COMPILER_COMPLIANCE, "1.5");
 		resourceSet = new ResourceSetImpl();
 		resourceSet.getAdapterFactories().add(new JavaJDOMAdapterFactory(javaProject));
 	}

 	protected void setUpForNoSource() throws CoreException, IOException, MalformedURLException {
 		oldAutoBuildingState = JavaProjectUtil.setAutoBuild(true);
 		URL installURL = JavaTestsPlugin.getPlugin().getBundle().getEntry("/");
 		String[] jarPaths = new String[1];
 		jarPaths[0] = FileLocator.toFileURL(new URL(installURL, "testdata/JDK5BinTests.jar")).getFile();
 		IProject project = JavaProjectUtil.createEmptyJavaProject(ResourcesPlugin.getWorkspace(), new Path(PROJECT_NAME), null);
 		assertNotNull(project);
 		JavaProjectUtil.waitForAutoBuild();
 		javaProject = JavaCore.create(project);
 		javaProject.setOption(JavaCore.COMPILER_COMPLIANCE, "1.5");
 		ArrayList classpath = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
 		classpath.add(JavaCore.newLibraryEntry(new Path(jarPaths[0]), null, null));
 		javaProject.setRawClasspath((IClasspathEntry[]) classpath.toArray(new IClasspathEntry[0]), null);
 		JavaProjectUtil.waitForAutoBuild();
 		resourceSet = new ResourceSetImpl();
 		resourceSet.getAdapterFactories().add(new JavaJDOMAdapterFactory(javaProject));
 	}

 	protected void tearDown() throws Exception {
 		super.tearDown();
 		ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
 			public void run(IProgressMonitor monitor) throws CoreException {
 				JavaProjectUtil.deleteProject(javaProject.getProject());
 			}
 		}, ResourcesPlugin.getWorkspace().getRoot(), 0, null);

 		JavaProjectUtil.setAutoBuild(oldAutoBuildingState);
 	}

 	private JavaHelpers reflectClass(String qualifiedName) {
 		return JavaRefFactory.eINSTANCE.reflectType(qualifiedName, resourceSet);
 	}

 	/**
 	 * Test method test1 from Test class.
 	 *
 	 * public Collection<String> test1()
 	 *
 	 */
 	public void test1() {
  		JavaHelpers testHelper = reflectClass("test.me.Test");
 		assertFalse(testHelper.isPrimitive());
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = testClass.getMethod("test1", Collections.EMPTY_LIST);
 		assertNotNull(method);
 		JavaHelpers returnType = method.getReturnType();


 		assertEquals("java.util.Collection", returnType.getQualifiedName());
 		assertEquals("Collection", returnType.getSimpleName());
 	}

 	/**
 	 * Test method test2 from Test class.
 	 *
 	 * public void test2(Collection<? extends IFoo> aCollection)
 	 *
 	 */
 	public void test2() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test2")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);
 		JavaHelpers returnType = method.getReturnType();
 		assertNotNull(returnType); //void
 		List params = method.getParameters();
 		assertTrue(params.size() == 1);
 		JavaParameter param = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param.getName().equals("aCollection"));
 		JavaHelpers paramType = param.getJavaType();
 		assertNotNull(paramType);

 		assertEquals("java.util.Collection", paramType.getQualifiedName());
 		assertEquals("Collection", paramType.getSimpleName());
 	}

 	/**
 	 * Test method test3 from Test class.
 	 *
 	 * public <T extends IFoo> T test3(Class<T> aClass, String s, List<Integer> aList)
 	 *
 	 */
 	public void test3() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test3")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify return type.
 		JavaHelpers returnType = method.getReturnType();
 		assertNotNull(returnType);

 		assertEquals("test.dependents.IFoo", returnType.getQualifiedName());
 		assertEquals("IFoo", returnType.getSimpleName());

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 3);

 		//Verify Class<T> aClass
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aClass"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);

 		assertEquals("java.lang.Class", param1Type.getQualifiedName());
 		assertEquals("Class", param1Type.getSimpleName());

 		//Verify String s
 		JavaParameter param2 = (JavaParameter) params.get(1);
 		if (isReflectingSource)
 			assertEquals("s", param2.getName());
 		JavaHelpers param2Type = param2.getJavaType();
 		assertNotNull(param2Type);

 		//Verify List<Integer> aList
 		JavaHelpers listType = reflectClass("java.util.List");
 		JavaParameter param3 = (JavaParameter) params.get(2);
 		if (isReflectingSource)
 			assertEquals("aList", param3.getName());
 		JavaHelpers param3Type = param3.getJavaType();
 		assertNotNull(param3Type);
 		assertEquals(listType, param3Type);
 	}

 	/**
 	 * Test method test4 from Test class.
 	 *
 	 * public Map<Integer, String> test4(Integer anInteger)
 	 *
 	 */
 	public void test4() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test4")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify return type.
 		JavaHelpers returnType = method.getReturnType();
 		assertNotNull(returnType);

 		assertEquals("java.util.Map", returnType.getQualifiedName());
 		assertEquals("Map", returnType.getSimpleName());
 	}

 	/**
 	 * Test method test5 from Test class.
 	 *
 	 * public void test5(List<? super IFoo> aList)
 	 *
 	 */
 	public void test5() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test5")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 1);

 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aList"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);

 		assertEquals("java.util.List", param1Type.getQualifiedName());
 		assertEquals("List", param1Type.getSimpleName());
 	}

 	/**
 	 * Test method test6 from Test class.
 	 *
 	 * public <T> void test6(Class<T>[] aClassArray, List<String>[] anArrayOfListsOfString, Class<?>[] aWildcardClassArray, Class<?>[][][] aMultiDimWildcardArray)
 	 *
 	 */
 	public void test6() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test6")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertEquals(4, params.size());

 		// Verify Class<T>[] aClassArray
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aClassArray"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);
 		assertTrue(((ArrayType)param1Type).getArrayDimensions() == 1);
 		assertEquals("java.lang.Class[]", param1Type.getQualifiedName());
 		assertEquals("Class[]", param1Type.getSimpleName());
 		assertEquals("java.lang.Class", ((ArrayType)param1Type).getComponentTypeAsHelper().getQualifiedName());
 		assertEquals("Class", ((ArrayType)param1Type).getComponentTypeAsHelper().getSimpleName());

 		// Verify List<String>[] anArrayOfListsOfString
 		JavaParameter param2 = (JavaParameter) params.get(1);
 		if (isReflectingSource)
 			assertTrue(param2.getName().equals("anArrayOfListsOfString"));
 		JavaHelpers param2Type = param2.getJavaType();
 		assertNotNull(param2Type);
 		assertTrue(((ArrayType)param2Type).getArrayDimensions() == 1);
 		assertEquals("java.util.List[]", param2Type.getQualifiedName());
 		assertEquals("List[]", param2Type.getSimpleName());
 		assertEquals("java.util.List", ((ArrayType)param2Type).getComponentTypeAsHelper().getQualifiedName());
 		assertEquals("List", ((ArrayType)param2Type).getComponentTypeAsHelper().getSimpleName());

 		// Verify Class<?>[] aWildcardClassArray
 		JavaParameter param3 = (JavaParameter) params.get(2);
 		if (isReflectingSource)
 			assertTrue(param3.getName().equals("aWildcardClassArray"));
 		JavaHelpers param3Type = param3.getJavaType();
 		assertNotNull(param3Type);
 		assertTrue(((ArrayType)param3Type).getArrayDimensions() == 1);
 		assertEquals("java.lang.Class[]", param3Type.getQualifiedName());
 		assertEquals("Class[]", param3Type.getSimpleName());
 		assertEquals("java.lang.Class", ((ArrayType)param3Type).getComponentTypeAsHelper().getQualifiedName());
 		assertEquals("Class", ((ArrayType)param3Type).getComponentTypeAsHelper().getSimpleName());

 		// Verify Class<?>[][][] aMultiDimWildcardArray
 		JavaParameter param4 = (JavaParameter) params.get(3);
 		if (isReflectingSource)
 			assertTrue(param4.getName().equals("aMultiDimWildcardArray"));
 		JavaHelpers param4Type = param4.getJavaType();
 		assertNotNull(param4Type);
 		assertTrue(((ArrayType)param4Type).getArrayDimensions() == 3);
 		assertEquals("java.lang.Class[][][]", param4Type.getQualifiedName());
 		assertEquals("Class[][][]", param4Type.getSimpleName());
 		JavaHelpers componentType = ((ArrayType)param4Type).getComponentTypeAsHelper();
 		assertEquals("java.lang.Class[][]", componentType.getQualifiedName());
 		assertEquals("Class[][]", componentType.getSimpleName());
 		componentType = ((ArrayType) componentType).getComponentTypeAsHelper();
 		assertEquals("java.lang.Class[]", componentType.getQualifiedName());
 		assertEquals("Class[]", componentType.getSimpleName());
 		componentType = ((ArrayType) componentType).getComponentTypeAsHelper();

 	}

 	/**
 	 * Test method test7 from Test class.
 	 *
 	 * public <T> void test7(List<List<String>> aListOfListOfString, List<List<T>> aListOfListOfT, Map<IFoo, List<Map<IBar, T>>> aMap)
 	 *
 	 */
 	public void test7() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test7")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 3);


 		// Verify List<List<String>> aListOfListOfString
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aListOfListOfString"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);
 		assertEquals("java.util.List", param1Type.getQualifiedName());
 		assertEquals("List", param1Type.getSimpleName());

 		// Verify List<List<T>> aListOfListOfT
 		JavaParameter param2 = (JavaParameter) params.get(1);
 		if (isReflectingSource)
 			assertTrue(param2.getName().equals("aListOfListOfT"));
 		JavaHelpers param2Type = param2.getJavaType();
 		assertNotNull(param2Type);
 		assertEquals("java.util.List", param2Type.getQualifiedName());
 		assertEquals("List", param2Type.getSimpleName());

 		// Verify Map<IFoo, List<Map<IBar, T>>> aMap
 		JavaParameter param3 = (JavaParameter) params.get(2);
 		if (isReflectingSource)
 			assertTrue(param3.getName().equals("aMap"));
 		JavaHelpers param3Type = param3.getJavaType();
 		assertNotNull(param3Type);
 		assertEquals("java.util.Map", param3Type.getQualifiedName());
 		assertEquals("Map", param3Type.getSimpleName());

 	}

 	/**
 	 * Test method test8 from Test class.
 	 *
 	 * public void test8(List<? extends List<String>> aList)
 	 *
 	 */
 	public void test8() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test8")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 1);

 		// Verify List<? extends List<String>> aList
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aList"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);

 		assertEquals("java.util.List", param1Type.getQualifiedName());
 		assertEquals("List", param1Type.getSimpleName());

 	}

 	/**
 	 * Test method test9 from Test class.
 	 * This is the same test as test7 but with qualified names.
 	 *
 	 * public <T> void test9(java.util.List<java.util.List<java.lang.String>> aListOfListOfString, java.util.List<java.util.List<T>> aListOfListOfT, java.util.Map<test.dependents.IFoo, java.util.List<java.util.Map<test.dependents.IBar, T>>> aMap)
 	 *
 	 */
 	public void test9() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test9")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 3);


 		// Verify List<List<String>> aListOfListOfString
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("aListOfListOfString"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);
 		assertEquals("java.util.List", param1Type.getQualifiedName());
 		assertEquals("List", param1Type.getSimpleName());

 		// Verify List<List<T>> aListOfListOfT
 		JavaParameter param2 = (JavaParameter) params.get(1);
 		if (isReflectingSource)
 			assertTrue(param2.getName().equals("aListOfListOfT"));
 		JavaHelpers param2Type = param2.getJavaType();
 		assertNotNull(param2Type);

 		assertEquals("java.util.List", param2Type.getQualifiedName());
 		assertEquals("List", param2Type.getSimpleName());

 		// Verify Map<IFoo, List<Map<IBar, T>>> aMap
 		JavaParameter param3 = (JavaParameter) params.get(2);
 		if (isReflectingSource)
 			assertTrue(param3.getName().equals("aMap"));
 		JavaHelpers param3Type = param3.getJavaType();
 		assertNotNull(param3Type);

 		assertEquals("java.util.Map", param3Type.getQualifiedName());
 		assertEquals("Map", param3Type.getSimpleName());
 	}

 	/**
 	 * Test method test10 from Test class.
 	 *
 	 * public <T extends Tester> T test10(List<Integer> list)
 	 *
 	 */
 	public void test10() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test10")) {
 				break;
 			} else {
 				method = null;
 			}
 		}

 		assertNotNull(method);

 		JavaHelpers returnType = method.getReturnType();

 		assertEquals("test.dependents.Tester", returnType.getQualifiedName());
 		assertEquals("Tester", returnType.getSimpleName());

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 1);


 		// Verify List<List<String>> aListOfListOfString
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("list"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);
 		assertEquals("java.util.List", param1Type.getQualifiedName());
 		assertEquals("List", param1Type.getSimpleName());
 	}

 	/**
 	 * Test method test11 from Test class.
 	 *
 	 * public <T extends Tester> T[] test11()
 	 *
 	 */
 	public void test11() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test11")) {
 				break;
 			} else {
 				method = null;
 			}
 		}
 		//TODO need to revisit
 //		assertNotNull(method);
 //
 //		JavaHelpers returnType = method.getReturnType();
 //
 //		assertEquals("test.dependents.Tester[]", returnType.getQualifiedName());
 //		assertEquals("Tester[]", returnType.getSimpleName());
 	}

 	/**
 	 * Test method test11 from Test class.
 	 *
 	 * public <T extends Tester> T[][][] test11()
 	 *
 	 */
 	public void test12() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test12")) {
 				break;
 			} else {
 				method = null;
 			}
 		}
 		//TODO need to revisit
 //		assertNotNull(method);
 //
 //		JavaHelpers returnType = method.getReturnType();
 //
 //		assertEquals("test.dependents.Tester[][][]", returnType.getQualifiedName());
 //		assertEquals("Tester[][][]", returnType.getSimpleName());
 	}
 	/**
 	 * Test method test13 from Test class.
 	 *
 	 * public void test13(Y param) (where Y is a class-level type parameter
 	 *
 	 */
 	public void test13() {
 		JavaHelpers testHelper = reflectClass("test.me.Test");
 		JavaClass testClass = (JavaClass) testHelper;
 		assertTrue((testClass).isExistingType());

 		Method method = null;
 		List methods = testClass.getMethods();
 		for (int i = 0; i < methods.size(); i++) {
 			method = (Method) methods.get(i);
 			if (method.getName().equals("test13")) {
 				break;
 			} else {
 				method = null;
 			}
 		}
 		assertNotNull(method);

 		//Verify parameters
 		List params = method.getParameters();
 		assertTrue(params.size() == 1);


 		// Verify Y param
 		JavaParameter param1 = (JavaParameter) params.get(0);
 		if (isReflectingSource)
 			assertTrue(param1.getName().equals("param"));
 		JavaHelpers param1Type = param1.getJavaType();
 		assertNotNull(param1Type);
 		assertEquals("java.io.Serializable", param1Type.getQualifiedName());
 		assertEquals("Serializable", param1Type.getSimpleName());
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2006 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jem.tests;

	import java.io.IOException;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.util.*;

	import junit.framework.TestCase;

	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
	import org.eclipse.jdt.core.*;

	import org.eclipse.jem.internal.adapters.jdom.JavaJDOMAdapterFactory;
	import org.eclipse.jem.java.*;

	/**
	* Test case for testing the reflection of concepts
	* from JDK 5.
	* @since 1.2.2
	*
	*/
	public class JDK5ReflectionTests extends TestCase {

	private static final String PROJECT_NAME = "JDK5Tests"; //$NON-NLS-1$
	private IJavaProject javaProject;
	private ResourceSet resourceSet;

	private boolean oldAutoBuildingState; // autoBuilding state before we started.

	protected boolean isReflectingSource;

	/**
	*
	*/
	public JDK5ReflectionTests() {
	isReflectingSource = true;
	}

	/**
	* @param name
	*/
	public JDK5ReflectionTests(String name) {
	super(name);
	isReflectingSource = true;
	}

	protected void setUp() throws Exception {
	super.setUp();
	if (isReflectingSource)
	setUpForSource();
	else
	setUpForNoSource();
	}

	protected void setUpForSource() throws CoreException, IOException, MalformedURLException {
	oldAutoBuildingState = JavaProjectUtil.setAutoBuild(true);
	URL installURL = JavaTestsPlugin.getPlugin().getBundle().getEntry("/");
	String[] zipPaths = new String[1];
	zipPaths[0] = FileLocator.toFileURL(new URL(installURL, "testdata/JDK5Tests.zip")).getFile();
	IProject[] projects =
	JavaProjectUtil.importProjects(
	new String[] { PROJECT_NAME },
	zipPaths);
	assertNotNull(projects[0]);
	JavaProjectUtil.waitForAutoBuild();
	javaProject = JavaCore.create(projects[0]);
	javaProject.setOption(JavaCore.COMPILER_COMPLIANCE, "1.5");
	resourceSet = new ResourceSetImpl();
	resourceSet.getAdapterFactories().add(new JavaJDOMAdapterFactory(javaProject));
	}

	protected void setUpForNoSource() throws CoreException, IOException, MalformedURLException {
	oldAutoBuildingState = JavaProjectUtil.setAutoBuild(true);
	URL installURL = JavaTestsPlugin.getPlugin().getBundle().getEntry("/");
	String[] jarPaths = new String[1];
	jarPaths[0] = FileLocator.toFileURL(new URL(installURL, "testdata/JDK5BinTests.jar")).getFile();
	IProject project = JavaProjectUtil.createEmptyJavaProject(ResourcesPlugin.getWorkspace(), new Path(PROJECT_NAME), null);
	assertNotNull(project);
	JavaProjectUtil.waitForAutoBuild();
	javaProject = JavaCore.create(project);
	javaProject.setOption(JavaCore.COMPILER_COMPLIANCE, "1.5");
	ArrayList classpath = new ArrayList(Arrays.asList(javaProject.getRawClasspath()));
	classpath.add(JavaCore.newLibraryEntry(new Path(jarPaths[0]), null, null));
	javaProject.setRawClasspath((IClasspathEntry[]) classpath.toArray(new IClasspathEntry[0]), null);
	JavaProjectUtil.waitForAutoBuild();
	resourceSet = new ResourceSetImpl();
	resourceSet.getAdapterFactories().add(new JavaJDOMAdapterFactory(javaProject));
	}

	protected void tearDown() throws Exception {
	super.tearDown();
	ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() {
	public void run(IProgressMonitor monitor) throws CoreException {
	JavaProjectUtil.deleteProject(javaProject.getProject());
	}
	}, ResourcesPlugin.getWorkspace().getRoot(), 0, null);

	JavaProjectUtil.setAutoBuild(oldAutoBuildingState);
	}

	private JavaHelpers reflectClass(String qualifiedName) {
	return JavaRefFactory.eINSTANCE.reflectType(qualifiedName, resourceSet);
	}

	/**
	* Test method test1 from Test class.
	*
	* public Collection<String> test1()
	*
	*/
	public void test1() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	assertFalse(testHelper.isPrimitive());
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = testClass.getMethod("test1", Collections.EMPTY_LIST);
	assertNotNull(method);
	JavaHelpers returnType = method.getReturnType();


	assertEquals("java.util.Collection", returnType.getQualifiedName());
	assertEquals("Collection", returnType.getSimpleName());
	}

	/**
	* Test method test2 from Test class.
	*
	* public void test2(Collection<? extends IFoo> aCollection)
	*
	*/
	public void test2() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test2")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);
	JavaHelpers returnType = method.getReturnType();
	assertNotNull(returnType); //void
	List params = method.getParameters();
	assertTrue(params.size() == 1);
	JavaParameter param = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param.getName().equals("aCollection"));
	JavaHelpers paramType = param.getJavaType();
	assertNotNull(paramType);

	assertEquals("java.util.Collection", paramType.getQualifiedName());
	assertEquals("Collection", paramType.getSimpleName());
	}

	/**
	* Test method test3 from Test class.
	*
	* public <T extends IFoo> T test3(Class<T> aClass, String s, List<Integer> aList)
	*
	*/
	public void test3() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test3")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify return type.
	JavaHelpers returnType = method.getReturnType();
	assertNotNull(returnType);

	assertEquals("test.dependents.IFoo", returnType.getQualifiedName());
	assertEquals("IFoo", returnType.getSimpleName());

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 3);

	//Verify Class<T> aClass
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aClass"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);

	assertEquals("java.lang.Class", param1Type.getQualifiedName());
	assertEquals("Class", param1Type.getSimpleName());

	//Verify String s
	JavaParameter param2 = (JavaParameter) params.get(1);
	if (isReflectingSource)
	assertEquals("s", param2.getName());
	JavaHelpers param2Type = param2.getJavaType();
	assertNotNull(param2Type);

	//Verify List<Integer> aList
	JavaHelpers listType = reflectClass("java.util.List");
	JavaParameter param3 = (JavaParameter) params.get(2);
	if (isReflectingSource)
	assertEquals("aList", param3.getName());
	JavaHelpers param3Type = param3.getJavaType();
	assertNotNull(param3Type);
	assertEquals(listType, param3Type);
	}

	/**
	* Test method test4 from Test class.
	*
	* public Map<Integer, String> test4(Integer anInteger)
	*
	*/
	public void test4() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test4")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify return type.
	JavaHelpers returnType = method.getReturnType();
	assertNotNull(returnType);

	assertEquals("java.util.Map", returnType.getQualifiedName());
	assertEquals("Map", returnType.getSimpleName());
	}

	/**
	* Test method test5 from Test class.
	*
	* public void test5(List<? super IFoo> aList)
	*
	*/
	public void test5() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test5")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 1);

	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aList"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);

	assertEquals("java.util.List", param1Type.getQualifiedName());
	assertEquals("List", param1Type.getSimpleName());
	}

	/**
	* Test method test6 from Test class.
	*
	* public <T> void test6(Class<T>[] aClassArray, List<String>[] anArrayOfListsOfString, Class<?>[] aWildcardClassArray, Class<?>[][][] aMultiDimWildcardArray)
	*
	*/
	public void test6() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test6")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertEquals(4, params.size());

	// Verify Class<T>[] aClassArray
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aClassArray"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);
	assertTrue(((ArrayType)param1Type).getArrayDimensions() == 1);
	assertEquals("java.lang.Class[]", param1Type.getQualifiedName());
	assertEquals("Class[]", param1Type.getSimpleName());
	assertEquals("java.lang.Class", ((ArrayType)param1Type).getComponentTypeAsHelper().getQualifiedName());
	assertEquals("Class", ((ArrayType)param1Type).getComponentTypeAsHelper().getSimpleName());

	// Verify List<String>[] anArrayOfListsOfString
	JavaParameter param2 = (JavaParameter) params.get(1);
	if (isReflectingSource)
	assertTrue(param2.getName().equals("anArrayOfListsOfString"));
	JavaHelpers param2Type = param2.getJavaType();
	assertNotNull(param2Type);
	assertTrue(((ArrayType)param2Type).getArrayDimensions() == 1);
	assertEquals("java.util.List[]", param2Type.getQualifiedName());
	assertEquals("List[]", param2Type.getSimpleName());
	assertEquals("java.util.List", ((ArrayType)param2Type).getComponentTypeAsHelper().getQualifiedName());
	assertEquals("List", ((ArrayType)param2Type).getComponentTypeAsHelper().getSimpleName());

	// Verify Class<?>[] aWildcardClassArray
	JavaParameter param3 = (JavaParameter) params.get(2);
	if (isReflectingSource)
	assertTrue(param3.getName().equals("aWildcardClassArray"));
	JavaHelpers param3Type = param3.getJavaType();
	assertNotNull(param3Type);
	assertTrue(((ArrayType)param3Type).getArrayDimensions() == 1);
	assertEquals("java.lang.Class[]", param3Type.getQualifiedName());
	assertEquals("Class[]", param3Type.getSimpleName());
	assertEquals("java.lang.Class", ((ArrayType)param3Type).getComponentTypeAsHelper().getQualifiedName());
	assertEquals("Class", ((ArrayType)param3Type).getComponentTypeAsHelper().getSimpleName());

	// Verify Class<?>[][][] aMultiDimWildcardArray
	JavaParameter param4 = (JavaParameter) params.get(3);
	if (isReflectingSource)
	assertTrue(param4.getName().equals("aMultiDimWildcardArray"));
	JavaHelpers param4Type = param4.getJavaType();
	assertNotNull(param4Type);
	assertTrue(((ArrayType)param4Type).getArrayDimensions() == 3);
	assertEquals("java.lang.Class[][][]", param4Type.getQualifiedName());
	assertEquals("Class[][][]", param4Type.getSimpleName());
	JavaHelpers componentType = ((ArrayType)param4Type).getComponentTypeAsHelper();
	assertEquals("java.lang.Class[][]", componentType.getQualifiedName());
	assertEquals("Class[][]", componentType.getSimpleName());
	componentType = ((ArrayType) componentType).getComponentTypeAsHelper();
	assertEquals("java.lang.Class[]", componentType.getQualifiedName());
	assertEquals("Class[]", componentType.getSimpleName());
	componentType = ((ArrayType) componentType).getComponentTypeAsHelper();

	}

	/**
	* Test method test7 from Test class.
	*
	* public <T> void test7(List<List<String>> aListOfListOfString, List<List<T>> aListOfListOfT, Map<IFoo, List<Map<IBar, T>>> aMap)
	*
	*/
	public void test7() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test7")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 3);


	// Verify List<List<String>> aListOfListOfString
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aListOfListOfString"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);
	assertEquals("java.util.List", param1Type.getQualifiedName());
	assertEquals("List", param1Type.getSimpleName());

	// Verify List<List<T>> aListOfListOfT
	JavaParameter param2 = (JavaParameter) params.get(1);
	if (isReflectingSource)
	assertTrue(param2.getName().equals("aListOfListOfT"));
	JavaHelpers param2Type = param2.getJavaType();
	assertNotNull(param2Type);
	assertEquals("java.util.List", param2Type.getQualifiedName());
	assertEquals("List", param2Type.getSimpleName());

	// Verify Map<IFoo, List<Map<IBar, T>>> aMap
	JavaParameter param3 = (JavaParameter) params.get(2);
	if (isReflectingSource)
	assertTrue(param3.getName().equals("aMap"));
	JavaHelpers param3Type = param3.getJavaType();
	assertNotNull(param3Type);
	assertEquals("java.util.Map", param3Type.getQualifiedName());
	assertEquals("Map", param3Type.getSimpleName());

	}

	/**
	* Test method test8 from Test class.
	*
	* public void test8(List<? extends List<String>> aList)
	*
	*/
	public void test8() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test8")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 1);

	// Verify List<? extends List<String>> aList
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aList"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);

	assertEquals("java.util.List", param1Type.getQualifiedName());
	assertEquals("List", param1Type.getSimpleName());

	}

	/**
	* Test method test9 from Test class.
	* This is the same test as test7 but with qualified names.
	*
	* public <T> void test9(java.util.List<java.util.List<java.lang.String>> aListOfListOfString, java.util.List<java.util.List<T>> aListOfListOfT, java.util.Map<test.dependents.IFoo, java.util.List<java.util.Map<test.dependents.IBar, T>>> aMap)
	*
	*/
	public void test9() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test9")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 3);


	// Verify List<List<String>> aListOfListOfString
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("aListOfListOfString"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);
	assertEquals("java.util.List", param1Type.getQualifiedName());
	assertEquals("List", param1Type.getSimpleName());

	// Verify List<List<T>> aListOfListOfT
	JavaParameter param2 = (JavaParameter) params.get(1);
	if (isReflectingSource)
	assertTrue(param2.getName().equals("aListOfListOfT"));
	JavaHelpers param2Type = param2.getJavaType();
	assertNotNull(param2Type);

	assertEquals("java.util.List", param2Type.getQualifiedName());
	assertEquals("List", param2Type.getSimpleName());

	// Verify Map<IFoo, List<Map<IBar, T>>> aMap
	JavaParameter param3 = (JavaParameter) params.get(2);
	if (isReflectingSource)
	assertTrue(param3.getName().equals("aMap"));
	JavaHelpers param3Type = param3.getJavaType();
	assertNotNull(param3Type);

	assertEquals("java.util.Map", param3Type.getQualifiedName());
	assertEquals("Map", param3Type.getSimpleName());
	}

	/**
	* Test method test10 from Test class.
	*
	* public <T extends Tester> T test10(List<Integer> list)
	*
	*/
	public void test10() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test10")) {
	break;
	} else {
	method = null;
	}
	}

	assertNotNull(method);

	JavaHelpers returnType = method.getReturnType();

	assertEquals("test.dependents.Tester", returnType.getQualifiedName());
	assertEquals("Tester", returnType.getSimpleName());

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 1);


	// Verify List<List<String>> aListOfListOfString
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("list"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);
	assertEquals("java.util.List", param1Type.getQualifiedName());
	assertEquals("List", param1Type.getSimpleName());
	}

	/**
	* Test method test11 from Test class.
	*
	* public <T extends Tester> T[] test11()
	*
	*/
	public void test11() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test11")) {
	break;
	} else {
	method = null;
	}
	}
	//TODO need to revisit
	// assertNotNull(method);
	//
	// JavaHelpers returnType = method.getReturnType();
	//
	// assertEquals("test.dependents.Tester[]", returnType.getQualifiedName());
	// assertEquals("Tester[]", returnType.getSimpleName());
	}

	/**
	* Test method test11 from Test class.
	*
	* public <T extends Tester> T[][][] test11()
	*
	*/
	public void test12() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test12")) {
	break;
	} else {
	method = null;
	}
	}
	//TODO need to revisit
	// assertNotNull(method);
	//
	// JavaHelpers returnType = method.getReturnType();
	//
	// assertEquals("test.dependents.Tester[][][]", returnType.getQualifiedName());
	// assertEquals("Tester[][][]", returnType.getSimpleName());
	}
	/**
	* Test method test13 from Test class.
	*
	* public void test13(Y param) (where Y is a class-level type parameter
	*
	*/
	public void test13() {
	JavaHelpers testHelper = reflectClass("test.me.Test");
	JavaClass testClass = (JavaClass) testHelper;
	assertTrue((testClass).isExistingType());

	Method method = null;
	List methods = testClass.getMethods();
	for (int i = 0; i < methods.size(); i++) {
	method = (Method) methods.get(i);
	if (method.getName().equals("test13")) {
	break;
	} else {
	method = null;
	}
	}
	assertNotNull(method);

	//Verify parameters
	List params = method.getParameters();
	assertTrue(params.size() == 1);


	// Verify Y param
	JavaParameter param1 = (JavaParameter) params.get(0);
	if (isReflectingSource)
	assertTrue(param1.getName().equals("param"));
	JavaHelpers param1Type = param1.getJavaType();
	assertNotNull(param1Type);
	assertEquals("java.io.Serializable", param1Type.getQualifiedName());
	assertEquals("Serializable", param1Type.getSimpleName());
	}
	}