View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.lang3;
18  
19  import static org.apache.commons.lang3.JavaVersion.JAVA_1_5;
20  import static org.junit.Assert.assertArrayEquals;
21  import static org.junit.Assert.assertEquals;
22  import static org.junit.Assert.assertFalse;
23  import static org.junit.Assert.assertNotNull;
24  import static org.junit.Assert.assertNotSame;
25  import static org.junit.Assert.assertNull;
26  import static org.junit.Assert.assertSame;
27  import static org.junit.Assert.assertTrue;
28  import static org.junit.Assert.fail;
29  
30  import java.lang.reflect.Constructor;
31  import java.lang.reflect.Method;
32  import java.lang.reflect.Modifier;
33  import java.util.ArrayList;
34  import java.util.Arrays;
35  import java.util.Collections;
36  import java.util.HashSet;
37  import java.util.List;
38  import java.util.Map;
39  import java.util.Set;
40  
41  import org.junit.Test;
42  
43  /**
44   * Unit tests {@link org.apache.commons.lang3.ClassUtils}.
45   *
46   * @version $Id: ClassUtilsTest.java 1436770 2013-01-22 07:09:45Z ggregory $
47   */
48  @SuppressWarnings("boxing") // JUnit4 does not support primitive equality testing apart from long
49  public class ClassUtilsTest  {
50  
51      private static class Inner {
52          private class DeeplyNested{}
53      }
54  
55      //-----------------------------------------------------------------------
56      @Test
57      public void testConstructor() {
58          assertNotNull(new ClassUtils());
59          final Constructor<?>[] cons = ClassUtils.class.getDeclaredConstructors();
60          assertEquals(1, cons.length);
61          assertTrue(Modifier.isPublic(cons[0].getModifiers()));
62          assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers()));
63          assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers()));
64      }
65  
66      // -------------------------------------------------------------------------
67      @Test
68      public void test_getShortClassName_Object() {
69          assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>"));
70          assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
71          assertEquals("String", ClassUtils.getShortClassName("hello", "<null>"));
72          assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>"));
73  
74          // Inner types
75          class Named extends Object {}
76          assertEquals("ClassUtilsTest.1", ClassUtils.getShortClassName(new Object(){}, "<null>"));
77          assertEquals("ClassUtilsTest.1Named", ClassUtils.getShortClassName(new Named(), "<null>"));
78          assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
79      }
80  
81      @Test
82      public void test_getShortClassName_Class() {
83          assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class));
84          assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class));
85          assertEquals("", ClassUtils.getShortClassName((Class<?>) null));
86  
87          // LANG-535
88          assertEquals("String[]", ClassUtils.getShortClassName(String[].class));
89          assertEquals("Map.Entry[]", ClassUtils.getShortClassName(Map.Entry[].class));
90  
91          // Primitives
92          assertEquals("boolean", ClassUtils.getShortClassName(boolean.class));
93          assertEquals("byte", ClassUtils.getShortClassName(byte.class));
94          assertEquals("char", ClassUtils.getShortClassName(char.class));
95          assertEquals("short", ClassUtils.getShortClassName(short.class));
96          assertEquals("int", ClassUtils.getShortClassName(int.class));
97          assertEquals("long", ClassUtils.getShortClassName(long.class));
98          assertEquals("float", ClassUtils.getShortClassName(float.class));
99          assertEquals("double", ClassUtils.getShortClassName(double.class));
100 
101         // Primitive Arrays
102         assertEquals("boolean[]", ClassUtils.getShortClassName(boolean[].class));
103         assertEquals("byte[]", ClassUtils.getShortClassName(byte[].class));
104         assertEquals("char[]", ClassUtils.getShortClassName(char[].class));
105         assertEquals("short[]", ClassUtils.getShortClassName(short[].class));
106         assertEquals("int[]", ClassUtils.getShortClassName(int[].class));
107         assertEquals("long[]", ClassUtils.getShortClassName(long[].class));
108         assertEquals("float[]", ClassUtils.getShortClassName(float[].class));
109         assertEquals("double[]", ClassUtils.getShortClassName(double[].class));
110 
111         // Arrays of arrays of ...
112         assertEquals("String[][]", ClassUtils.getShortClassName(String[][].class));
113         assertEquals("String[][][]", ClassUtils.getShortClassName(String[][][].class));
114         assertEquals("String[][][][]", ClassUtils.getShortClassName(String[][][][].class));
115         
116         // Inner types
117         class Named extends Object {}
118         assertEquals("ClassUtilsTest.2", ClassUtils.getShortClassName(new Object(){}.getClass()));
119         assertEquals("ClassUtilsTest.2Named", ClassUtils.getShortClassName(Named.class));
120         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(Inner.class));
121     }
122 
123 
124 
125     @Test
126     public void test_getShortClassName_String() {
127         assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName()));
128         assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName()));
129         assertEquals("", ClassUtils.getShortClassName((String) null));
130         assertEquals("", ClassUtils.getShortClassName(""));
131     }
132 
133     @Test
134     public void test_getSimpleName_Class() {
135         assertEquals("ClassUtils", ClassUtils.getSimpleName(ClassUtils.class));
136         assertEquals("Entry", ClassUtils.getSimpleName(Map.Entry.class));
137         assertEquals("", ClassUtils.getSimpleName((Class<?>) null));
138 
139         // LANG-535
140         assertEquals("String[]", ClassUtils.getSimpleName(String[].class));
141         assertEquals("Entry[]", ClassUtils.getSimpleName(Map.Entry[].class));
142 
143         // Primitives
144         assertEquals("boolean", ClassUtils.getSimpleName(boolean.class));
145         assertEquals("byte", ClassUtils.getSimpleName(byte.class));
146         assertEquals("char", ClassUtils.getSimpleName(char.class));
147         assertEquals("short", ClassUtils.getSimpleName(short.class));
148         assertEquals("int", ClassUtils.getSimpleName(int.class));
149         assertEquals("long", ClassUtils.getSimpleName(long.class));
150         assertEquals("float", ClassUtils.getSimpleName(float.class));
151         assertEquals("double", ClassUtils.getSimpleName(double.class));
152 
153         // Primitive Arrays
154         assertEquals("boolean[]", ClassUtils.getSimpleName(boolean[].class));
155         assertEquals("byte[]", ClassUtils.getSimpleName(byte[].class));
156         assertEquals("char[]", ClassUtils.getSimpleName(char[].class));
157         assertEquals("short[]", ClassUtils.getSimpleName(short[].class));
158         assertEquals("int[]", ClassUtils.getSimpleName(int[].class));
159         assertEquals("long[]", ClassUtils.getSimpleName(long[].class));
160         assertEquals("float[]", ClassUtils.getSimpleName(float[].class));
161         assertEquals("double[]", ClassUtils.getSimpleName(double[].class));
162 
163         // Arrays of arrays of ...
164         assertEquals("String[][]", ClassUtils.getSimpleName(String[][].class));
165         assertEquals("String[][][]", ClassUtils.getSimpleName(String[][][].class));
166         assertEquals("String[][][][]", ClassUtils.getSimpleName(String[][][][].class));
167         
168         // On-the-fly types
169         class Named extends Object {}
170         assertEquals("", ClassUtils.getSimpleName(new Object(){}.getClass()));
171         assertEquals("Named", ClassUtils.getSimpleName(Named.class));
172     }
173 
174     @Test
175     public void test_getSimpleName_Object() {
176         assertEquals("ClassUtils", ClassUtils.getSimpleName(new ClassUtils(), "<null>"));
177         assertEquals("Inner", ClassUtils.getSimpleName(new Inner(), "<null>"));
178         assertEquals("String", ClassUtils.getSimpleName("hello", "<null>"));
179         assertEquals("<null>", ClassUtils.getSimpleName(null, "<null>"));
180     }
181 
182     // -------------------------------------------------------------------------
183     @Test
184     public void test_getPackageName_Object() {
185         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new ClassUtils(), "<null>"));
186         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Inner(), "<null>"));
187         assertEquals("<null>", ClassUtils.getPackageName(null, "<null>"));
188     }
189 
190     @Test
191     public void test_getPackageName_Class() {
192         assertEquals("java.lang", ClassUtils.getPackageName(String.class));
193         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class));
194         assertEquals("", ClassUtils.getPackageName((Class<?>)null));
195 
196         // LANG-535
197         assertEquals("java.lang", ClassUtils.getPackageName(String[].class));
198 
199         // Primitive Arrays
200         assertEquals("", ClassUtils.getPackageName(boolean[].class));
201         assertEquals("", ClassUtils.getPackageName(byte[].class));
202         assertEquals("", ClassUtils.getPackageName(char[].class));
203         assertEquals("", ClassUtils.getPackageName(short[].class));
204         assertEquals("", ClassUtils.getPackageName(int[].class));
205         assertEquals("", ClassUtils.getPackageName(long[].class));
206         assertEquals("", ClassUtils.getPackageName(float[].class));
207         assertEquals("", ClassUtils.getPackageName(double[].class));
208 
209         // Arrays of arrays of ...
210         assertEquals("java.lang", ClassUtils.getPackageName(String[][].class));
211         assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class));
212         assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class));
213         
214         // On-the-fly types
215         class Named extends Object {}
216         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object(){}.getClass()));
217         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(Named.class));
218     }
219 
220     @Test
221     public void test_getPackageName_String() {
222         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(ClassUtils.class.getName()));
223         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName()));
224         assertEquals("", ClassUtils.getPackageName((String)null));
225         assertEquals("", ClassUtils.getPackageName(""));
226     }
227 
228     // -------------------------------------------------------------------------
229     @Test
230     public void test_getAllSuperclasses_Class() {
231         final List<?> list = ClassUtils.getAllSuperclasses(CY.class);
232         assertEquals(2, list.size());
233         assertEquals(CX.class, list.get(0));
234         assertEquals(Object.class, list.get(1));
235 
236         assertEquals(null, ClassUtils.getAllSuperclasses(null));
237     }
238 
239     @Test
240     public void test_getAllInterfaces_Class() {
241         final List<?> list = ClassUtils.getAllInterfaces(CY.class);
242         assertEquals(6, list.size());
243         assertEquals(IB.class, list.get(0));
244         assertEquals(IC.class, list.get(1));
245         assertEquals(ID.class, list.get(2));
246         assertEquals(IE.class, list.get(3));
247         assertEquals(IF.class, list.get(4));
248         assertEquals(IA.class, list.get(5));
249 
250         assertEquals(null, ClassUtils.getAllInterfaces(null));
251     }
252 
253     private static interface IA {
254     }
255     private static interface IB {
256     }
257     private static interface IC extends ID, IE {
258     }
259     private static interface ID {
260     }
261     private static interface IE extends IF {
262     }
263     private static interface IF {
264     }
265     private static class CX implements IB, IA, IE {
266     }
267     private static class CY extends CX implements IB, IC {
268     }
269 
270     // -------------------------------------------------------------------------
271     @Test
272     public void test_convertClassNamesToClasses_List() {
273         final List<String> list = new ArrayList<String>();
274         List<Class<?>> result = ClassUtils.convertClassNamesToClasses(list);
275         assertEquals(0, result.size());
276 
277         list.add("java.lang.String");
278         list.add("java.lang.xxx");
279         list.add("java.lang.Object");
280         result = ClassUtils.convertClassNamesToClasses(list);
281         assertEquals(3, result.size());
282         assertEquals(String.class, result.get(0));
283         assertEquals(null, result.get(1));
284         assertEquals(Object.class, result.get(2));
285 
286         @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element
287         final
288         List<Object> olist = (List<Object>)(List<?>)list;
289         olist.add(new Object());
290         try {
291             ClassUtils.convertClassNamesToClasses(list);
292             fail("Should not have been able to convert list");
293         } catch (final ClassCastException expected) {}
294         assertEquals(null, ClassUtils.convertClassNamesToClasses(null));
295     }
296 
297     @Test
298     public void test_convertClassesToClassNames_List() {
299         final List<Class<?>> list = new ArrayList<Class<?>>();
300         List<String> result = ClassUtils.convertClassesToClassNames(list);
301         assertEquals(0, result.size());
302 
303         list.add(String.class);
304         list.add(null);
305         list.add(Object.class);
306         result = ClassUtils.convertClassesToClassNames(list);
307         assertEquals(3, result.size());
308         assertEquals("java.lang.String", result.get(0));
309         assertEquals(null, result.get(1));
310         assertEquals("java.lang.Object", result.get(2));
311 
312         @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element
313         final
314         List<Object> olist = (List<Object>)(List<?>)list;
315         olist.add(new Object());
316         try {
317             ClassUtils.convertClassesToClassNames(list);
318             fail("Should not have been able to convert list");
319         } catch (final ClassCastException expected) {}
320         assertEquals(null, ClassUtils.convertClassesToClassNames(null));
321     }
322 
323     // -------------------------------------------------------------------------
324     @Test
325     public void test_isInnerClass_Class() {
326         assertTrue(ClassUtils.isInnerClass(Inner.class));
327         assertTrue(ClassUtils.isInnerClass(Map.Entry.class));
328         assertTrue(ClassUtils.isInnerClass(new Cloneable() {
329         }.getClass()));
330         assertFalse(ClassUtils.isInnerClass(this.getClass()));
331         assertFalse(ClassUtils.isInnerClass(String.class));
332         assertFalse(ClassUtils.isInnerClass(null));
333     }
334 
335     // -------------------------------------------------------------------------
336     @Test
337     public void test_isAssignable_ClassArray_ClassArray() throws Exception {
338         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
339         final Class<?>[] array1 = new Class[] {Object.class};
340         final Class<?>[] array1s = new Class[] {String.class};
341         final Class<?>[] array0 = new Class[] {};
342         final Class<?>[] arrayPrimitives = { Integer.TYPE, Boolean.TYPE };
343         final Class<?>[] arrayWrappers = { Integer.class, Boolean.class };
344 
345         assertFalse(ClassUtils.isAssignable(array1, array2));
346         assertFalse(ClassUtils.isAssignable(null, array2));
347         assertTrue(ClassUtils.isAssignable(null, array0));
348         assertTrue(ClassUtils.isAssignable(array0, array0));
349 //        assertTrue(ClassUtils.isAssignable(array0, null)); 
350         assertTrue(ClassUtils.isAssignable(array0, (Class<?>[]) null)); // explicit cast to avoid warning
351         assertTrue(ClassUtils.isAssignable((Class[]) null, (Class[]) null));
352 
353         assertFalse(ClassUtils.isAssignable(array1, array1s));
354         assertTrue(ClassUtils.isAssignable(array1s, array1s));
355         assertTrue(ClassUtils.isAssignable(array1s, array1));
356 
357         final boolean autoboxing = SystemUtils.isJavaVersionAtLeast(JAVA_1_5);
358 
359         assertEquals(autoboxing, ClassUtils.isAssignable(arrayPrimitives, arrayWrappers));
360         assertEquals(autoboxing, ClassUtils.isAssignable(arrayWrappers, arrayPrimitives));
361         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1));
362         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1));
363         assertEquals(autoboxing, ClassUtils.isAssignable(arrayPrimitives, array2));
364         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2));
365     }
366 
367     @Test
368     public void test_isAssignable_ClassArray_ClassArray_Autoboxing() throws Exception {
369         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
370         final Class<?>[] array1 = new Class[] {Object.class};
371         final Class<?>[] array1s = new Class[] {String.class};
372         final Class<?>[] array0 = new Class[] {};
373         final Class<?>[] arrayPrimitives = { Integer.TYPE, Boolean.TYPE };
374         final Class<?>[] arrayWrappers = { Integer.class, Boolean.class };
375 
376         assertFalse(ClassUtils.isAssignable(array1, array2, true));
377         assertFalse(ClassUtils.isAssignable(null, array2, true));
378         assertTrue(ClassUtils.isAssignable(null, array0, true));
379         assertTrue(ClassUtils.isAssignable(array0, array0, true));
380         assertTrue(ClassUtils.isAssignable(array0, null, true));
381         assertTrue(ClassUtils.isAssignable((Class[]) null, (Class[]) null, true));
382 
383         assertFalse(ClassUtils.isAssignable(array1, array1s, true));
384         assertTrue(ClassUtils.isAssignable(array1s, array1s, true));
385         assertTrue(ClassUtils.isAssignable(array1s, array1, true));
386 
387         assertTrue(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, true));
388         assertTrue(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, true));
389         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, true));
390         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, true));
391         assertTrue(ClassUtils.isAssignable(arrayPrimitives, array2, true));
392         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, true));
393     }
394 
395     @Test
396     public void test_isAssignable_ClassArray_ClassArray_NoAutoboxing() throws Exception {
397         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
398         final Class<?>[] array1 = new Class[] {Object.class};
399         final Class<?>[] array1s = new Class[] {String.class};
400         final Class<?>[] array0 = new Class[] {};
401         final Class<?>[] arrayPrimitives = { Integer.TYPE, Boolean.TYPE };
402         final Class<?>[] arrayWrappers = { Integer.class, Boolean.class };
403 
404         assertFalse(ClassUtils.isAssignable(array1, array2, false));
405         assertFalse(ClassUtils.isAssignable(null, array2, false));
406         assertTrue(ClassUtils.isAssignable(null, array0, false));
407         assertTrue(ClassUtils.isAssignable(array0, array0, false));
408         assertTrue(ClassUtils.isAssignable(array0, null, false));
409         assertTrue(ClassUtils.isAssignable((Class[]) null, (Class[]) null, false));
410 
411         assertFalse(ClassUtils.isAssignable(array1, array1s, false));
412         assertTrue(ClassUtils.isAssignable(array1s, array1s, false));
413         assertTrue(ClassUtils.isAssignable(array1s, array1, false));
414 
415         assertFalse(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, false));
416         assertFalse(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, false));
417         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, false));
418         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, false));
419         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, false));
420         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array2, false));
421     }
422 
423     @Test
424     public void test_isAssignable() throws Exception {
425         assertFalse(ClassUtils.isAssignable((Class<?>) null, null));
426         assertFalse(ClassUtils.isAssignable(String.class, null));
427 
428         assertTrue(ClassUtils.isAssignable(null, Object.class));
429         assertTrue(ClassUtils.isAssignable(null, Integer.class));
430         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE));
431         assertTrue(ClassUtils.isAssignable(String.class, Object.class));
432         assertTrue(ClassUtils.isAssignable(String.class, String.class));
433         assertFalse(ClassUtils.isAssignable(Object.class, String.class));
434 
435         final boolean autoboxing = SystemUtils.isJavaVersionAtLeast(JAVA_1_5);
436 
437         assertEquals(autoboxing, ClassUtils.isAssignable(Integer.TYPE, Integer.class));
438         assertEquals(autoboxing, ClassUtils.isAssignable(Integer.TYPE, Object.class));
439         assertEquals(autoboxing, ClassUtils.isAssignable(Integer.class, Integer.TYPE));
440         assertEquals(autoboxing, ClassUtils.isAssignable(Integer.class, Object.class));
441         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
442         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class));
443         assertEquals(autoboxing, ClassUtils.isAssignable(Boolean.TYPE, Boolean.class));
444         assertEquals(autoboxing, ClassUtils.isAssignable(Boolean.TYPE, Object.class));
445         assertEquals(autoboxing, ClassUtils.isAssignable(Boolean.class, Boolean.TYPE));
446         assertEquals(autoboxing, ClassUtils.isAssignable(Boolean.class, Object.class));
447         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE));
448         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class));
449     }
450 
451     @Test
452     public void test_isAssignable_Autoboxing() throws Exception {
453         assertFalse(ClassUtils.isAssignable((Class<?>) null, null, true));
454         assertFalse(ClassUtils.isAssignable(String.class, null, true));
455 
456         assertTrue(ClassUtils.isAssignable(null, Object.class, true));
457         assertTrue(ClassUtils.isAssignable(null, Integer.class, true));
458         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, true));
459         assertTrue(ClassUtils.isAssignable(String.class, Object.class, true));
460         assertTrue(ClassUtils.isAssignable(String.class, String.class, true));
461         assertFalse(ClassUtils.isAssignable(Object.class, String.class, true));
462         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class, true));
463         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class, true));
464         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true));
465         assertTrue(ClassUtils.isAssignable(Integer.class, Object.class, true));
466         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, true));
467         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, true));
468         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, true));
469         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true));
470         assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, true));
471         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, true));
472         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, true));
473     }
474 
475     @Test
476     public void test_isAssignable_NoAutoboxing() throws Exception {
477         assertFalse(ClassUtils.isAssignable((Class<?>) null, null, false));
478         assertFalse(ClassUtils.isAssignable(String.class, null, false));
479 
480         assertTrue(ClassUtils.isAssignable(null, Object.class, false));
481         assertTrue(ClassUtils.isAssignable(null, Integer.class, false));
482         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, false));
483         assertTrue(ClassUtils.isAssignable(String.class, Object.class, false));
484         assertTrue(ClassUtils.isAssignable(String.class, String.class, false));
485         assertFalse(ClassUtils.isAssignable(Object.class, String.class, false));
486         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Integer.class, false));
487         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Object.class, false));
488         assertFalse(ClassUtils.isAssignable(Integer.class, Integer.TYPE, false));
489         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, false));
490         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, false));
491         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, false));
492         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Object.class, false));
493         assertFalse(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, false));
494         assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, false));
495         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, false));
496         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, false));
497     }
498 
499     @Test
500     public void test_isAssignable_Widening() throws Exception {
501         // test byte conversions
502         assertFalse("byte -> char", ClassUtils.isAssignable(Byte.TYPE, Character.TYPE));
503         assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE));
504         assertTrue("byte -> short", ClassUtils.isAssignable(Byte.TYPE, Short.TYPE));
505         assertTrue("byte -> int", ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE));
506         assertTrue("byte -> long", ClassUtils.isAssignable(Byte.TYPE, Long.TYPE));
507         assertTrue("byte -> float", ClassUtils.isAssignable(Byte.TYPE, Float.TYPE));
508         assertTrue("byte -> double", ClassUtils.isAssignable(Byte.TYPE, Double.TYPE));
509         assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE));
510 
511         // test short conversions
512         assertFalse("short -> char", ClassUtils.isAssignable(Short.TYPE, Character.TYPE));
513         assertFalse("short -> byte", ClassUtils.isAssignable(Short.TYPE, Byte.TYPE));
514         assertTrue("short -> short", ClassUtils.isAssignable(Short.TYPE, Short.TYPE));
515         assertTrue("short -> int", ClassUtils.isAssignable(Short.TYPE, Integer.TYPE));
516         assertTrue("short -> long", ClassUtils.isAssignable(Short.TYPE, Long.TYPE));
517         assertTrue("short -> float", ClassUtils.isAssignable(Short.TYPE, Float.TYPE));
518         assertTrue("short -> double", ClassUtils.isAssignable(Short.TYPE, Double.TYPE));
519         assertFalse("short -> boolean", ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE));
520 
521         // test char conversions
522         assertTrue("char -> char", ClassUtils.isAssignable(Character.TYPE, Character.TYPE));
523         assertFalse("char -> byte", ClassUtils.isAssignable(Character.TYPE, Byte.TYPE));
524         assertFalse("char -> short", ClassUtils.isAssignable(Character.TYPE, Short.TYPE));
525         assertTrue("char -> int", ClassUtils.isAssignable(Character.TYPE, Integer.TYPE));
526         assertTrue("char -> long", ClassUtils.isAssignable(Character.TYPE, Long.TYPE));
527         assertTrue("char -> float", ClassUtils.isAssignable(Character.TYPE, Float.TYPE));
528         assertTrue("char -> double", ClassUtils.isAssignable(Character.TYPE, Double.TYPE));
529         assertFalse("char -> boolean", ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE));
530 
531         // test int conversions
532         assertFalse("int -> char", ClassUtils.isAssignable(Integer.TYPE, Character.TYPE));
533         assertFalse("int -> byte", ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE));
534         assertFalse("int -> short", ClassUtils.isAssignable(Integer.TYPE, Short.TYPE));
535         assertTrue("int -> int", ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
536         assertTrue("int -> long", ClassUtils.isAssignable(Integer.TYPE, Long.TYPE));
537         assertTrue("int -> float", ClassUtils.isAssignable(Integer.TYPE, Float.TYPE));
538         assertTrue("int -> double", ClassUtils.isAssignable(Integer.TYPE, Double.TYPE));
539         assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE));
540 
541         // test long conversions
542         assertFalse("long -> char", ClassUtils.isAssignable(Long.TYPE, Character.TYPE));
543         assertFalse("long -> byte", ClassUtils.isAssignable(Long.TYPE, Byte.TYPE));
544         assertFalse("long -> short", ClassUtils.isAssignable(Long.TYPE, Short.TYPE));
545         assertFalse("long -> int", ClassUtils.isAssignable(Long.TYPE, Integer.TYPE));
546         assertTrue("long -> long", ClassUtils.isAssignable(Long.TYPE, Long.TYPE));
547         assertTrue("long -> float", ClassUtils.isAssignable(Long.TYPE, Float.TYPE));
548         assertTrue("long -> double", ClassUtils.isAssignable(Long.TYPE, Double.TYPE));
549         assertFalse("long -> boolean", ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE));
550 
551         // test float conversions
552         assertFalse("float -> char", ClassUtils.isAssignable(Float.TYPE, Character.TYPE));
553         assertFalse("float -> byte", ClassUtils.isAssignable(Float.TYPE, Byte.TYPE));
554         assertFalse("float -> short", ClassUtils.isAssignable(Float.TYPE, Short.TYPE));
555         assertFalse("float -> int", ClassUtils.isAssignable(Float.TYPE, Integer.TYPE));
556         assertFalse("float -> long", ClassUtils.isAssignable(Float.TYPE, Long.TYPE));
557         assertTrue("float -> float", ClassUtils.isAssignable(Float.TYPE, Float.TYPE));
558         assertTrue("float -> double", ClassUtils.isAssignable(Float.TYPE, Double.TYPE));
559         assertFalse("float -> boolean", ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE));
560 
561         // test double conversions
562         assertFalse("double -> char", ClassUtils.isAssignable(Double.TYPE, Character.TYPE));
563         assertFalse("double -> byte", ClassUtils.isAssignable(Double.TYPE, Byte.TYPE));
564         assertFalse("double -> short", ClassUtils.isAssignable(Double.TYPE, Short.TYPE));
565         assertFalse("double -> int", ClassUtils.isAssignable(Double.TYPE, Integer.TYPE));
566         assertFalse("double -> long", ClassUtils.isAssignable(Double.TYPE, Long.TYPE));
567         assertFalse("double -> float", ClassUtils.isAssignable(Double.TYPE, Float.TYPE));
568         assertTrue("double -> double", ClassUtils.isAssignable(Double.TYPE, Double.TYPE));
569         assertFalse("double -> boolean", ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE));
570 
571         // test boolean conversions
572         assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE));
573         assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE));
574         assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE));
575         assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE));
576         assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE));
577         assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE));
578         assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE));
579         assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE));
580     }
581 
582     @Test
583     public void test_isAssignable_DefaultUnboxing_Widening() throws Exception {
584         final boolean autoboxing = SystemUtils.isJavaVersionAtLeast(JAVA_1_5);
585 
586         // test byte conversions
587         assertFalse("byte -> char", ClassUtils.isAssignable(Byte.class, Character.TYPE));
588         assertEquals("byte -> byte", autoboxing, ClassUtils.isAssignable(Byte.class, Byte.TYPE));
589         assertEquals("byte -> short", autoboxing, ClassUtils.isAssignable(Byte.class, Short.TYPE));
590         assertEquals("byte -> int", autoboxing, ClassUtils.isAssignable(Byte.class, Integer.TYPE));
591         assertEquals("byte -> long", autoboxing, ClassUtils.isAssignable(Byte.class, Long.TYPE));
592         assertEquals("byte -> float", autoboxing, ClassUtils.isAssignable(Byte.class, Float.TYPE));
593         assertEquals("byte -> double", autoboxing, ClassUtils.isAssignable(Byte.class, Double.TYPE));
594         assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.class, Boolean.TYPE));
595 
596         // test short conversions
597         assertFalse("short -> char", ClassUtils.isAssignable(Short.class, Character.TYPE));
598         assertFalse("short -> byte", ClassUtils.isAssignable(Short.class, Byte.TYPE));
599         assertEquals("short -> short", autoboxing, ClassUtils.isAssignable(Short.class, Short.TYPE));
600         assertEquals("short -> int", autoboxing, ClassUtils.isAssignable(Short.class, Integer.TYPE));
601         assertEquals("short -> long", autoboxing, ClassUtils.isAssignable(Short.class, Long.TYPE));
602         assertEquals("short -> float", autoboxing, ClassUtils.isAssignable(Short.class, Float.TYPE));
603         assertEquals("short -> double", autoboxing, ClassUtils.isAssignable(Short.class, Double.TYPE));
604         assertFalse("short -> boolean", ClassUtils.isAssignable(Short.class, Boolean.TYPE));
605 
606         // test char conversions
607         assertEquals("char -> char", autoboxing, ClassUtils.isAssignable(Character.class, Character.TYPE));
608         assertFalse("char -> byte", ClassUtils.isAssignable(Character.class, Byte.TYPE));
609         assertFalse("char -> short", ClassUtils.isAssignable(Character.class, Short.TYPE));
610         assertEquals("char -> int", autoboxing, ClassUtils.isAssignable(Character.class, Integer.TYPE));
611         assertEquals("char -> long", autoboxing, ClassUtils.isAssignable(Character.class, Long.TYPE));
612         assertEquals("char -> float", autoboxing, ClassUtils.isAssignable(Character.class, Float.TYPE));
613         assertEquals("char -> double", autoboxing, ClassUtils.isAssignable(Character.class, Double.TYPE));
614         assertFalse("char -> boolean", ClassUtils.isAssignable(Character.class, Boolean.TYPE));
615 
616         // test int conversions
617         assertFalse("int -> char", ClassUtils.isAssignable(Integer.class, Character.TYPE));
618         assertFalse("int -> byte", ClassUtils.isAssignable(Integer.class, Byte.TYPE));
619         assertFalse("int -> short", ClassUtils.isAssignable(Integer.class, Short.TYPE));
620         assertEquals("int -> int", autoboxing, ClassUtils.isAssignable(Integer.class, Integer.TYPE));
621         assertEquals("int -> long", autoboxing, ClassUtils.isAssignable(Integer.class, Long.TYPE));
622         assertEquals("int -> float", autoboxing, ClassUtils.isAssignable(Integer.class, Float.TYPE));
623         assertEquals("int -> double", autoboxing, ClassUtils.isAssignable(Integer.class, Double.TYPE));
624         assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.class, Boolean.TYPE));
625 
626         // test long conversions
627         assertFalse("long -> char", ClassUtils.isAssignable(Long.class, Character.TYPE));
628         assertFalse("long -> byte", ClassUtils.isAssignable(Long.class, Byte.TYPE));
629         assertFalse("long -> short", ClassUtils.isAssignable(Long.class, Short.TYPE));
630         assertFalse("long -> int", ClassUtils.isAssignable(Long.class, Integer.TYPE));
631         assertEquals("long -> long", autoboxing, ClassUtils.isAssignable(Long.class, Long.TYPE));
632         assertEquals("long -> float", autoboxing, ClassUtils.isAssignable(Long.class, Float.TYPE));
633         assertEquals("long -> double", autoboxing, ClassUtils.isAssignable(Long.class, Double.TYPE));
634         assertFalse("long -> boolean", ClassUtils.isAssignable(Long.class, Boolean.TYPE));
635 
636         // test float conversions
637         assertFalse("float -> char", ClassUtils.isAssignable(Float.class, Character.TYPE));
638         assertFalse("float -> byte", ClassUtils.isAssignable(Float.class, Byte.TYPE));
639         assertFalse("float -> short", ClassUtils.isAssignable(Float.class, Short.TYPE));
640         assertFalse("float -> int", ClassUtils.isAssignable(Float.class, Integer.TYPE));
641         assertFalse("float -> long", ClassUtils.isAssignable(Float.class, Long.TYPE));
642         assertEquals("float -> float", autoboxing, ClassUtils.isAssignable(Float.class, Float.TYPE));
643         assertEquals("float -> double", autoboxing, ClassUtils.isAssignable(Float.class, Double.TYPE));
644         assertFalse("float -> boolean", ClassUtils.isAssignable(Float.class, Boolean.TYPE));
645 
646         // test double conversions
647         assertFalse("double -> char", ClassUtils.isAssignable(Double.class, Character.TYPE));
648         assertFalse("double -> byte", ClassUtils.isAssignable(Double.class, Byte.TYPE));
649         assertFalse("double -> short", ClassUtils.isAssignable(Double.class, Short.TYPE));
650         assertFalse("double -> int", ClassUtils.isAssignable(Double.class, Integer.TYPE));
651         assertFalse("double -> long", ClassUtils.isAssignable(Double.class, Long.TYPE));
652         assertFalse("double -> float", ClassUtils.isAssignable(Double.class, Float.TYPE));
653         assertEquals("double -> double", autoboxing, ClassUtils.isAssignable(Double.class, Double.TYPE));
654         assertFalse("double -> boolean", ClassUtils.isAssignable(Double.class, Boolean.TYPE));
655 
656         // test boolean conversions
657         assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.class, Character.TYPE));
658         assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.class, Byte.TYPE));
659         assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.class, Short.TYPE));
660         assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.class, Integer.TYPE));
661         assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.class, Long.TYPE));
662         assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.class, Float.TYPE));
663         assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.class, Double.TYPE));
664         assertEquals("boolean -> boolean", autoboxing, ClassUtils.isAssignable(Boolean.class, Boolean.TYPE));
665     }
666 
667     @Test
668     public void test_isAssignable_Unboxing_Widening() throws Exception {
669         // test byte conversions
670         assertFalse("byte -> char", ClassUtils.isAssignable(Byte.class, Character.TYPE, true));
671         assertTrue("byte -> byte", ClassUtils.isAssignable(Byte.class, Byte.TYPE, true));
672         assertTrue("byte -> short", ClassUtils.isAssignable(Byte.class, Short.TYPE, true));
673         assertTrue("byte -> int", ClassUtils.isAssignable(Byte.class, Integer.TYPE, true));
674         assertTrue("byte -> long", ClassUtils.isAssignable(Byte.class, Long.TYPE, true));
675         assertTrue("byte -> float", ClassUtils.isAssignable(Byte.class, Float.TYPE, true));
676         assertTrue("byte -> double", ClassUtils.isAssignable(Byte.class, Double.TYPE, true));
677         assertFalse("byte -> boolean", ClassUtils.isAssignable(Byte.class, Boolean.TYPE, true));
678 
679         // test short conversions
680         assertFalse("short -> char", ClassUtils.isAssignable(Short.class, Character.TYPE, true));
681         assertFalse("short -> byte", ClassUtils.isAssignable(Short.class, Byte.TYPE, true));
682         assertTrue("short -> short", ClassUtils.isAssignable(Short.class, Short.TYPE, true));
683         assertTrue("short -> int", ClassUtils.isAssignable(Short.class, Integer.TYPE, true));
684         assertTrue("short -> long", ClassUtils.isAssignable(Short.class, Long.TYPE, true));
685         assertTrue("short -> float", ClassUtils.isAssignable(Short.class, Float.TYPE, true));
686         assertTrue("short -> double", ClassUtils.isAssignable(Short.class, Double.TYPE, true));
687         assertFalse("short -> boolean", ClassUtils.isAssignable(Short.class, Boolean.TYPE, true));
688 
689         // test char conversions
690         assertTrue("char -> char", ClassUtils.isAssignable(Character.class, Character.TYPE, true));
691         assertFalse("char -> byte", ClassUtils.isAssignable(Character.class, Byte.TYPE, true));
692         assertFalse("char -> short", ClassUtils.isAssignable(Character.class, Short.TYPE, true));
693         assertTrue("char -> int", ClassUtils.isAssignable(Character.class, Integer.TYPE, true));
694         assertTrue("char -> long", ClassUtils.isAssignable(Character.class, Long.TYPE, true));
695         assertTrue("char -> float", ClassUtils.isAssignable(Character.class, Float.TYPE, true));
696         assertTrue("char -> double", ClassUtils.isAssignable(Character.class, Double.TYPE, true));
697         assertFalse("char -> boolean", ClassUtils.isAssignable(Character.class, Boolean.TYPE, true));
698 
699         // test int conversions
700         assertFalse("int -> char", ClassUtils.isAssignable(Integer.class, Character.TYPE, true));
701         assertFalse("int -> byte", ClassUtils.isAssignable(Integer.class, Byte.TYPE, true));
702         assertFalse("int -> short", ClassUtils.isAssignable(Integer.class, Short.TYPE, true));
703         assertTrue("int -> int", ClassUtils.isAssignable(Integer.class, Integer.TYPE, true));
704         assertTrue("int -> long", ClassUtils.isAssignable(Integer.class, Long.TYPE, true));
705         assertTrue("int -> float", ClassUtils.isAssignable(Integer.class, Float.TYPE, true));
706         assertTrue("int -> double", ClassUtils.isAssignable(Integer.class, Double.TYPE, true));
707         assertFalse("int -> boolean", ClassUtils.isAssignable(Integer.class, Boolean.TYPE, true));
708 
709         // test long conversions
710         assertFalse("long -> char", ClassUtils.isAssignable(Long.class, Character.TYPE, true));
711         assertFalse("long -> byte", ClassUtils.isAssignable(Long.class, Byte.TYPE, true));
712         assertFalse("long -> short", ClassUtils.isAssignable(Long.class, Short.TYPE, true));
713         assertFalse("long -> int", ClassUtils.isAssignable(Long.class, Integer.TYPE, true));
714         assertTrue("long -> long", ClassUtils.isAssignable(Long.class, Long.TYPE, true));
715         assertTrue("long -> float", ClassUtils.isAssignable(Long.class, Float.TYPE, true));
716         assertTrue("long -> double", ClassUtils.isAssignable(Long.class, Double.TYPE, true));
717         assertFalse("long -> boolean", ClassUtils.isAssignable(Long.class, Boolean.TYPE, true));
718 
719         // test float conversions
720         assertFalse("float -> char", ClassUtils.isAssignable(Float.class, Character.TYPE, true));
721         assertFalse("float -> byte", ClassUtils.isAssignable(Float.class, Byte.TYPE, true));
722         assertFalse("float -> short", ClassUtils.isAssignable(Float.class, Short.TYPE, true));
723         assertFalse("float -> int", ClassUtils.isAssignable(Float.class, Integer.TYPE, true));
724         assertFalse("float -> long", ClassUtils.isAssignable(Float.class, Long.TYPE, true));
725         assertTrue("float -> float", ClassUtils.isAssignable(Float.class, Float.TYPE, true));
726         assertTrue("float -> double", ClassUtils.isAssignable(Float.class, Double.TYPE, true));
727         assertFalse("float -> boolean", ClassUtils.isAssignable(Float.class, Boolean.TYPE, true));
728 
729         // test double conversions
730         assertFalse("double -> char", ClassUtils.isAssignable(Double.class, Character.TYPE, true));
731         assertFalse("double -> byte", ClassUtils.isAssignable(Double.class, Byte.TYPE, true));
732         assertFalse("double -> short", ClassUtils.isAssignable(Double.class, Short.TYPE, true));
733         assertFalse("double -> int", ClassUtils.isAssignable(Double.class, Integer.TYPE, true));
734         assertFalse("double -> long", ClassUtils.isAssignable(Double.class, Long.TYPE, true));
735         assertFalse("double -> float", ClassUtils.isAssignable(Double.class, Float.TYPE, true));
736         assertTrue("double -> double", ClassUtils.isAssignable(Double.class, Double.TYPE, true));
737         assertFalse("double -> boolean", ClassUtils.isAssignable(Double.class, Boolean.TYPE, true));
738 
739         // test boolean conversions
740         assertFalse("boolean -> char", ClassUtils.isAssignable(Boolean.class, Character.TYPE, true));
741         assertFalse("boolean -> byte", ClassUtils.isAssignable(Boolean.class, Byte.TYPE, true));
742         assertFalse("boolean -> short", ClassUtils.isAssignable(Boolean.class, Short.TYPE, true));
743         assertFalse("boolean -> int", ClassUtils.isAssignable(Boolean.class, Integer.TYPE, true));
744         assertFalse("boolean -> long", ClassUtils.isAssignable(Boolean.class, Long.TYPE, true));
745         assertFalse("boolean -> float", ClassUtils.isAssignable(Boolean.class, Float.TYPE, true));
746         assertFalse("boolean -> double", ClassUtils.isAssignable(Boolean.class, Double.TYPE, true));
747         assertTrue("boolean -> boolean", ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true));
748     }
749 
750     @Test
751     public void testIsPrimitiveOrWrapper() {
752 
753         // test primitive wrapper classes
754         assertTrue("Boolean.class", ClassUtils.isPrimitiveOrWrapper(Boolean.class));
755         assertTrue("Byte.class", ClassUtils.isPrimitiveOrWrapper(Byte.class));
756         assertTrue("Character.class", ClassUtils.isPrimitiveOrWrapper(Character.class));
757         assertTrue("Short.class", ClassUtils.isPrimitiveOrWrapper(Short.class));
758         assertTrue("Integer.class", ClassUtils.isPrimitiveOrWrapper(Integer.class));
759         assertTrue("Long.class", ClassUtils.isPrimitiveOrWrapper(Long.class));
760         assertTrue("Double.class", ClassUtils.isPrimitiveOrWrapper(Double.class));
761         assertTrue("Float.class", ClassUtils.isPrimitiveOrWrapper(Float.class));
762         
763         // test primitive classes
764         assertTrue("boolean", ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE));
765         assertTrue("byte", ClassUtils.isPrimitiveOrWrapper(Byte.TYPE));
766         assertTrue("char", ClassUtils.isPrimitiveOrWrapper(Character.TYPE));
767         assertTrue("short", ClassUtils.isPrimitiveOrWrapper(Short.TYPE));
768         assertTrue("int", ClassUtils.isPrimitiveOrWrapper(Integer.TYPE));
769         assertTrue("long", ClassUtils.isPrimitiveOrWrapper(Long.TYPE));
770         assertTrue("double", ClassUtils.isPrimitiveOrWrapper(Double.TYPE));
771         assertTrue("float", ClassUtils.isPrimitiveOrWrapper(Float.TYPE));
772         assertTrue("Void.TYPE", ClassUtils.isPrimitiveOrWrapper(Void.TYPE));
773         
774         // others
775         assertFalse("null", ClassUtils.isPrimitiveOrWrapper(null));
776         assertFalse("Void.class", ClassUtils.isPrimitiveOrWrapper(Void.class));
777         assertFalse("String.class", ClassUtils.isPrimitiveOrWrapper(String.class));
778         assertFalse("this.getClass()", ClassUtils.isPrimitiveOrWrapper(this.getClass()));
779     }
780     
781     @Test
782     public void testIsPrimitiveWrapper() {
783 
784         // test primitive wrapper classes
785         assertTrue("Boolean.class", ClassUtils.isPrimitiveWrapper(Boolean.class));
786         assertTrue("Byte.class", ClassUtils.isPrimitiveWrapper(Byte.class));
787         assertTrue("Character.class", ClassUtils.isPrimitiveWrapper(Character.class));
788         assertTrue("Short.class", ClassUtils.isPrimitiveWrapper(Short.class));
789         assertTrue("Integer.class", ClassUtils.isPrimitiveWrapper(Integer.class));
790         assertTrue("Long.class", ClassUtils.isPrimitiveWrapper(Long.class));
791         assertTrue("Double.class", ClassUtils.isPrimitiveWrapper(Double.class));
792         assertTrue("Float.class", ClassUtils.isPrimitiveWrapper(Float.class));
793         
794         // test primitive classes
795         assertFalse("boolean", ClassUtils.isPrimitiveWrapper(Boolean.TYPE));
796         assertFalse("byte", ClassUtils.isPrimitiveWrapper(Byte.TYPE));
797         assertFalse("char", ClassUtils.isPrimitiveWrapper(Character.TYPE));
798         assertFalse("short", ClassUtils.isPrimitiveWrapper(Short.TYPE));
799         assertFalse("int", ClassUtils.isPrimitiveWrapper(Integer.TYPE));
800         assertFalse("long", ClassUtils.isPrimitiveWrapper(Long.TYPE));
801         assertFalse("double", ClassUtils.isPrimitiveWrapper(Double.TYPE));
802         assertFalse("float", ClassUtils.isPrimitiveWrapper(Float.TYPE));
803         
804         // others
805         assertFalse("null", ClassUtils.isPrimitiveWrapper(null));
806         assertFalse("Void.class", ClassUtils.isPrimitiveWrapper(Void.class));
807         assertFalse("Void.TYPE", ClassUtils.isPrimitiveWrapper(Void.TYPE));
808         assertFalse("String.class", ClassUtils.isPrimitiveWrapper(String.class));
809         assertFalse("this.getClass()", ClassUtils.isPrimitiveWrapper(this.getClass()));
810     }
811     
812     @Test
813     public void testPrimitiveToWrapper() {
814 
815         // test primitive classes
816         assertEquals("boolean -> Boolean.class",
817             Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE));
818         assertEquals("byte -> Byte.class",
819             Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE));
820         assertEquals("char -> Character.class",
821             Character.class, ClassUtils.primitiveToWrapper(Character.TYPE));
822         assertEquals("short -> Short.class",
823             Short.class, ClassUtils.primitiveToWrapper(Short.TYPE));
824         assertEquals("int -> Integer.class",
825             Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE));
826         assertEquals("long -> Long.class",
827             Long.class, ClassUtils.primitiveToWrapper(Long.TYPE));
828         assertEquals("double -> Double.class",
829             Double.class, ClassUtils.primitiveToWrapper(Double.TYPE));
830         assertEquals("float -> Float.class",
831             Float.class, ClassUtils.primitiveToWrapper(Float.TYPE));
832 
833         // test a few other classes
834         assertEquals("String.class -> String.class",
835             String.class, ClassUtils.primitiveToWrapper(String.class));
836         assertEquals("ClassUtils.class -> ClassUtils.class",
837             org.apache.commons.lang3.ClassUtils.class,
838             ClassUtils.primitiveToWrapper(org.apache.commons.lang3.ClassUtils.class));
839         assertEquals("Void.TYPE -> Void.TYPE",
840             Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE));
841 
842         // test null
843         assertNull("null -> null",
844             ClassUtils.primitiveToWrapper(null));
845     }
846 
847     @Test
848     public void testPrimitivesToWrappers() {
849         // test null
850 //        assertNull("null -> null", ClassUtils.primitivesToWrappers(null)); // generates warning
851         assertNull("null -> null", ClassUtils.primitivesToWrappers((Class<?>[]) null)); // equivalent cast to avoid warning
852         // Other possible casts for null
853         assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers()));
854         final Class<?>[] castNull = ClassUtils.primitivesToWrappers((Class<?>)null); // == new Class<?>[]{null}
855         assertTrue("(Class<?>)null -> [null]", Arrays.equals(new Class<?>[]{null}, castNull));
856         // test empty array is returned unchanged
857         // TODO this is not documented
858         assertArrayEquals("empty -> empty",
859                 ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY));
860 
861         // test an array of various classes
862         final Class<?>[] primitives = new Class[] {
863                 Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE,
864                 Integer.TYPE, Long.TYPE, Double.TYPE, Float.TYPE,
865                 String.class, ClassUtils.class
866         };
867         final Class<?>[] wrappers= ClassUtils.primitivesToWrappers(primitives);
868 
869         for (int i=0; i < primitives.length; i++) {
870             // test each returned wrapper
871             final Class<?> primitive = primitives[i];
872             final Class<?> expectedWrapper = ClassUtils.primitiveToWrapper(primitive);
873 
874             assertEquals(primitive + " -> " + expectedWrapper, expectedWrapper, wrappers[i]);
875         }
876 
877         // test an array of no primitive classes
878         final Class<?>[] noPrimitives = new Class[] {
879                 String.class, ClassUtils.class, Void.TYPE
880         };
881         // This used to return the exact same array, but no longer does.
882         assertNotSame("unmodified", noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives));
883     }
884 
885     @Test
886     public void testWrapperToPrimitive() {
887         // an array with classes to convert
888         final Class<?>[] primitives = {
889                 Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE,
890                 Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE
891         };
892         for (final Class<?> primitive : primitives) {
893             final Class<?> wrapperCls = ClassUtils.primitiveToWrapper(primitive);
894             assertFalse("Still primitive", wrapperCls.isPrimitive());
895             assertEquals(wrapperCls + " -> " + primitive, primitive,
896                     ClassUtils.wrapperToPrimitive(wrapperCls));
897         }
898     }
899 
900     @Test
901     public void testWrapperToPrimitiveNoWrapper() {
902         assertNull("Wrong result for non wrapper class", ClassUtils.wrapperToPrimitive(String.class));
903     }
904 
905     @Test
906     public void testWrapperToPrimitiveNull() {
907         assertNull("Wrong result for null class", ClassUtils.wrapperToPrimitive(null));
908     }
909 
910     @Test
911     public void testWrappersToPrimitives() {
912         // an array with classes to test
913         final Class<?>[] classes = {
914                 Boolean.class, Byte.class, Character.class, Short.class,
915                 Integer.class, Long.class, Float.class, Double.class,
916                 String.class, ClassUtils.class, null
917         };
918 
919         final Class<?>[] primitives = ClassUtils.wrappersToPrimitives(classes);
920         // now test the result
921         assertEquals("Wrong length of result array", classes.length, primitives.length);
922         for (int i = 0; i < classes.length; i++) {
923             final Class<?> expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]);
924             assertEquals(classes[i] + " -> " + expectedPrimitive, expectedPrimitive,
925                     primitives[i]);
926         }
927     }
928 
929     @Test
930     public void testWrappersToPrimitivesNull() {
931 //        assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning
932         assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives((Class<?>[]) null)); // equivalent cast
933         // Other possible casts for null
934         assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives()));
935         final Class<?>[] castNull = ClassUtils.wrappersToPrimitives((Class<?>)null); // == new Class<?>[]{null}
936         assertTrue("(Class<?>)null -> [null]", Arrays.equals(new Class<?>[]{null}, castNull));
937 }
938 
939     @Test
940     public void testWrappersToPrimitivesEmpty() {
941         final Class<?>[] empty = new Class[0];
942         assertArrayEquals("Wrong result for empty input", empty, ClassUtils.wrappersToPrimitives(empty));
943     }
944 
945     @Test
946     public void testGetClassClassNotFound() throws Exception {
947         assertGetClassThrowsClassNotFound( "bool" );
948         assertGetClassThrowsClassNotFound( "bool[]" );
949         assertGetClassThrowsClassNotFound( "integer[]" );
950     }
951 
952     @Test
953     public void testGetClassInvalidArguments() throws Exception {
954         assertGetClassThrowsNullPointerException( null );
955         assertGetClassThrowsClassNotFound( "[][][]" );
956         assertGetClassThrowsClassNotFound( "[[]" );
957         assertGetClassThrowsClassNotFound( "[" );
958         assertGetClassThrowsClassNotFound( "java.lang.String][" );
959         assertGetClassThrowsClassNotFound( ".hello.world" );
960         assertGetClassThrowsClassNotFound( "hello..world" );
961     }
962 
963     @Test
964     public void testWithInterleavingWhitespace() throws ClassNotFoundException {
965         assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) );
966         assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) );
967         assertEquals( short[].class, ClassUtils.getClass( "\tshort                \t\t[]" ) );
968         assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r]   " ) );
969     }
970 
971     @Test
972     public void testGetInnerClass() throws ClassNotFoundException {
973         assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested" ) );
974         assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested" ) );
975         assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested" ) );
976         assertEquals( Inner.DeeplyNested.class, ClassUtils.getClass( "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" ) );
977     }
978 
979     @Test
980     public void testGetClassByNormalNameArrays() throws ClassNotFoundException {
981         assertEquals( int[].class, ClassUtils.getClass( "int[]" ) );
982         assertEquals( long[].class, ClassUtils.getClass( "long[]" ) );
983         assertEquals( short[].class, ClassUtils.getClass( "short[]" ) );
984         assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) );
985         assertEquals( char[].class, ClassUtils.getClass( "char[]" ) );
986         assertEquals( float[].class, ClassUtils.getClass( "float[]" ) );
987         assertEquals( double[].class, ClassUtils.getClass( "double[]" ) );
988         assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) );
989         assertEquals( String[].class, ClassUtils.getClass( "java.lang.String[]" ) );
990         assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map.Entry[]" ) );
991         assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "java.util.Map$Entry[]" ) );
992         assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map.Entry;" ) );
993         assertEquals( java.util.Map.Entry[].class, ClassUtils.getClass( "[Ljava.util.Map$Entry;" ) );
994     }
995 
996     @Test
997     public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException {
998         assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) );
999         assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) );
1000         assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) );
1001         assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) );
1002         assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) );
1003         assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) );
1004         assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) );
1005         assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" ) );
1006         assertEquals( String[][].class, ClassUtils.getClass( "java.lang.String[][]" ) );
1007     }
1008 
1009     @Test
1010     public void testGetClassWithArrayClasses2D() throws Exception {
1011         assertGetClassReturnsClass( String[][].class );
1012         assertGetClassReturnsClass( int[][].class );
1013         assertGetClassReturnsClass( long[][].class );
1014         assertGetClassReturnsClass( short[][].class );
1015         assertGetClassReturnsClass( byte[][].class );
1016         assertGetClassReturnsClass( char[][].class );
1017         assertGetClassReturnsClass( float[][].class );
1018         assertGetClassReturnsClass( double[][].class );
1019         assertGetClassReturnsClass( boolean[][].class );
1020     }
1021 
1022     @Test
1023     public void testGetClassWithArrayClasses() throws Exception {
1024         assertGetClassReturnsClass( String[].class );
1025         assertGetClassReturnsClass( int[].class );
1026         assertGetClassReturnsClass( long[].class );
1027         assertGetClassReturnsClass( short[].class );
1028         assertGetClassReturnsClass( byte[].class );
1029         assertGetClassReturnsClass( char[].class );
1030         assertGetClassReturnsClass( float[].class );
1031         assertGetClassReturnsClass( double[].class );
1032         assertGetClassReturnsClass( boolean[].class );
1033     }
1034 
1035     @Test
1036     public void testGetClassRawPrimitives() throws ClassNotFoundException {
1037         assertEquals( int.class, ClassUtils.getClass( "int" ) );
1038         assertEquals( long.class, ClassUtils.getClass( "long" ) );
1039         assertEquals( short.class, ClassUtils.getClass( "short" ) );
1040         assertEquals( byte.class, ClassUtils.getClass( "byte" ) );
1041         assertEquals( char.class, ClassUtils.getClass( "char" ) );
1042         assertEquals( float.class, ClassUtils.getClass( "float" ) );
1043         assertEquals( double.class, ClassUtils.getClass( "double" ) );
1044         assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) );
1045     }
1046 
1047     private void assertGetClassReturnsClass( final Class<?> c ) throws Exception {
1048         assertEquals( c, ClassUtils.getClass( c.getName() ) );
1049     }
1050 
1051     private void assertGetClassThrowsException( final String className, final Class<?> exceptionType ) throws Exception {
1052         try {
1053             ClassUtils.getClass( className );
1054             fail( "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"." );
1055         }
1056         catch( final Exception e ) {
1057             assertTrue( exceptionType.isAssignableFrom( e.getClass() ) );
1058         }
1059     }
1060 
1061     private void assertGetClassThrowsNullPointerException( final String className ) throws Exception {
1062         assertGetClassThrowsException( className, NullPointerException.class );
1063     }
1064 
1065     private void assertGetClassThrowsClassNotFound( final String className ) throws Exception {
1066         assertGetClassThrowsException( className, ClassNotFoundException.class );
1067     }
1068 
1069     // Show the Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957
1070     // We may have to delete this if a JDK fixes the bug.
1071     @Test
1072     public void testShowJavaBug() throws Exception {
1073         // Tests with Collections$UnmodifiableSet
1074         final Set<?> set = Collections.unmodifiableSet(new HashSet<Object>());
1075         final Method isEmptyMethod = set.getClass().getMethod("isEmpty",  new Class[0]);
1076         try {
1077             isEmptyMethod.invoke(set, new Object[0]);
1078             fail("Failed to throw IllegalAccessException as expected");
1079         } catch(final IllegalAccessException iae) {
1080             // expected
1081         }
1082     }
1083 
1084     @Test
1085     public void testGetPublicMethod() throws Exception {
1086         // Tests with Collections$UnmodifiableSet
1087         final Set<?> set = Collections.unmodifiableSet(new HashSet<Object>());
1088         final Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty",  new Class[0]);
1089             assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers()));
1090 
1091         try {
1092             isEmptyMethod.invoke(set, new Object[0]);
1093         } catch(final java.lang.IllegalAccessException iae) {
1094             fail("Should not have thrown IllegalAccessException");
1095         }
1096 
1097         // Tests with a public Class
1098         final Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString",  new Class[0]);
1099             assertEquals(Object.class.getMethod("toString", new Class[0]), toStringMethod);
1100     }
1101 
1102     @Test
1103     public void testToClass_object() {
1104 //        assertNull(ClassUtils.toClass(null)); // generates warning
1105         assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast
1106         
1107         // Additional varargs tests
1108         assertTrue("empty -> empty", Arrays.equals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass()));
1109         final Class<?>[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null}
1110         assertTrue("(Object)null -> [null]", Arrays.equals(new Object[]{null}, castNull));
1111 
1112         assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY));
1113 
1114         assertTrue(Arrays.equals(new Class[] { String.class, Integer.class, Double.class },
1115                 ClassUtils.toClass(new Object[] { "Test", Integer.valueOf(1), Double.valueOf(99d) })));
1116 
1117         assertTrue(Arrays.equals(new Class[] { String.class, null, Double.class },
1118                 ClassUtils.toClass(new Object[] { "Test", null, Double.valueOf(99d) })));
1119     }
1120 
1121     @Test
1122     public void test_getShortCanonicalName_Object() {
1123         assertEquals("<null>", ClassUtils.getShortCanonicalName(null, "<null>"));
1124         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "<null>"));
1125         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "<null>"));
1126         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "<null>"));
1127         assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "<null>"));
1128         assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "<null>"));
1129 
1130         // Inner types
1131         class Named extends Object {}
1132         assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName(new Object(){}, "<null>"));
1133         assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName(new Named(), "<null>"));
1134         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(new Inner(), "<null>"));
1135     }
1136 
1137     @Test
1138     public void test_getShortCanonicalName_Class() {
1139         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class));
1140         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class));
1141         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class));
1142         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class));
1143         assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class));
1144         
1145         // Inner types
1146         class Named extends Object {}
1147         assertEquals("ClassUtilsTest.7", ClassUtils.getShortCanonicalName(new Object(){}.getClass()));
1148         assertEquals("ClassUtilsTest.6Named", ClassUtils.getShortCanonicalName(Named.class));
1149         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName(Inner.class));
1150     }
1151 
1152     @Test
1153     public void test_getShortCanonicalName_String() {
1154         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils"));
1155         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;"));
1156         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;"));
1157         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[]"));
1158         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[][]"));
1159         assertEquals("int[]", ClassUtils.getShortCanonicalName("[I"));
1160         assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I"));
1161         assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]"));
1162         assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]"));
1163         
1164         // Inner types
1165         assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
1166         assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));
1167         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner"));
1168     }
1169 
1170     @Test
1171     public void test_getPackageCanonicalName_Object() {
1172         assertEquals("<null>", ClassUtils.getPackageCanonicalName(null, "<null>"));
1173         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils(), "<null>"));
1174         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "<null>"));
1175         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "<null>"));
1176         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "<null>"));
1177         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "<null>"));
1178         
1179         // Inner types
1180         class Named extends Object {}
1181         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}, "<null>"));
1182         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Named(), "<null>"));
1183         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Inner(), "<null>"));
1184     }
1185 
1186     @Test
1187     public void test_getPackageCanonicalName_Class() {
1188         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils.class));
1189         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[].class));
1190         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class));
1191         assertEquals("", ClassUtils.getPackageCanonicalName(int[].class));
1192         assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class));
1193         
1194         // Inner types
1195         class Named extends Object {}
1196         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object(){}.getClass()));
1197         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class));
1198         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class));
1199     }
1200 
1201     @Test
1202     public void test_getPackageCanonicalName_String() {
1203         assertEquals("org.apache.commons.lang3",
1204             ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils"));
1205         assertEquals("org.apache.commons.lang3",
1206             ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;"));
1207         assertEquals("org.apache.commons.lang3",
1208             ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;"));
1209         assertEquals("org.apache.commons.lang3",
1210             ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[]"));
1211         assertEquals("org.apache.commons.lang3",
1212             ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][]"));
1213         assertEquals("", ClassUtils.getPackageCanonicalName("[I"));
1214         assertEquals("", ClassUtils.getPackageCanonicalName("[[I"));
1215         assertEquals("", ClassUtils.getPackageCanonicalName("int[]"));
1216         assertEquals("", ClassUtils.getPackageCanonicalName("int[][]"));
1217         
1218         // Inner types
1219         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
1220         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));
1221         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner"));
1222     }
1223 
1224 }