| /******************************************************************************* |
| * 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 |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * 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()); |
| } |
| } |