From b52c69b1b0ba1c542b917247f1f76deb4ce2a42d Mon Sep 17 00:00:00 2001 From: Gary Gregory Date: Mon, 23 Oct 2017 10:40:17 -0600 Subject: [PATCH] Sort members. --- .../apache/commons/lang3/ClassUtilsTest.java | 1434 ++++++++--------- 1 file changed, 717 insertions(+), 717 deletions(-) diff --git a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java index 6b97fb5ed..5aa2baff2 100644 --- a/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ClassUtilsTest.java @@ -50,34 +50,304 @@ import org.junit.Test; @SuppressWarnings("boxing") // JUnit4 does not support primitive equality testing apart from long public class ClassUtilsTest { + private static class CX implements IB, IA, IE { + } + + private static class CY extends CX implements IB, IC { + } + + private interface IA { + } + + private interface IB { + } + + + + private interface IC extends ID, IE { + } + + private interface ID { + } + + private interface IE extends IF { + } + + private interface IF { + } + private static class Inner { private class DeeplyNested{} } - //----------------------------------------------------------------------- + private void assertGetClassReturnsClass( final Class c ) throws Exception { + assertEquals( c, ClassUtils.getClass( c.getName() ) ); + } + + private void assertGetClassThrowsClassNotFound( final String className ) throws Exception { + assertGetClassThrowsException( className, ClassNotFoundException.class ); + } + + private void assertGetClassThrowsException( final String className, final Class exceptionType ) throws Exception { + try { + ClassUtils.getClass( className ); + fail( "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"." ); + } catch( final Exception e ) { + assertTrue( exceptionType.isAssignableFrom( e.getClass() ) ); + } + } + + private void assertGetClassThrowsNullPointerException( final String className ) throws Exception { + assertGetClassThrowsException( className, NullPointerException.class ); + } + @Test - public void testConstructor() { - assertNotNull(new ClassUtils()); - final Constructor[] cons = ClassUtils.class.getDeclaredConstructors(); - assertEquals(1, cons.length); - assertTrue(Modifier.isPublic(cons[0].getModifiers())); - assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers())); - assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers())); + public void test_convertClassesToClassNames_List() { + final List> list = new ArrayList<>(); + List result = ClassUtils.convertClassesToClassNames(list); + assertEquals(0, result.size()); + + list.add(String.class); + list.add(null); + list.add(Object.class); + result = ClassUtils.convertClassesToClassNames(list); + assertEquals(3, result.size()); + assertEquals("java.lang.String", result.get(0)); + assertNull(result.get(1)); + assertEquals("java.lang.Object", result.get(2)); + + @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element + final + List olist = (List)(List)list; + olist.add(new Object()); + try { + ClassUtils.convertClassesToClassNames(list); + fail("Should not have been able to convert list"); + } catch (final ClassCastException expected) {} + assertNull(ClassUtils.convertClassesToClassNames(null)); } // ------------------------------------------------------------------------- @Test - public void test_getShortClassName_Object() { - assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "")); - assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "")); - assertEquals("String", ClassUtils.getShortClassName("hello", "")); - assertEquals("", ClassUtils.getShortClassName(null, "")); + public void test_convertClassNamesToClasses_List() { + final List list = new ArrayList<>(); + List> result = ClassUtils.convertClassNamesToClasses(list); + assertEquals(0, result.size()); + + list.add("java.lang.String"); + list.add("java.lang.xxx"); + list.add("java.lang.Object"); + result = ClassUtils.convertClassNamesToClasses(list); + assertEquals(3, result.size()); + assertEquals(String.class, result.get(0)); + assertNull(result.get(1)); + assertEquals(Object.class, result.get(2)); + + @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element + final + List olist = (List)(List)list; + olist.add(new Object()); + try { + ClassUtils.convertClassNamesToClasses(list); + fail("Should not have been able to convert list"); + } catch (final ClassCastException expected) {} + assertNull(ClassUtils.convertClassNamesToClasses(null)); + } + + // ------------------------------------------------------------------------- + @Test + public void test_getAbbreviatedName_Class() { + assertEquals("", ClassUtils.getAbbreviatedName((Class)null, 1)); + assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 1)); + assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 5)); + assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 13)); + assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 15)); + assertEquals("java.lang.String", ClassUtils.getAbbreviatedName(String.class, 20)); + } + + @Test(expected = IllegalArgumentException.class) + public void test_getAbbreviatedName_Class_NegativeLen() { + ClassUtils.getAbbreviatedName(String.class, -10); + } + @Test(expected = IllegalArgumentException.class) + public void test_getAbbreviatedName_Class_ZeroLen() { + ClassUtils.getAbbreviatedName(String.class, 0); + } + @Test + public void test_getAbbreviatedName_String() { + assertEquals("", ClassUtils.getAbbreviatedName((String) null, 1)); + assertEquals("WithoutPackage", ClassUtils.getAbbreviatedName("WithoutPackage", 1)); + assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", 1)); + } + @Test + public void test_getAllInterfaces_Class() { + final List list = ClassUtils.getAllInterfaces(CY.class); + assertEquals(6, list.size()); + assertEquals(IB.class, list.get(0)); + assertEquals(IC.class, list.get(1)); + assertEquals(ID.class, list.get(2)); + assertEquals(IE.class, list.get(3)); + assertEquals(IF.class, list.get(4)); + assertEquals(IA.class, list.get(5)); + + assertNull(ClassUtils.getAllInterfaces(null)); + } + // ------------------------------------------------------------------------- + @Test + public void test_getAllSuperclasses_Class() { + final List list = ClassUtils.getAllSuperclasses(CY.class); + assertEquals(2, list.size()); + assertEquals(CX.class, list.get(0)); + assertEquals(Object.class, list.get(1)); + + assertNull(ClassUtils.getAllSuperclasses(null)); + } + @Test + public void test_getPackageCanonicalName_Class() { + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils.class)); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[].class)); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class)); + assertEquals("", ClassUtils.getPackageCanonicalName(int[].class)); + assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class)); // Inner types class Named {} - assertEquals("ClassUtilsTest.1", ClassUtils.getShortClassName(new Object(){}, "")); - assertEquals("ClassUtilsTest.1Named", ClassUtils.getShortClassName(new Named(), "")); - assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}.getClass())); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class)); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class)); + } + @Test + public void test_getPackageCanonicalName_Object() { + assertEquals("", ClassUtils.getPackageCanonicalName(null, "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils(), "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "")); + assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "")); + assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "")); + + // Inner types + class Named {} + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}, "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Named(), "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Inner(), "")); + } + @Test + public void test_getPackageCanonicalName_String() { + assertEquals("org.apache.commons.lang3", + ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils")); + assertEquals("org.apache.commons.lang3", + ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); + assertEquals("org.apache.commons.lang3", + ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); + assertEquals("org.apache.commons.lang3", + ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[]")); + assertEquals("org.apache.commons.lang3", + ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); + assertEquals("", ClassUtils.getPackageCanonicalName("[I")); + assertEquals("", ClassUtils.getPackageCanonicalName("[[I")); + assertEquals("", ClassUtils.getPackageCanonicalName("int[]")); + assertEquals("", ClassUtils.getPackageCanonicalName("int[][]")); + + // Inner types + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); + } + + @Test + public void test_getPackageName_Class() { + assertEquals("java.lang", ClassUtils.getPackageName(String.class)); + assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class)); + assertEquals("", ClassUtils.getPackageName((Class) null)); + + // LANG-535 + assertEquals("java.lang", ClassUtils.getPackageName(String[].class)); + + // Primitive Arrays + assertEquals("", ClassUtils.getPackageName(boolean[].class)); + assertEquals("", ClassUtils.getPackageName(byte[].class)); + assertEquals("", ClassUtils.getPackageName(char[].class)); + assertEquals("", ClassUtils.getPackageName(short[].class)); + assertEquals("", ClassUtils.getPackageName(int[].class)); + assertEquals("", ClassUtils.getPackageName(long[].class)); + assertEquals("", ClassUtils.getPackageName(float[].class)); + assertEquals("", ClassUtils.getPackageName(double[].class)); + + // Arrays of arrays of ... + assertEquals("java.lang", ClassUtils.getPackageName(String[][].class)); + assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class)); + assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class)); + + // On-the-fly types + class Named {} + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() { + }.getClass())); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(Named.class)); + } + + // ------------------------------------------------------------------------- + @Test + public void test_getPackageName_Object() { + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new ClassUtils(), "")); + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Inner(), "")); + assertEquals("", ClassUtils.getPackageName(null, "")); + } + + @Test + public void test_getPackageName_String() { + assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(ClassUtils.class.getName())); + assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName())); + assertEquals("", ClassUtils.getPackageName((String) null)); + assertEquals("", ClassUtils.getPackageName("")); + } + + @Test + public void test_getShortCanonicalName_Class() { + assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class)); + assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class)); + assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class)); + assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class)); + assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class)); + + // Inner types + class Named {} + assertEquals("ClassUtilsTest.7", ClassUtils.getShortCanonicalName(new Object(){}.getClass())); + assertEquals("ClassUtilsTest.6Named", ClassUtils.getShortCanonicalName(Named.class)); + assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(Inner.class)); + } + + @Test + public void test_getShortCanonicalName_Object() { + assertEquals("", ClassUtils.getShortCanonicalName(null, "")); + assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "")); + assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "")); + assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "")); + assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "")); + assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "")); + + // Inner types + class Named {} + assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName(new Object(){}, "")); + assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName(new Named(), "")); + assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(new Inner(), "")); + } + + @Test + public void test_getShortCanonicalName_String() { + assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils")); + assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); + assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); + assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[]")); + assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); + assertEquals("int[]", ClassUtils.getShortCanonicalName("[I")); + assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I")); + assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]")); + assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]")); + + // Inner types + assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); + assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); + assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); } @Test @@ -122,7 +392,20 @@ public class ClassUtilsTest { assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(Inner.class)); } + // ------------------------------------------------------------------------- + @Test + public void test_getShortClassName_Object() { + assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "")); + assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "")); + assertEquals("String", ClassUtils.getShortClassName("hello", "")); + assertEquals("", ClassUtils.getShortClassName(null, "")); + // Inner types + class Named {} + assertEquals("ClassUtilsTest.1", ClassUtils.getShortClassName(new Object(){}, "")); + assertEquals("ClassUtilsTest.1Named", ClassUtils.getShortClassName(new Named(), "")); + assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "")); + } @Test public void test_getShortClassName_String() { @@ -181,186 +464,54 @@ public class ClassUtilsTest { assertEquals("", ClassUtils.getSimpleName(null, "")); } - // ------------------------------------------------------------------------- @Test - public void test_getPackageName_Object() { - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new ClassUtils(), "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Inner(), "")); - assertEquals("", ClassUtils.getPackageName(null, "")); + public void test_isAssignable() throws Exception { + assertFalse(ClassUtils.isAssignable((Class) null, null)); + assertFalse(ClassUtils.isAssignable(String.class, null)); + + assertTrue(ClassUtils.isAssignable(null, Object.class)); + assertTrue(ClassUtils.isAssignable(null, Integer.class)); + assertFalse(ClassUtils.isAssignable(null, Integer.TYPE)); + assertTrue(ClassUtils.isAssignable(String.class, Object.class)); + assertTrue(ClassUtils.isAssignable(String.class, String.class)); + assertFalse(ClassUtils.isAssignable(Object.class, String.class)); + + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class)); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE)); + assertTrue(ClassUtils.isAssignable(Integer.class, Object.class)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Object.class)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class)); } @Test - public void test_getPackageName_Class() { - assertEquals("java.lang", ClassUtils.getPackageName(String.class)); - assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class)); - assertEquals("", ClassUtils.getPackageName((Class) null)); + public void test_isAssignable_Autoboxing() throws Exception { + assertFalse(ClassUtils.isAssignable((Class) null, null, true)); + assertFalse(ClassUtils.isAssignable(String.class, null, true)); - // LANG-535 - assertEquals("java.lang", ClassUtils.getPackageName(String[].class)); - - // Primitive Arrays - assertEquals("", ClassUtils.getPackageName(boolean[].class)); - assertEquals("", ClassUtils.getPackageName(byte[].class)); - assertEquals("", ClassUtils.getPackageName(char[].class)); - assertEquals("", ClassUtils.getPackageName(short[].class)); - assertEquals("", ClassUtils.getPackageName(int[].class)); - assertEquals("", ClassUtils.getPackageName(long[].class)); - assertEquals("", ClassUtils.getPackageName(float[].class)); - assertEquals("", ClassUtils.getPackageName(double[].class)); - - // Arrays of arrays of ... - assertEquals("java.lang", ClassUtils.getPackageName(String[][].class)); - assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class)); - assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class)); - - // On-the-fly types - class Named {} - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() { - }.getClass())); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(Named.class)); - } - - @Test - public void test_getPackageName_String() { - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(ClassUtils.class.getName())); - assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName())); - assertEquals("", ClassUtils.getPackageName((String) null)); - assertEquals("", ClassUtils.getPackageName("")); - } - - // ------------------------------------------------------------------------- - @Test - public void test_getAbbreviatedName_Class() { - assertEquals("", ClassUtils.getAbbreviatedName((Class)null, 1)); - assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 1)); - assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 5)); - assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 13)); - assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 15)); - assertEquals("java.lang.String", ClassUtils.getAbbreviatedName(String.class, 20)); - } - - @Test(expected = IllegalArgumentException.class) - public void test_getAbbreviatedName_Class_ZeroLen() { - ClassUtils.getAbbreviatedName(String.class, 0); - } - - @Test(expected = IllegalArgumentException.class) - public void test_getAbbreviatedName_Class_NegativeLen() { - ClassUtils.getAbbreviatedName(String.class, -10); - } - - @Test - public void test_getAbbreviatedName_String() { - assertEquals("", ClassUtils.getAbbreviatedName((String) null, 1)); - assertEquals("WithoutPackage", ClassUtils.getAbbreviatedName("WithoutPackage", 1)); - assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", 1)); - } - - // ------------------------------------------------------------------------- - @Test - public void test_getAllSuperclasses_Class() { - final List list = ClassUtils.getAllSuperclasses(CY.class); - assertEquals(2, list.size()); - assertEquals(CX.class, list.get(0)); - assertEquals(Object.class, list.get(1)); - - assertNull(ClassUtils.getAllSuperclasses(null)); - } - - @Test - public void test_getAllInterfaces_Class() { - final List list = ClassUtils.getAllInterfaces(CY.class); - assertEquals(6, list.size()); - assertEquals(IB.class, list.get(0)); - assertEquals(IC.class, list.get(1)); - assertEquals(ID.class, list.get(2)); - assertEquals(IE.class, list.get(3)); - assertEquals(IF.class, list.get(4)); - assertEquals(IA.class, list.get(5)); - - assertNull(ClassUtils.getAllInterfaces(null)); - } - - private interface IA { - } - private interface IB { - } - private interface IC extends ID, IE { - } - private interface ID { - } - private interface IE extends IF { - } - private interface IF { - } - private static class CX implements IB, IA, IE { - } - private static class CY extends CX implements IB, IC { - } - - // ------------------------------------------------------------------------- - @Test - public void test_convertClassNamesToClasses_List() { - final List list = new ArrayList<>(); - List> result = ClassUtils.convertClassNamesToClasses(list); - assertEquals(0, result.size()); - - list.add("java.lang.String"); - list.add("java.lang.xxx"); - list.add("java.lang.Object"); - result = ClassUtils.convertClassNamesToClasses(list); - assertEquals(3, result.size()); - assertEquals(String.class, result.get(0)); - assertNull(result.get(1)); - assertEquals(Object.class, result.get(2)); - - @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element - final - List olist = (List)(List)list; - olist.add(new Object()); - try { - ClassUtils.convertClassNamesToClasses(list); - fail("Should not have been able to convert list"); - } catch (final ClassCastException expected) {} - assertNull(ClassUtils.convertClassNamesToClasses(null)); - } - - @Test - public void test_convertClassesToClassNames_List() { - final List> list = new ArrayList<>(); - List result = ClassUtils.convertClassesToClassNames(list); - assertEquals(0, result.size()); - - list.add(String.class); - list.add(null); - list.add(Object.class); - result = ClassUtils.convertClassesToClassNames(list); - assertEquals(3, result.size()); - assertEquals("java.lang.String", result.get(0)); - assertNull(result.get(1)); - assertEquals("java.lang.Object", result.get(2)); - - @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element - final - List olist = (List)(List)list; - olist.add(new Object()); - try { - ClassUtils.convertClassesToClassNames(list); - fail("Should not have been able to convert list"); - } catch (final ClassCastException expected) {} - assertNull(ClassUtils.convertClassesToClassNames(null)); - } - - // ------------------------------------------------------------------------- - @Test - public void test_isInnerClass_Class() { - assertTrue(ClassUtils.isInnerClass(Inner.class)); - assertTrue(ClassUtils.isInnerClass(Map.Entry.class)); - assertTrue(ClassUtils.isInnerClass(new Cloneable() { - }.getClass())); - assertFalse(ClassUtils.isInnerClass(this.getClass())); - assertFalse(ClassUtils.isInnerClass(String.class)); - assertFalse(ClassUtils.isInnerClass(null)); + assertTrue(ClassUtils.isAssignable(null, Object.class, true)); + assertTrue(ClassUtils.isAssignable(null, Integer.class, true)); + assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, true)); + assertTrue(ClassUtils.isAssignable(String.class, Object.class, true)); + assertTrue(ClassUtils.isAssignable(String.class, String.class, true)); + assertFalse(ClassUtils.isAssignable(Object.class, String.class, true)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class, true)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class, true)); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true)); + assertTrue(ClassUtils.isAssignable(Integer.class, Object.class, true)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, true)); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, true)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, true)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, true)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, true)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, true)); } // ------------------------------------------------------------------------- @@ -448,163 +599,6 @@ public class ClassUtilsTest { assertFalse(ClassUtils.isAssignable(arrayPrimitives, array2, false)); } - @Test - public void test_isAssignable() throws Exception { - assertFalse(ClassUtils.isAssignable((Class) null, null)); - assertFalse(ClassUtils.isAssignable(String.class, null)); - - assertTrue(ClassUtils.isAssignable(null, Object.class)); - assertTrue(ClassUtils.isAssignable(null, Integer.class)); - assertFalse(ClassUtils.isAssignable(null, Integer.TYPE)); - assertTrue(ClassUtils.isAssignable(String.class, Object.class)); - assertTrue(ClassUtils.isAssignable(String.class, String.class)); - assertFalse(ClassUtils.isAssignable(Object.class, String.class)); - - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class)); - assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE)); - assertTrue(ClassUtils.isAssignable(Integer.class, Object.class)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); - assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Object.class)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class)); - } - - @Test - public void test_isAssignable_Autoboxing() throws Exception { - assertFalse(ClassUtils.isAssignable((Class) null, null, true)); - assertFalse(ClassUtils.isAssignable(String.class, null, true)); - - assertTrue(ClassUtils.isAssignable(null, Object.class, true)); - assertTrue(ClassUtils.isAssignable(null, Integer.class, true)); - assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, true)); - assertTrue(ClassUtils.isAssignable(String.class, Object.class, true)); - assertTrue(ClassUtils.isAssignable(String.class, String.class, true)); - assertFalse(ClassUtils.isAssignable(Object.class, String.class, true)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class, true)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class, true)); - assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true)); - assertTrue(ClassUtils.isAssignable(Integer.class, Object.class, true)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, true)); - assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, true)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, true)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, true)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, true)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, true)); - } - - @Test - public void test_isAssignable_NoAutoboxing() throws Exception { - assertFalse(ClassUtils.isAssignable((Class) null, null, false)); - assertFalse(ClassUtils.isAssignable(String.class, null, false)); - - assertTrue(ClassUtils.isAssignable(null, Object.class, false)); - assertTrue(ClassUtils.isAssignable(null, Integer.class, false)); - assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, false)); - assertTrue(ClassUtils.isAssignable(String.class, Object.class, false)); - assertTrue(ClassUtils.isAssignable(String.class, String.class, false)); - assertFalse(ClassUtils.isAssignable(Object.class, String.class, false)); - assertFalse(ClassUtils.isAssignable(Integer.TYPE, Integer.class, false)); - assertFalse(ClassUtils.isAssignable(Integer.TYPE, Object.class, false)); - assertFalse(ClassUtils.isAssignable(Integer.class, Integer.TYPE, false)); - assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, false)); - assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, false)); - assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, false)); - assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Object.class, false)); - assertFalse(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, false)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, false)); - assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, false)); - assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, false)); - } - - @Test - public void test_isAssignable_Widening() throws Exception { - // test byte conversions - assertFalse("byte -> char", ClassUtils.isAssignable(Byte.TYPE, Character.TYPE)); - assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE)); - assertTrue("byte -> short", ClassUtils.isAssignable(Byte.TYPE, Short.TYPE)); - assertTrue("byte -> int", ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE)); - assertTrue("byte -> long", ClassUtils.isAssignable(Byte.TYPE, Long.TYPE)); - assertTrue("byte -> float", ClassUtils.isAssignable(Byte.TYPE, Float.TYPE)); - assertTrue("byte -> double", ClassUtils.isAssignable(Byte.TYPE, Double.TYPE)); - assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE)); - - // test short conversions - assertFalse("short -> char", ClassUtils.isAssignable(Short.TYPE, Character.TYPE)); - assertFalse("short -> byte", ClassUtils.isAssignable(Short.TYPE, Byte.TYPE)); - assertTrue("short -> short", ClassUtils.isAssignable(Short.TYPE, Short.TYPE)); - assertTrue("short -> int", ClassUtils.isAssignable(Short.TYPE, Integer.TYPE)); - assertTrue("short -> long", ClassUtils.isAssignable(Short.TYPE, Long.TYPE)); - assertTrue("short -> float", ClassUtils.isAssignable(Short.TYPE, Float.TYPE)); - assertTrue("short -> double", ClassUtils.isAssignable(Short.TYPE, Double.TYPE)); - assertFalse("short -> boolean", ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE)); - - // test char conversions - assertTrue("char -> char", ClassUtils.isAssignable(Character.TYPE, Character.TYPE)); - assertFalse("char -> byte", ClassUtils.isAssignable(Character.TYPE, Byte.TYPE)); - assertFalse("char -> short", ClassUtils.isAssignable(Character.TYPE, Short.TYPE)); - assertTrue("char -> int", ClassUtils.isAssignable(Character.TYPE, Integer.TYPE)); - assertTrue("char -> long", ClassUtils.isAssignable(Character.TYPE, Long.TYPE)); - assertTrue("char -> float", ClassUtils.isAssignable(Character.TYPE, Float.TYPE)); - assertTrue("char -> double", ClassUtils.isAssignable(Character.TYPE, Double.TYPE)); - assertFalse("char -> boolean", ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE)); - - // test int conversions - assertFalse("int -> char", ClassUtils.isAssignable(Integer.TYPE, Character.TYPE)); - assertFalse("int -> byte", ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE)); - assertFalse("int -> short", ClassUtils.isAssignable(Integer.TYPE, Short.TYPE)); - assertTrue("int -> int", ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); - assertTrue("int -> long", ClassUtils.isAssignable(Integer.TYPE, Long.TYPE)); - assertTrue("int -> float", ClassUtils.isAssignable(Integer.TYPE, Float.TYPE)); - assertTrue("int -> double", ClassUtils.isAssignable(Integer.TYPE, Double.TYPE)); - assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE)); - - // test long conversions - assertFalse("long -> char", ClassUtils.isAssignable(Long.TYPE, Character.TYPE)); - assertFalse("long -> byte", ClassUtils.isAssignable(Long.TYPE, Byte.TYPE)); - assertFalse("long -> short", ClassUtils.isAssignable(Long.TYPE, Short.TYPE)); - assertFalse("long -> int", ClassUtils.isAssignable(Long.TYPE, Integer.TYPE)); - assertTrue("long -> long", ClassUtils.isAssignable(Long.TYPE, Long.TYPE)); - assertTrue("long -> float", ClassUtils.isAssignable(Long.TYPE, Float.TYPE)); - assertTrue("long -> double", ClassUtils.isAssignable(Long.TYPE, Double.TYPE)); - assertFalse("long -> boolean", ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE)); - - // test float conversions - assertFalse("float -> char", ClassUtils.isAssignable(Float.TYPE, Character.TYPE)); - assertFalse("float -> byte", ClassUtils.isAssignable(Float.TYPE, Byte.TYPE)); - assertFalse("float -> short", ClassUtils.isAssignable(Float.TYPE, Short.TYPE)); - assertFalse("float -> int", ClassUtils.isAssignable(Float.TYPE, Integer.TYPE)); - assertFalse("float -> long", ClassUtils.isAssignable(Float.TYPE, Long.TYPE)); - assertTrue("float -> float", ClassUtils.isAssignable(Float.TYPE, Float.TYPE)); - assertTrue("float -> double", ClassUtils.isAssignable(Float.TYPE, Double.TYPE)); - assertFalse("float -> boolean", ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE)); - - // test double conversions - assertFalse("double -> char", ClassUtils.isAssignable(Double.TYPE, Character.TYPE)); - assertFalse("double -> byte", ClassUtils.isAssignable(Double.TYPE, Byte.TYPE)); - assertFalse("double -> short", ClassUtils.isAssignable(Double.TYPE, Short.TYPE)); - assertFalse("double -> int", ClassUtils.isAssignable(Double.TYPE, Integer.TYPE)); - assertFalse("double -> long", ClassUtils.isAssignable(Double.TYPE, Long.TYPE)); - assertFalse("double -> float", ClassUtils.isAssignable(Double.TYPE, Float.TYPE)); - assertTrue("double -> double", ClassUtils.isAssignable(Double.TYPE, Double.TYPE)); - assertFalse("double -> boolean", ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE)); - - // test boolean conversions - assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE)); - assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE)); - assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE)); - assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE)); - assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE)); - assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE)); - assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE)); - assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); - } - @Test public void test_isAssignable_DefaultUnboxing_Widening() throws Exception { // test byte conversions @@ -688,6 +682,30 @@ public class ClassUtilsTest { assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.class, Boolean.TYPE)); } + @Test + public void test_isAssignable_NoAutoboxing() throws Exception { + assertFalse(ClassUtils.isAssignable((Class) null, null, false)); + assertFalse(ClassUtils.isAssignable(String.class, null, false)); + + assertTrue(ClassUtils.isAssignable(null, Object.class, false)); + assertTrue(ClassUtils.isAssignable(null, Integer.class, false)); + assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, false)); + assertTrue(ClassUtils.isAssignable(String.class, Object.class, false)); + assertTrue(ClassUtils.isAssignable(String.class, String.class, false)); + assertFalse(ClassUtils.isAssignable(Object.class, String.class, false)); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Integer.class, false)); + assertFalse(ClassUtils.isAssignable(Integer.TYPE, Object.class, false)); + assertFalse(ClassUtils.isAssignable(Integer.class, Integer.TYPE, false)); + assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, false)); + assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, false)); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, false)); + assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Object.class, false)); + assertFalse(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, false)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, false)); + assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, false)); + assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, false)); + } + @Test public void test_isAssignable_Unboxing_Widening() throws Exception { // test byte conversions @@ -771,6 +789,245 @@ public class ClassUtilsTest { assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true)); } + @Test + public void test_isAssignable_Widening() throws Exception { + // test byte conversions + assertFalse("byte -> char", ClassUtils.isAssignable(Byte.TYPE, Character.TYPE)); + assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE)); + assertTrue("byte -> short", ClassUtils.isAssignable(Byte.TYPE, Short.TYPE)); + assertTrue("byte -> int", ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE)); + assertTrue("byte -> long", ClassUtils.isAssignable(Byte.TYPE, Long.TYPE)); + assertTrue("byte -> float", ClassUtils.isAssignable(Byte.TYPE, Float.TYPE)); + assertTrue("byte -> double", ClassUtils.isAssignable(Byte.TYPE, Double.TYPE)); + assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE)); + + // test short conversions + assertFalse("short -> char", ClassUtils.isAssignable(Short.TYPE, Character.TYPE)); + assertFalse("short -> byte", ClassUtils.isAssignable(Short.TYPE, Byte.TYPE)); + assertTrue("short -> short", ClassUtils.isAssignable(Short.TYPE, Short.TYPE)); + assertTrue("short -> int", ClassUtils.isAssignable(Short.TYPE, Integer.TYPE)); + assertTrue("short -> long", ClassUtils.isAssignable(Short.TYPE, Long.TYPE)); + assertTrue("short -> float", ClassUtils.isAssignable(Short.TYPE, Float.TYPE)); + assertTrue("short -> double", ClassUtils.isAssignable(Short.TYPE, Double.TYPE)); + assertFalse("short -> boolean", ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE)); + + // test char conversions + assertTrue("char -> char", ClassUtils.isAssignable(Character.TYPE, Character.TYPE)); + assertFalse("char -> byte", ClassUtils.isAssignable(Character.TYPE, Byte.TYPE)); + assertFalse("char -> short", ClassUtils.isAssignable(Character.TYPE, Short.TYPE)); + assertTrue("char -> int", ClassUtils.isAssignable(Character.TYPE, Integer.TYPE)); + assertTrue("char -> long", ClassUtils.isAssignable(Character.TYPE, Long.TYPE)); + assertTrue("char -> float", ClassUtils.isAssignable(Character.TYPE, Float.TYPE)); + assertTrue("char -> double", ClassUtils.isAssignable(Character.TYPE, Double.TYPE)); + assertFalse("char -> boolean", ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE)); + + // test int conversions + assertFalse("int -> char", ClassUtils.isAssignable(Integer.TYPE, Character.TYPE)); + assertFalse("int -> byte", ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE)); + assertFalse("int -> short", ClassUtils.isAssignable(Integer.TYPE, Short.TYPE)); + assertTrue("int -> int", ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE)); + assertTrue("int -> long", ClassUtils.isAssignable(Integer.TYPE, Long.TYPE)); + assertTrue("int -> float", ClassUtils.isAssignable(Integer.TYPE, Float.TYPE)); + assertTrue("int -> double", ClassUtils.isAssignable(Integer.TYPE, Double.TYPE)); + assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE)); + + // test long conversions + assertFalse("long -> char", ClassUtils.isAssignable(Long.TYPE, Character.TYPE)); + assertFalse("long -> byte", ClassUtils.isAssignable(Long.TYPE, Byte.TYPE)); + assertFalse("long -> short", ClassUtils.isAssignable(Long.TYPE, Short.TYPE)); + assertFalse("long -> int", ClassUtils.isAssignable(Long.TYPE, Integer.TYPE)); + assertTrue("long -> long", ClassUtils.isAssignable(Long.TYPE, Long.TYPE)); + assertTrue("long -> float", ClassUtils.isAssignable(Long.TYPE, Float.TYPE)); + assertTrue("long -> double", ClassUtils.isAssignable(Long.TYPE, Double.TYPE)); + assertFalse("long -> boolean", ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE)); + + // test float conversions + assertFalse("float -> char", ClassUtils.isAssignable(Float.TYPE, Character.TYPE)); + assertFalse("float -> byte", ClassUtils.isAssignable(Float.TYPE, Byte.TYPE)); + assertFalse("float -> short", ClassUtils.isAssignable(Float.TYPE, Short.TYPE)); + assertFalse("float -> int", ClassUtils.isAssignable(Float.TYPE, Integer.TYPE)); + assertFalse("float -> long", ClassUtils.isAssignable(Float.TYPE, Long.TYPE)); + assertTrue("float -> float", ClassUtils.isAssignable(Float.TYPE, Float.TYPE)); + assertTrue("float -> double", ClassUtils.isAssignable(Float.TYPE, Double.TYPE)); + assertFalse("float -> boolean", ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE)); + + // test double conversions + assertFalse("double -> char", ClassUtils.isAssignable(Double.TYPE, Character.TYPE)); + assertFalse("double -> byte", ClassUtils.isAssignable(Double.TYPE, Byte.TYPE)); + assertFalse("double -> short", ClassUtils.isAssignable(Double.TYPE, Short.TYPE)); + assertFalse("double -> int", ClassUtils.isAssignable(Double.TYPE, Integer.TYPE)); + assertFalse("double -> long", ClassUtils.isAssignable(Double.TYPE, Long.TYPE)); + assertFalse("double -> float", ClassUtils.isAssignable(Double.TYPE, Float.TYPE)); + assertTrue("double -> double", ClassUtils.isAssignable(Double.TYPE, Double.TYPE)); + assertFalse("double -> boolean", ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE)); + + // test boolean conversions + assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE)); + assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE)); + assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE)); + assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE)); + assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE)); + assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE)); + assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE)); + assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE)); + } + + // ------------------------------------------------------------------------- + @Test + public void test_isInnerClass_Class() { + assertTrue(ClassUtils.isInnerClass(Inner.class)); + assertTrue(ClassUtils.isInnerClass(Map.Entry.class)); + assertTrue(ClassUtils.isInnerClass(new Cloneable() { + }.getClass())); + assertFalse(ClassUtils.isInnerClass(this.getClass())); + assertFalse(ClassUtils.isInnerClass(String.class)); + assertFalse(ClassUtils.isInnerClass(null)); + } + + //----------------------------------------------------------------------- + @Test + public void testConstructor() { + assertNotNull(new ClassUtils()); + final Constructor[] cons = ClassUtils.class.getDeclaredConstructors(); + assertEquals(1, cons.length); + assertTrue(Modifier.isPublic(cons[0].getModifiers())); + assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers())); + assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers())); + } + + @Test + public void testGetClassByNormalNameArrays() throws ClassNotFoundException { + assertEquals( int[].class, ClassUtils.getClass( "int[]" ) ); + assertEquals( long[].class, ClassUtils.getClass( "long[]" ) ); + assertEquals( short[].class, ClassUtils.getClass( "short[]" ) ); + assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) ); + assertEquals( char[].class, ClassUtils.getClass( "char[]" ) ); + assertEquals( float[].class, ClassUtils.getClass( "float[]" ) ); + assertEquals( double[].class, ClassUtils.getClass( "double[]" ) ); + assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) ); + assertEquals( String[].class, ClassUtils.getClass( "java.lang.String[]" ) ); + assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map.Entry[]" ) ); + assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map$Entry[]" ) ); + assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map.Entry;" ) ); + assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map$Entry;" ) ); + } + + @Test + public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException { + assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) ); + assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) ); + assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) ); + assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) ); + assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) ); + assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) ); + assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) ); + assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" ) ); + assertEquals( String[][].class, ClassUtils.getClass( "java.lang.String[][]" ) ); + } + + @Test + public void testGetClassClassNotFound() throws Exception { + assertGetClassThrowsClassNotFound( "bool" ); + assertGetClassThrowsClassNotFound( "bool[]" ); + assertGetClassThrowsClassNotFound( "integer[]" ); + } + + @Test + public void testGetClassInvalidArguments() throws Exception { + assertGetClassThrowsNullPointerException( null ); + assertGetClassThrowsClassNotFound( "[][][]" ); + assertGetClassThrowsClassNotFound( "[[]" ); + assertGetClassThrowsClassNotFound( "[" ); + assertGetClassThrowsClassNotFound( "java.lang.String][" ); + assertGetClassThrowsClassNotFound( ".hello.world" ); + assertGetClassThrowsClassNotFound( "hello..world" ); + } + + @Test + public void testGetClassRawPrimitives() throws ClassNotFoundException { + assertEquals( int.class, ClassUtils.getClass( "int" ) ); + assertEquals( long.class, ClassUtils.getClass( "long" ) ); + assertEquals( short.class, ClassUtils.getClass( "short" ) ); + assertEquals( byte.class, ClassUtils.getClass( "byte" ) ); + assertEquals( char.class, ClassUtils.getClass( "char" ) ); + assertEquals( float.class, ClassUtils.getClass( "float" ) ); + assertEquals( double.class, ClassUtils.getClass( "double" ) ); + assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) ); + assertEquals( void.class, ClassUtils.getClass( "void" ) ); + } + + @Test + public void testGetClassWithArrayClasses() throws Exception { + assertGetClassReturnsClass( String[].class ); + assertGetClassReturnsClass( int[].class ); + assertGetClassReturnsClass( long[].class ); + assertGetClassReturnsClass( short[].class ); + assertGetClassReturnsClass( byte[].class ); + assertGetClassReturnsClass( char[].class ); + assertGetClassReturnsClass( float[].class ); + assertGetClassReturnsClass( double[].class ); + assertGetClassReturnsClass( boolean[].class ); + } + + @Test + public void testGetClassWithArrayClasses2D() throws Exception { + assertGetClassReturnsClass( String[][].class ); + assertGetClassReturnsClass( int[][].class ); + assertGetClassReturnsClass( long[][].class ); + assertGetClassReturnsClass( short[][].class ); + assertGetClassReturnsClass( byte[][].class ); + assertGetClassReturnsClass( char[][].class ); + assertGetClassReturnsClass( float[][].class ); + assertGetClassReturnsClass( double[][].class ); + assertGetClassReturnsClass( boolean[][].class ); + } + + @Test + public void testGetInnerClass() throws ClassNotFoundException { + assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested" ) ); + assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested" ) ); + assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested" ) ); + assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" ) ); + } + + @Test + public void testGetPublicMethod() throws Exception { + // Tests with Collections$UnmodifiableSet + final Set set = Collections.unmodifiableSet(new HashSet<>()); + final Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty"); + assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers())); + + try { + isEmptyMethod.invoke(set); + } catch(final java.lang.IllegalAccessException iae) { + fail("Should not have thrown IllegalAccessException"); + } + + // Tests with a public Class + final Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString"); + assertEquals(Object.class.getMethod("toString", new Class[0]), toStringMethod); + } + + @Test + public void testHierarchyExcludingInterfaces() { + final Iterator> iter = ClassUtils.hierarchy(StringParameterizedChild.class).iterator(); + assertEquals(StringParameterizedChild.class, iter.next()); + assertEquals(GenericParent.class, iter.next()); + assertEquals(Object.class, iter.next()); + assertFalse(iter.hasNext()); + } + + @Test + public void testHierarchyIncludingInterfaces() { + final Iterator> iter = + ClassUtils.hierarchy(StringParameterizedChild.class, Interfaces.INCLUDE).iterator(); + assertEquals(StringParameterizedChild.class, iter.next()); + assertEquals(GenericParent.class, iter.next()); + assertEquals(GenericConsumer.class, iter.next()); + assertEquals(Object.class, iter.next()); + assertFalse(iter.hasNext()); + } + @Test public void testIsPrimitiveOrWrapper() { @@ -833,41 +1090,6 @@ public class ClassUtilsTest { assertFalse("this.getClass()", ClassUtils.isPrimitiveWrapper(this.getClass())); } - @Test - public void testPrimitiveToWrapper() { - - // test primitive classes - assertEquals("boolean -> Boolean.class", - Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE)); - assertEquals("byte -> Byte.class", - Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE)); - assertEquals("char -> Character.class", - Character.class, ClassUtils.primitiveToWrapper(Character.TYPE)); - assertEquals("short -> Short.class", - Short.class, ClassUtils.primitiveToWrapper(Short.TYPE)); - assertEquals("int -> Integer.class", - Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE)); - assertEquals("long -> Long.class", - Long.class, ClassUtils.primitiveToWrapper(Long.TYPE)); - assertEquals("double -> Double.class", - Double.class, ClassUtils.primitiveToWrapper(Double.TYPE)); - assertEquals("float -> Float.class", - Float.class, ClassUtils.primitiveToWrapper(Float.TYPE)); - - // test a few other classes - assertEquals("String.class -> String.class", - String.class, ClassUtils.primitiveToWrapper(String.class)); - assertEquals("ClassUtils.class -> ClassUtils.class", - org.apache.commons.lang3.ClassUtils.class, - ClassUtils.primitiveToWrapper(org.apache.commons.lang3.ClassUtils.class)); - assertEquals("Void.TYPE -> Void.TYPE", - Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE)); - - // test null - assertNull("null -> null", - ClassUtils.primitiveToWrapper(null)); - } - @Test public void testPrimitivesToWrappers() { // test null @@ -905,6 +1127,118 @@ public class ClassUtilsTest { assertNotSame("unmodified", noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives)); } + @Test + public void testPrimitiveToWrapper() { + + // test primitive classes + assertEquals("boolean -> Boolean.class", + Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE)); + assertEquals("byte -> Byte.class", + Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE)); + assertEquals("char -> Character.class", + Character.class, ClassUtils.primitiveToWrapper(Character.TYPE)); + assertEquals("short -> Short.class", + Short.class, ClassUtils.primitiveToWrapper(Short.TYPE)); + assertEquals("int -> Integer.class", + Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE)); + assertEquals("long -> Long.class", + Long.class, ClassUtils.primitiveToWrapper(Long.TYPE)); + assertEquals("double -> Double.class", + Double.class, ClassUtils.primitiveToWrapper(Double.TYPE)); + assertEquals("float -> Float.class", + Float.class, ClassUtils.primitiveToWrapper(Float.TYPE)); + + // test a few other classes + assertEquals("String.class -> String.class", + String.class, ClassUtils.primitiveToWrapper(String.class)); + assertEquals("ClassUtils.class -> ClassUtils.class", + org.apache.commons.lang3.ClassUtils.class, + ClassUtils.primitiveToWrapper(org.apache.commons.lang3.ClassUtils.class)); + assertEquals("Void.TYPE -> Void.TYPE", + Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE)); + + // test null + assertNull("null -> null", + ClassUtils.primitiveToWrapper(null)); + } + + // Show the Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957 + // We may have to delete this if a JDK fixes the bug. + @Test + public void testShowJavaBug() throws Exception { + // Tests with Collections$UnmodifiableSet + final Set set = Collections.unmodifiableSet(new HashSet<>()); + final Method isEmptyMethod = set.getClass().getMethod("isEmpty"); + try { + isEmptyMethod.invoke(set); + fail("Failed to throw IllegalAccessException as expected"); + } catch(final IllegalAccessException iae) { + // expected + } + } + + @Test + public void testToClass_object() { +// assertNull(ClassUtils.toClass(null)); // generates warning + assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast + + // Additional varargs tests + assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass())); + final Class[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null} + assertTrue("(Object)null -> [null]", Arrays.equals(new Object[]{null}, castNull)); + + assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY)); + + assertTrue(Arrays.equals(new Class[] { String.class, Integer.class, Double.class }, + ClassUtils.toClass("Test", Integer.valueOf(1), Double.valueOf(99d)))); + + assertTrue(Arrays.equals(new Class[] { String.class, null, Double.class }, + ClassUtils.toClass("Test", null, Double.valueOf(99d)))); + } + + @Test + public void testWithInterleavingWhitespace() throws ClassNotFoundException { + assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) ); + assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) ); + assertEquals( short[].class, ClassUtils.getClass( "\tshort \t\t[]" ) ); + assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r] " ) ); + } + + @Test + public void testWrappersToPrimitives() { + // an array with classes to test + final Class[] classes = { + Boolean.class, Byte.class, Character.class, Short.class, + Integer.class, Long.class, Float.class, Double.class, + String.class, ClassUtils.class, null + }; + + final Class[] primitives = ClassUtils.wrappersToPrimitives(classes); + // now test the result + assertEquals("Wrong length of result array", classes.length, primitives.length); + for (int i = 0; i < classes.length; i++) { + final Class expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]); + assertEquals(classes[i] + " -> " + expectedPrimitive, expectedPrimitive, + primitives[i]); + } + } + + @Test + public void testWrappersToPrimitivesEmpty() { + final Class[] empty = new Class[0]; + assertArrayEquals("Wrong result for empty input", empty, ClassUtils.wrappersToPrimitives(empty)); + } + + @Test + public void testWrappersToPrimitivesNull() { +// assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning + assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives((Class[]) null)); // equivalent cast + // Other possible casts for null + assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives())); + final Class[] castNull = ClassUtils.wrappersToPrimitives((Class)null); // == new Class[]{null} + assertTrue("(Class)null -> [null]", Arrays.equals(new Class[]{null}, castNull)); +} + @Test public void testWrapperToPrimitive() { // an array with classes to convert @@ -929,338 +1263,4 @@ public class ClassUtilsTest { public void testWrapperToPrimitiveNull() { assertNull("Wrong result for null class", ClassUtils.wrapperToPrimitive(null)); } - - @Test - public void testWrappersToPrimitives() { - // an array with classes to test - final Class[] classes = { - Boolean.class, Byte.class, Character.class, Short.class, - Integer.class, Long.class, Float.class, Double.class, - String.class, ClassUtils.class, null - }; - - final Class[] primitives = ClassUtils.wrappersToPrimitives(classes); - // now test the result - assertEquals("Wrong length of result array", classes.length, primitives.length); - for (int i = 0; i < classes.length; i++) { - final Class expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]); - assertEquals(classes[i] + " -> " + expectedPrimitive, expectedPrimitive, - primitives[i]); - } - } - - @Test - public void testWrappersToPrimitivesNull() { -// assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning - assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives((Class[]) null)); // equivalent cast - // Other possible casts for null - assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives())); - final Class[] castNull = ClassUtils.wrappersToPrimitives((Class)null); // == new Class[]{null} - assertTrue("(Class)null -> [null]", Arrays.equals(new Class[]{null}, castNull)); -} - - @Test - public void testWrappersToPrimitivesEmpty() { - final Class[] empty = new Class[0]; - assertArrayEquals("Wrong result for empty input", empty, ClassUtils.wrappersToPrimitives(empty)); - } - - @Test - public void testGetClassClassNotFound() throws Exception { - assertGetClassThrowsClassNotFound( "bool" ); - assertGetClassThrowsClassNotFound( "bool[]" ); - assertGetClassThrowsClassNotFound( "integer[]" ); - } - - @Test - public void testGetClassInvalidArguments() throws Exception { - assertGetClassThrowsNullPointerException( null ); - assertGetClassThrowsClassNotFound( "[][][]" ); - assertGetClassThrowsClassNotFound( "[[]" ); - assertGetClassThrowsClassNotFound( "[" ); - assertGetClassThrowsClassNotFound( "java.lang.String][" ); - assertGetClassThrowsClassNotFound( ".hello.world" ); - assertGetClassThrowsClassNotFound( "hello..world" ); - } - - @Test - public void testWithInterleavingWhitespace() throws ClassNotFoundException { - assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) ); - assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) ); - assertEquals( short[].class, ClassUtils.getClass( "\tshort \t\t[]" ) ); - assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r] " ) ); - } - - @Test - public void testGetInnerClass() throws ClassNotFoundException { - assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested" ) ); - assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested" ) ); - assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested" ) ); - assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" ) ); - } - - @Test - public void testGetClassByNormalNameArrays() throws ClassNotFoundException { - assertEquals( int[].class, ClassUtils.getClass( "int[]" ) ); - assertEquals( long[].class, ClassUtils.getClass( "long[]" ) ); - assertEquals( short[].class, ClassUtils.getClass( "short[]" ) ); - assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) ); - assertEquals( char[].class, ClassUtils.getClass( "char[]" ) ); - assertEquals( float[].class, ClassUtils.getClass( "float[]" ) ); - assertEquals( double[].class, ClassUtils.getClass( "double[]" ) ); - assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) ); - assertEquals( String[].class, ClassUtils.getClass( "java.lang.String[]" ) ); - assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map.Entry[]" ) ); - assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map$Entry[]" ) ); - assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map.Entry;" ) ); - assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map$Entry;" ) ); - } - - @Test - public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException { - assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) ); - assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) ); - assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) ); - assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) ); - assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) ); - assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) ); - assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) ); - assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" ) ); - assertEquals( String[][].class, ClassUtils.getClass( "java.lang.String[][]" ) ); - } - - @Test - public void testGetClassWithArrayClasses2D() throws Exception { - assertGetClassReturnsClass( String[][].class ); - assertGetClassReturnsClass( int[][].class ); - assertGetClassReturnsClass( long[][].class ); - assertGetClassReturnsClass( short[][].class ); - assertGetClassReturnsClass( byte[][].class ); - assertGetClassReturnsClass( char[][].class ); - assertGetClassReturnsClass( float[][].class ); - assertGetClassReturnsClass( double[][].class ); - assertGetClassReturnsClass( boolean[][].class ); - } - - @Test - public void testGetClassWithArrayClasses() throws Exception { - assertGetClassReturnsClass( String[].class ); - assertGetClassReturnsClass( int[].class ); - assertGetClassReturnsClass( long[].class ); - assertGetClassReturnsClass( short[].class ); - assertGetClassReturnsClass( byte[].class ); - assertGetClassReturnsClass( char[].class ); - assertGetClassReturnsClass( float[].class ); - assertGetClassReturnsClass( double[].class ); - assertGetClassReturnsClass( boolean[].class ); - } - - @Test - public void testGetClassRawPrimitives() throws ClassNotFoundException { - assertEquals( int.class, ClassUtils.getClass( "int" ) ); - assertEquals( long.class, ClassUtils.getClass( "long" ) ); - assertEquals( short.class, ClassUtils.getClass( "short" ) ); - assertEquals( byte.class, ClassUtils.getClass( "byte" ) ); - assertEquals( char.class, ClassUtils.getClass( "char" ) ); - assertEquals( float.class, ClassUtils.getClass( "float" ) ); - assertEquals( double.class, ClassUtils.getClass( "double" ) ); - assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) ); - assertEquals( void.class, ClassUtils.getClass( "void" ) ); - } - - private void assertGetClassReturnsClass( final Class c ) throws Exception { - assertEquals( c, ClassUtils.getClass( c.getName() ) ); - } - - private void assertGetClassThrowsException( final String className, final Class exceptionType ) throws Exception { - try { - ClassUtils.getClass( className ); - fail( "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"." ); - } catch( final Exception e ) { - assertTrue( exceptionType.isAssignableFrom( e.getClass() ) ); - } - } - - private void assertGetClassThrowsNullPointerException( final String className ) throws Exception { - assertGetClassThrowsException( className, NullPointerException.class ); - } - - private void assertGetClassThrowsClassNotFound( final String className ) throws Exception { - assertGetClassThrowsException( className, ClassNotFoundException.class ); - } - - // Show the Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957 - // We may have to delete this if a JDK fixes the bug. - @Test - public void testShowJavaBug() throws Exception { - // Tests with Collections$UnmodifiableSet - final Set set = Collections.unmodifiableSet(new HashSet<>()); - final Method isEmptyMethod = set.getClass().getMethod("isEmpty"); - try { - isEmptyMethod.invoke(set); - fail("Failed to throw IllegalAccessException as expected"); - } catch(final IllegalAccessException iae) { - // expected - } - } - - @Test - public void testGetPublicMethod() throws Exception { - // Tests with Collections$UnmodifiableSet - final Set set = Collections.unmodifiableSet(new HashSet<>()); - final Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty"); - assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers())); - - try { - isEmptyMethod.invoke(set); - } catch(final java.lang.IllegalAccessException iae) { - fail("Should not have thrown IllegalAccessException"); - } - - // Tests with a public Class - final Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString"); - assertEquals(Object.class.getMethod("toString", new Class[0]), toStringMethod); - } - - @Test - public void testToClass_object() { -// assertNull(ClassUtils.toClass(null)); // generates warning - assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast - - // Additional varargs tests - assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass())); - final Class[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null} - assertTrue("(Object)null -> [null]", Arrays.equals(new Object[]{null}, castNull)); - - assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY)); - - assertTrue(Arrays.equals(new Class[] { String.class, Integer.class, Double.class }, - ClassUtils.toClass("Test", Integer.valueOf(1), Double.valueOf(99d)))); - - assertTrue(Arrays.equals(new Class[] { String.class, null, Double.class }, - ClassUtils.toClass("Test", null, Double.valueOf(99d)))); - } - - @Test - public void test_getShortCanonicalName_Object() { - assertEquals("", ClassUtils.getShortCanonicalName(null, "")); - assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "")); - assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "")); - assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "")); - assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "")); - assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "")); - - // Inner types - class Named {} - assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName(new Object(){}, "")); - assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName(new Named(), "")); - assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(new Inner(), "")); - } - - @Test - public void test_getShortCanonicalName_Class() { - assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class)); - assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class)); - assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class)); - assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class)); - assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class)); - - // Inner types - class Named {} - assertEquals("ClassUtilsTest.7", ClassUtils.getShortCanonicalName(new Object(){}.getClass())); - assertEquals("ClassUtilsTest.6Named", ClassUtils.getShortCanonicalName(Named.class)); - assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(Inner.class)); - } - - @Test - public void test_getShortCanonicalName_String() { - assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils")); - assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); - assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); - assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[]")); - assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); - assertEquals("int[]", ClassUtils.getShortCanonicalName("[I")); - assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I")); - assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]")); - assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]")); - - // Inner types - assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); - assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); - assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); - } - - @Test - public void test_getPackageCanonicalName_Object() { - assertEquals("", ClassUtils.getPackageCanonicalName(null, "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils(), "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "")); - assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "")); - assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "")); - - // Inner types - class Named {} - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}, "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Named(), "")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Inner(), "")); - } - - @Test - public void test_getPackageCanonicalName_Class() { - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils.class)); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[].class)); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class)); - assertEquals("", ClassUtils.getPackageCanonicalName(int[].class)); - assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class)); - - // Inner types - class Named {} - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}.getClass())); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class)); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class)); - } - - @Test - public void test_getPackageCanonicalName_String() { - assertEquals("org.apache.commons.lang3", - ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils")); - assertEquals("org.apache.commons.lang3", - ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;")); - assertEquals("org.apache.commons.lang3", - ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;")); - assertEquals("org.apache.commons.lang3", - ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[]")); - assertEquals("org.apache.commons.lang3", - ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][]")); - assertEquals("", ClassUtils.getPackageCanonicalName("[I")); - assertEquals("", ClassUtils.getPackageCanonicalName("[[I")); - assertEquals("", ClassUtils.getPackageCanonicalName("int[]")); - assertEquals("", ClassUtils.getPackageCanonicalName("int[][]")); - - // Inner types - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named")); - assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner")); - } - - @Test - public void testHierarchyIncludingInterfaces() { - final Iterator> iter = - ClassUtils.hierarchy(StringParameterizedChild.class, Interfaces.INCLUDE).iterator(); - assertEquals(StringParameterizedChild.class, iter.next()); - assertEquals(GenericParent.class, iter.next()); - assertEquals(GenericConsumer.class, iter.next()); - assertEquals(Object.class, iter.next()); - assertFalse(iter.hasNext()); - } - - @Test - public void testHierarchyExcludingInterfaces() { - final Iterator> iter = ClassUtils.hierarchy(StringParameterizedChild.class).iterator(); - assertEquals(StringParameterizedChild.class, iter.next()); - assertEquals(GenericParent.class, iter.next()); - assertEquals(Object.class, iter.next()); - assertFalse(iter.hasNext()); - } }