| /******************************************************************************* |
| * Copyright (c) 2005, 2007 Oracle. 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: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.utility.tests.internal; |
| |
| import java.lang.reflect.Array; |
| import java.lang.reflect.Field; |
| import java.lang.reflect.Method; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Vector; |
| import java.util.Map.Entry; |
| import junit.framework.TestCase; |
| import org.eclipse.jpt.utility.internal.ClassTools; |
| import org.eclipse.jpt.utility.internal.CollectionTools; |
| import org.eclipse.jpt.utility.internal.iterators.TransformationIterator; |
| |
| public class ClassToolsTests extends TestCase { |
| |
| private static String testStaticField; |
| |
| public ClassToolsTests(String name) { |
| super(name); |
| } |
| |
| /** |
| * Return the compiler-generated class name. The Eclipse compiler generates |
| * "local" classes with names in the form "com.foo.Outer$1$Local"; while the |
| * JDK compiler generates "com.foo.Outer$1Local". There might be other |
| * differences.... ~bjv |
| */ |
| public static String compilerDependentClassNameFor(String className) { |
| int index = className.indexOf("$1$"); |
| if (index == -1) { |
| return className; |
| } |
| try { |
| Class.forName(className); |
| } catch (ClassNotFoundException ex) { |
| return className.substring(0, index + 2) + className.substring(index + 3); |
| } |
| return className; |
| } |
| |
| private static String munge(String className) { |
| return compilerDependentClassNameFor(className); |
| } |
| |
| public void testAllFields() { |
| int fieldCount = 0; |
| fieldCount += java.util.Vector.class.getDeclaredFields().length; |
| fieldCount += java.util.AbstractList.class.getDeclaredFields().length; |
| fieldCount += java.util.AbstractCollection.class.getDeclaredFields().length; |
| fieldCount += java.lang.Object.class.getDeclaredFields().length; |
| Field[] fields = ClassTools.allFields(java.util.Vector.class); |
| assertEquals(fieldCount, fields.length); |
| assertTrue(CollectionTools.contains(this.names(fields), "modCount")); |
| assertTrue(CollectionTools.contains(this.names(fields), "serialVersionUID")); |
| assertTrue(CollectionTools.contains(this.names(fields), "capacityIncrement")); |
| assertTrue(CollectionTools.contains(this.names(fields), "elementCount")); |
| assertTrue(CollectionTools.contains(this.names(fields), "elementData")); |
| assertTrue(fields[0].isAccessible()); |
| } |
| |
| public void testAllMethods() { |
| int methodCount = 0; |
| methodCount += java.util.Vector.class.getDeclaredMethods().length; |
| methodCount += java.util.AbstractList.class.getDeclaredMethods().length; |
| methodCount += java.util.AbstractCollection.class.getDeclaredMethods().length; |
| methodCount += java.lang.Object.class.getDeclaredMethods().length; |
| Method[] methods = ClassTools.allMethods(java.util.Vector.class); |
| assertEquals(methodCount, methods.length); |
| assertTrue(CollectionTools.contains(this.names(methods), "wait")); |
| assertTrue(CollectionTools.contains(this.names(methods), "addElement")); |
| assertTrue(methods[0].isAccessible()); |
| } |
| |
| public void testNewInstanceClass() { |
| Vector<?> v = ClassTools.newInstance(java.util.Vector.class); |
| assertNotNull(v); |
| assertEquals(0, v.size()); |
| } |
| |
| public void testNewInstanceClassClassObject() { |
| int initialCapacity = 200; |
| Vector<?> v = ClassTools.newInstance(java.util.Vector.class, int.class, new Integer(initialCapacity)); |
| assertNotNull(v); |
| assertEquals(0, v.size()); |
| Object[] elementData = (Object[]) ClassTools.getFieldValue(v, "elementData"); |
| assertEquals(initialCapacity, elementData.length); |
| } |
| |
| public void testNewInstanceClassClassArrayObjectArray() { |
| int initialCapacity = 200; |
| Class<?>[] parmTypes = new Class[1]; |
| parmTypes[0] = int.class; |
| Object[] parms = new Object[1]; |
| parms[0] = new Integer(initialCapacity); |
| Vector<?> v = ClassTools.newInstance(java.util.Vector.class, parmTypes, parms); |
| assertNotNull(v); |
| assertEquals(0, v.size()); |
| Object[] elementData = (Object[]) ClassTools.getFieldValue(v, "elementData"); |
| assertEquals(initialCapacity, elementData.length); |
| |
| parms[0] = new Integer(-1); |
| boolean exCaught = false; |
| try { |
| v = ClassTools.newInstance(java.util.Vector.class, parmTypes, parms); |
| } catch (RuntimeException ex) { |
| exCaught = true; |
| } |
| assertTrue("RuntimeException not thrown", exCaught); |
| |
| parmTypes[0] = java.lang.String.class; |
| parms[0] = "foo"; |
| exCaught = false; |
| try { |
| v = ClassTools.attemptNewInstance(java.util.Vector.class, parmTypes, parms); |
| } catch (NoSuchMethodException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchMethodException not thrown", exCaught); |
| } |
| |
| public void testGetFieldValue() { |
| int initialCapacity = 200; |
| Vector<?> v = new Vector<Object>(initialCapacity); |
| Object[] elementData = (Object[]) ClassTools.getFieldValue(v, "elementData"); |
| assertEquals(initialCapacity, elementData.length); |
| |
| // test inherited field |
| Integer modCountInteger = (Integer) ClassTools.getFieldValue(v, "modCount"); |
| int modCount = modCountInteger.intValue(); |
| assertEquals(0, modCount); |
| |
| boolean exCaught = false; |
| Object bogusFieldValue = null; |
| try { |
| bogusFieldValue = ClassTools.attemptToGetFieldValue(v, "bogusField"); |
| } catch (NoSuchFieldException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchFieldException not thrown: " + bogusFieldValue, exCaught); |
| } |
| |
| public void testExecuteMethodObjectString() { |
| Vector<String> v = new Vector<String>(); |
| int size = ((Integer) ClassTools.executeMethod(v, "size")).intValue(); |
| assertEquals(0, size); |
| |
| v.addElement("foo"); |
| size = ((Integer) ClassTools.executeMethod(v, "size")).intValue(); |
| assertEquals(1, size); |
| } |
| |
| public void testExecuteMethodObjectStringClassObject() { |
| Vector<String> v = new Vector<String>(); |
| boolean booleanResult = ((Boolean) ClassTools.executeMethod(v, "add", Object.class, "foo")).booleanValue(); |
| assertTrue(booleanResult); |
| assertTrue(v.contains("foo")); |
| Object voidResult = ClassTools.executeMethod(v, "addElement", Object.class, "bar"); |
| assertNull(voidResult); |
| } |
| |
| public void testExecuteMethodObjectStringClassArrayObjectArray() { |
| Vector<String> v = new Vector<String>(); |
| Class<?>[] parmTypes = new Class[1]; |
| parmTypes[0] = java.lang.Object.class; |
| Object[] parms = new Object[1]; |
| parms[0] = "foo"; |
| boolean booleanResult = ((Boolean) ClassTools.executeMethod(v, "add", parmTypes, parms)).booleanValue(); |
| assertTrue(booleanResult); |
| assertTrue(v.contains("foo")); |
| |
| boolean exCaught = false; |
| Object bogusMethodReturnValue = null; |
| try { |
| bogusMethodReturnValue = ClassTools.attemptToExecuteMethod(v, "bogusMethod", parmTypes, parms); |
| } catch (NoSuchMethodException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchMethodException not thrown: " + bogusMethodReturnValue, exCaught); |
| } |
| |
| public void testExecuteStaticMethodClassString() { |
| Double randomObject = (Double) ClassTools.executeStaticMethod(java.lang.Math.class, "random"); |
| assertNotNull(randomObject); |
| double random = randomObject.doubleValue(); |
| assertTrue(random >= 0); |
| assertTrue(random < 1); |
| } |
| |
| public void testExecuteStaticMethodClassStringClassObject() { |
| String s = (String) ClassTools.executeStaticMethod(java.lang.String.class, "valueOf", boolean.class, Boolean.TRUE); |
| assertNotNull(s); |
| assertEquals("true", s); |
| } |
| |
| public void testExecuteStaticMethodClassStringClassArrayObjectArray() { |
| Class<?>[] parmTypes = new Class[1]; |
| parmTypes[0] = boolean.class; |
| Object[] parms = new Object[1]; |
| parms[0] = Boolean.TRUE; |
| String s = (String) ClassTools.executeStaticMethod(java.lang.String.class, "valueOf", parmTypes, parms); |
| assertNotNull(s); |
| assertEquals("true", s); |
| |
| boolean exCaught = false; |
| Object bogusStaticMethodReturnValue = null; |
| try { |
| bogusStaticMethodReturnValue = ClassTools.attemptToExecuteStaticMethod(java.lang.String.class, "bogusStaticMethod", parmTypes, parms); |
| } catch (NoSuchMethodException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchMethodException not thrown: " + bogusStaticMethodReturnValue, exCaught); |
| |
| // test non-static method |
| exCaught = false; |
| try { |
| bogusStaticMethodReturnValue = ClassTools.attemptToExecuteStaticMethod(java.lang.String.class, "toString"); |
| } catch (NoSuchMethodException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchMethodException not thrown: " + bogusStaticMethodReturnValue, exCaught); |
| } |
| |
| public void testSetFieldValue() { |
| Vector<String> v = new Vector<String>(); |
| Object[] newElementData = new Object[5]; |
| newElementData[0] = "foo"; |
| ClassTools.setFieldValue(v, "elementData", newElementData); |
| ClassTools.setFieldValue(v, "elementCount", new Integer(1)); |
| // test inherited field |
| ClassTools.setFieldValue(v, "modCount", new Integer(1)); |
| assertTrue(v.contains("foo")); |
| |
| boolean exCaught = false; |
| try { |
| ClassTools.attemptToSetFieldValue(v, "bogusField", "foo"); |
| } catch (NoSuchFieldException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchFieldException not thrown", exCaught); |
| } |
| |
| public void testSetStaticFieldValue() { |
| ClassTools.setStaticFieldValue(this.getClass(), "testStaticField", "new value"); |
| assertEquals(testStaticField, "new value"); |
| |
| boolean exCaught = false; |
| try { |
| ClassTools.attemptToSetStaticFieldValue(this.getClass(), "bogusStaticField", "new value"); |
| } catch (NoSuchFieldException ex) { |
| exCaught = true; |
| } |
| assertTrue("NoSuchFieldException not thrown", exCaught); |
| } |
| |
| public void testShortName() { |
| assertEquals("Vector", ClassTools.shortClassNameForObject(new java.util.Vector<Object>())); |
| assertEquals("Vector", ClassTools.shortNameFor(java.util.Vector.class)); |
| } |
| |
| public void testNestedName() { |
| Map<String, String> map = new HashMap<String, String>(); |
| map.put("foo", "bar"); |
| Entry<String, String> entry = map.entrySet().iterator().next(); |
| assertEquals("Entry", ClassTools.nestedClassNameForObject(entry)); |
| assertEquals("Entry", ClassTools.nestedNameFor(java.util.Map.Entry.class)); |
| } |
| |
| public void testPackageName() { |
| assertEquals("java.util", ClassTools.packageNameFor(java.util.Vector.class)); |
| assertEquals("java.util", ClassTools.packageNameFor(java.util.Map.Entry.class)); |
| } |
| |
| public void testArrayDepthFor() { |
| assertEquals(0, ClassTools.arrayDepthFor(java.util.Vector.class)); |
| assertEquals(0, ClassTools.arrayDepthFor(int.class)); |
| assertEquals(0, ClassTools.arrayDepthFor(void.class)); |
| assertEquals(1, ClassTools.arrayDepthFor(java.util.Vector[].class)); |
| assertEquals(1, ClassTools.arrayDepthFor(int[].class)); |
| assertEquals(3, ClassTools.arrayDepthFor(java.util.Vector[][][].class)); |
| assertEquals(3, ClassTools.arrayDepthFor(int[][][].class)); |
| } |
| |
| public void testArrayDepthForObject() { |
| assertEquals(0, ClassTools.arrayDepthForObject(new java.util.Vector<Object>())); |
| assertEquals(1, ClassTools.arrayDepthForObject(new java.util.Vector[0])); |
| assertEquals(1, ClassTools.arrayDepthForObject(new int[0])); |
| assertEquals(3, ClassTools.arrayDepthForObject(new java.util.Vector[0][0][0])); |
| assertEquals(3, ClassTools.arrayDepthForObject(new int[0][0][0])); |
| } |
| |
| public void testArrayDepthForClassNamed() { |
| assertEquals(0, ClassTools.arrayDepthForClassNamed(java.util.Vector.class.getName())); |
| assertEquals(0, ClassTools.arrayDepthForClassNamed(int.class.getName())); |
| assertEquals(0, ClassTools.arrayDepthForClassNamed(void.class.getName())); |
| assertEquals(1, ClassTools.arrayDepthForClassNamed(java.util.Vector[].class.getName())); |
| assertEquals(1, ClassTools.arrayDepthForClassNamed(int[].class.getName())); |
| assertEquals(3, ClassTools.arrayDepthForClassNamed(java.util.Vector[][][].class.getName())); |
| assertEquals(3, ClassTools.arrayDepthForClassNamed(int[][][].class.getName())); |
| } |
| |
| public void testElementTypeFor() { |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeFor(java.util.Vector.class)); |
| assertEquals(int.class, ClassTools.elementTypeFor(int.class)); |
| assertEquals(void.class, ClassTools.elementTypeFor(void.class)); |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeFor(java.util.Vector[].class)); |
| assertEquals(int.class, ClassTools.elementTypeFor(int[].class)); |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeFor(java.util.Vector[][][].class)); |
| assertEquals(int.class, ClassTools.elementTypeFor(int[][][].class)); |
| } |
| |
| public void testElementTypeForObject() { |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeForObject(new java.util.Vector<Object>())); |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeForObject(new java.util.Vector[0])); |
| assertEquals(int.class, ClassTools.elementTypeForObject(new int[0])); |
| assertEquals(java.util.Vector.class, ClassTools.elementTypeForObject(new java.util.Vector[0][0][0])); |
| assertEquals(int.class, ClassTools.elementTypeForObject(new int[0][0][0])); |
| } |
| |
| public void testElementTypeNameFor() { |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameFor(java.util.Vector.class)); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameFor(int.class)); |
| assertEquals(void.class.getName(), ClassTools.elementTypeNameFor(void.class)); |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameFor(java.util.Vector[].class)); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameFor(int[].class)); |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameFor(java.util.Vector[][][].class)); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameFor(int[][][].class)); |
| } |
| |
| public void testElementTypeNameForClassNamed() { |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameForClassNamed(java.util.Vector.class.getName())); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameForClassNamed(int.class.getName())); |
| assertEquals(void.class.getName(), ClassTools.elementTypeNameForClassNamed(void.class.getName())); |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameForClassNamed(java.util.Vector[].class.getName())); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameForClassNamed(int[].class.getName())); |
| assertEquals(java.util.Vector.class.getName(), ClassTools.elementTypeNameForClassNamed(java.util.Vector[][][].class.getName())); |
| assertEquals(int.class.getName(), ClassTools.elementTypeNameForClassNamed(int[][][].class.getName())); |
| } |
| |
| public void testClassCodes() { |
| assertEquals("byte", ClassTools.classNameForCode('B')); |
| assertEquals("char", ClassTools.classNameForCode('C')); |
| assertEquals("double", ClassTools.classNameForCode('D')); |
| assertEquals("float", ClassTools.classNameForCode('F')); |
| assertEquals("int", ClassTools.classNameForCode('I')); |
| assertEquals("long", ClassTools.classNameForCode('J')); |
| assertEquals("short", ClassTools.classNameForCode('S')); |
| assertEquals("boolean", ClassTools.classNameForCode('Z')); |
| assertEquals("void", ClassTools.classNameForCode('V')); |
| |
| boolean exCaught = false; |
| try { |
| ClassTools.classNameForCode('X'); |
| } catch (IllegalArgumentException ex) { |
| exCaught = true; |
| } |
| assertTrue("IllegalArgumentException not thrown", exCaught); |
| } |
| |
| public void testClassNamedIsTopLevel() throws Exception { |
| assertTrue(ClassTools.classNamedIsTopLevel(java.util.Map.class.getName())); // top-level |
| assertFalse(ClassTools.classNamedIsTopLevel(java.util.Map.Entry.class.getName())); // member |
| assertFalse(ClassTools.classNamedIsTopLevel(Class.forName(munge(this.getClass().getName() + "$1$LocalClass")).getName())); // local |
| assertFalse(ClassTools.classNamedIsTopLevel(Class.forName("java.util.Vector$1").getName())); // anonymous |
| |
| Object[] array = new java.util.Map[0]; // top-level |
| assertFalse(ClassTools.classNamedIsTopLevel(array.getClass().getName())); |
| array = new java.util.Map.Entry[0]; // member |
| assertFalse(ClassTools.classNamedIsTopLevel(array.getClass().getName())); |
| Class<?> localClass = Class.forName(munge(this.getClass().getName() + "$1$LocalClass")); // local |
| array = (Object[]) Array.newInstance(localClass, 0); |
| assertFalse(ClassTools.classNamedIsTopLevel(array.getClass().getName())); |
| Class<?> anonClass = Class.forName("java.util.Vector$1"); // local |
| array = (Object[]) Array.newInstance(anonClass, 0); |
| assertFalse(ClassTools.classNamedIsTopLevel(array.getClass().getName())); |
| } |
| |
| public void testClassNamedIsMember() throws Exception { |
| assertFalse(ClassTools.classNamedIsMember(java.util.Map.class.getName())); // top-level |
| assertTrue(ClassTools.classNamedIsMember(java.util.Map.Entry.class.getName())); // member |
| assertFalse(ClassTools.classNamedIsMember(Class.forName(munge(this.getClass().getName() + "$1$LocalClass")).getName())); // local |
| assertFalse(ClassTools.classNamedIsMember(Class.forName("java.util.Vector$1").getName())); // anonymous |
| |
| Object[] array = new java.util.Map[0]; // top-level |
| assertFalse(ClassTools.classNamedIsMember(array.getClass().getName())); |
| array = new java.util.Map.Entry[0]; // member |
| assertFalse(ClassTools.classNamedIsMember(array.getClass().getName())); |
| Class<?> localClass = Class.forName(munge(this.getClass().getName() + "$1$LocalClass")); // local |
| array = (Object[]) Array.newInstance(localClass, 0); |
| assertFalse(ClassTools.classNamedIsMember(array.getClass().getName())); |
| Class<?> anonClass = Class.forName("java.util.Vector$1"); // local |
| array = (Object[]) Array.newInstance(anonClass, 0); |
| assertFalse(ClassTools.classNamedIsMember(array.getClass().getName())); |
| |
| // test a few edge cases |
| assertTrue(ClassTools.classNamedIsMember("java.util.Map$a1")); |
| assertTrue(ClassTools.classNamedIsMember("java.util.Map$a1$aaa$bbb")); |
| assertFalse(ClassTools.classNamedIsMember("java.util.Map$1a1$aaa")); |
| assertFalse(ClassTools.classNamedIsMember("java.util.Map$1a")); |
| assertTrue(ClassTools.classNamedIsMember("java.util.Map$a12345$b12345")); |
| assertFalse(ClassTools.classNamedIsMember("java.util.Map$12345a")); |
| assertFalse(ClassTools.classNamedIsMember("java.util.Map$333")); |
| assertFalse(ClassTools.classNamedIsMember("java.util.Map3$333")); |
| } |
| |
| public void testClassNamedIsLocal() throws Exception { |
| class LocalClass { |
| void foo() { |
| System.getProperty("foo"); |
| } |
| } |
| new LocalClass().foo(); |
| assertFalse(ClassTools.classNamedIsLocal(java.util.Map.class.getName())); // top-level |
| assertFalse(ClassTools.classNamedIsLocal(java.util.Map.Entry.class.getName())); // member |
| assertTrue(ClassTools.classNamedIsLocal(Class.forName(munge(this.getClass().getName() + "$1$LocalClass")).getName())); // local |
| assertFalse(ClassTools.classNamedIsLocal(Class.forName("java.util.Vector$1").getName())); // anonymous |
| |
| Object[] array = new java.util.Map[0]; // top-level |
| assertFalse(ClassTools.classNamedIsLocal(array.getClass().getName())); |
| array = new java.util.Map.Entry[0]; // member |
| assertFalse(ClassTools.classNamedIsLocal(array.getClass().getName())); |
| Class<?> localClass = Class.forName(munge(this.getClass().getName() + "$1$LocalClass")); // local |
| array = (Object[]) Array.newInstance(localClass, 0); |
| assertFalse(ClassTools.classNamedIsLocal(array.getClass().getName())); |
| Class<?> anonClass = Class.forName("java.util.Vector$1"); // local |
| array = (Object[]) Array.newInstance(anonClass, 0); |
| assertFalse(ClassTools.classNamedIsLocal(array.getClass().getName())); |
| |
| // test a few edge cases |
| assertFalse(ClassTools.classNamedIsLocal("java.util.Map$a1")); |
| assertFalse(ClassTools.classNamedIsLocal("java.util.Map$a1$aaa$bbb")); |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$11$aaa")); |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$1$a")); // eclipse naming convention |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$2$abc")); // eclipse naming convention |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$2$abc1")); // eclipse naming convention |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$1a")); // jdk naming convention |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$2abc")); // jdk naming convention |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$2abc1")); // jdk naming convention |
| assertFalse(ClassTools.classNamedIsLocal("java.util.Map$a12345$b12345")); |
| assertTrue(ClassTools.classNamedIsLocal("java.util.Map$12345$a1234")); |
| assertFalse(ClassTools.classNamedIsLocal("java.util.Map$333")); |
| assertFalse(ClassTools.classNamedIsLocal("java.util.Map3$333")); |
| } |
| |
| public void testClassNamedIsAnonymous() throws Exception { |
| assertFalse(ClassTools.classNamedIsAnonymous(java.util.Map.class.getName())); // top-level |
| assertFalse(ClassTools.classNamedIsAnonymous(java.util.Map.Entry.class.getName())); // member |
| assertFalse(ClassTools.classNamedIsAnonymous(Class.forName(munge(this.getClass().getName() + "$1$LocalClass")).getName())); // local |
| assertTrue(ClassTools.classNamedIsAnonymous(Class.forName("java.util.Vector$1").getName())); // anonymous |
| |
| Object[] array = new java.util.Map[0]; // top-level |
| assertFalse(ClassTools.classNamedIsAnonymous(array.getClass().getName())); |
| array = new java.util.Map.Entry[0]; // member |
| assertFalse(ClassTools.classNamedIsAnonymous(array.getClass().getName())); |
| Class<?> localClass = Class.forName(munge(this.getClass().getName() + "$1$LocalClass")); // local |
| array = (Object[]) Array.newInstance(localClass, 0); |
| assertFalse(ClassTools.classNamedIsAnonymous(array.getClass().getName())); |
| Class<?> anonClass = Class.forName("java.util.Vector$1"); // local |
| array = (Object[]) Array.newInstance(anonClass, 0); |
| assertFalse(ClassTools.classNamedIsAnonymous(array.getClass().getName())); |
| |
| // test a few edge cases |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$a1")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$a1$aaa$bbb")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$1a1$aaa")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$1$a")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$1a")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$a12345$b12345")); |
| assertFalse(ClassTools.classNamedIsAnonymous("java.util.Map$12345$a1234")); |
| assertTrue(ClassTools.classNamedIsAnonymous("java.util.Map$333")); |
| assertTrue(ClassTools.classNamedIsAnonymous("java.util.Map3$333")); |
| } |
| |
| public void testCodeForClass() { |
| assertEquals('I', ClassTools.codeForClass(int.class)); |
| assertEquals('B', ClassTools.codeForClass(byte.class)); |
| } |
| |
| public void testCodeForClassNamed() { |
| assertEquals('I', ClassTools.codeForClassNamed(int.class.getName())); |
| assertEquals('I', ClassTools.codeForClassNamed("int")); |
| assertEquals('B', ClassTools.codeForClassNamed(byte.class.getName())); |
| assertEquals('B', ClassTools.codeForClassNamed("byte")); |
| } |
| |
| public void testClassForTypeDeclaration() throws Exception { |
| assertEquals(int.class, ClassTools.classForTypeDeclaration("int", 0)); |
| assertEquals(int[].class, ClassTools.classForTypeDeclaration("int", 1)); |
| assertEquals(int[][][].class, ClassTools.classForTypeDeclaration("int", 3)); |
| |
| assertEquals(Object.class, ClassTools.classForTypeDeclaration("java.lang.Object", 0)); |
| assertEquals(Object[][][].class, ClassTools.classForTypeDeclaration("java.lang.Object", 3)); |
| |
| assertEquals(void.class, ClassTools.classForTypeDeclaration("void", 0)); |
| try { |
| ClassTools.classForTypeDeclaration(void.class.getName(), 1); |
| fail("should not get here..."); |
| } catch (ClassNotFoundException ex) { |
| // expected |
| } |
| } |
| |
| public void testClassNameForTypeDeclaration() throws Exception { |
| assertEquals(int.class.getName(), ClassTools.classNameForTypeDeclaration("int", 0)); |
| assertEquals(int[].class.getName(), ClassTools.classNameForTypeDeclaration("int", 1)); |
| assertEquals(int[][][].class.getName(), ClassTools.classNameForTypeDeclaration("int", 3)); |
| |
| assertEquals(Object.class.getName(), ClassTools.classNameForTypeDeclaration("java.lang.Object", 0)); |
| assertEquals(Object[][][].class.getName(), ClassTools.classNameForTypeDeclaration("java.lang.Object", 3)); |
| |
| assertEquals(void.class.getName(), ClassTools.classNameForTypeDeclaration("void", 0)); |
| try { |
| ClassTools.classNameForTypeDeclaration(void.class.getName(), 1); |
| fail("should not get here..."); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| } |
| |
| private Iterator<String> names(Field[] fields) { |
| return new TransformationIterator<Field, String>(CollectionTools.iterator(fields)) { |
| @Override |
| protected String transform(Field field) { |
| return field.getName(); |
| } |
| }; |
| } |
| |
| private Iterator<String> names(Method[] methods) { |
| return new TransformationIterator<Method, String>(CollectionTools.iterator(methods)) { |
| @Override |
| protected String transform(Method method) { |
| return method.getName(); |
| } |
| }; |
| } |
| |
| } |