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.lang;
18  
19  import java.lang.reflect.Constructor;
20  import java.lang.reflect.Method;
21  import java.lang.reflect.Modifier;
22  import java.util.ArrayList;
23  import java.util.Collections;
24  import java.util.HashSet;
25  import java.util.List;
26  import java.util.Map;
27  import java.util.Set;
28  
29  import junit.framework.Test;
30  import junit.framework.TestCase;
31  import junit.framework.TestSuite;
32  import junit.textui.TestRunner;
33  
34  
35  
36  /**
37   * Unit tests {@link org.apache.commons.lang.ClassUtils}.
38   *
39   * @author Stephen Colebourne
40   * @author Gary D. Gregory
41   * @author Tomasz Blachowicz
42   * @version $Id: ClassUtilsTest.java 612749 2008-01-17 08:05:23Z bayard $
43   */
44  public class ClassUtilsTest extends TestCase {
45  
46      public ClassUtilsTest(String name) {
47          super(name);
48      }
49  
50      public static void main(String[] args) {
51          TestRunner.run(suite());
52      }
53  
54      public static Test suite() {
55          TestSuite suite = new TestSuite(ClassUtilsTest.class);
56          suite.setName("ClassUtils Tests");
57          return suite;
58      }
59  
60      protected void setUp() throws Exception {
61          super.setUp();
62      }
63  
64      protected void tearDown() throws Exception {
65          super.tearDown();
66      }
67  
68      private static class Inner {
69      }
70      
71      //-----------------------------------------------------------------------
72      public void testConstructor() {
73          assertNotNull(new ClassUtils());
74          Constructor[] cons = ClassUtils.class.getDeclaredConstructors();
75          assertEquals(1, cons.length);
76          assertEquals(true, Modifier.isPublic(cons[0].getModifiers()));
77          assertEquals(true, Modifier.isPublic(ClassUtils.class.getModifiers()));
78          assertEquals(false, Modifier.isFinal(ClassUtils.class.getModifiers()));
79      }
80      
81      // -------------------------------------------------------------------------
82      public void test_getShortClassName_Object() {
83          assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>"));
84          assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
85          assertEquals("String", ClassUtils.getShortClassName("hello", "<null>"));
86          assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>"));
87      }
88      
89      public void test_getShortClassName_Class() {
90          assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class));
91          assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class));
92          assertEquals("", ClassUtils.getShortClassName((Class) null));
93      }
94      
95      public void test_getShortClassName_String() {
96          assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName()));
97          assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName()));
98          assertEquals("", ClassUtils.getShortClassName((String) null));
99          assertEquals("", ClassUtils.getShortClassName(""));
100     }
101     
102     // -------------------------------------------------------------------------
103     public void test_getPackageName_Object() {
104         assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new ClassUtils(), "<null>"));
105         assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new Inner(), "<null>"));
106         assertEquals("<null>", ClassUtils.getPackageName(null, "<null>"));
107     }
108     
109     public void test_getPackageName_Class() {
110         assertEquals("java.lang", ClassUtils.getPackageName(String.class));
111         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class));
112         assertEquals("", ClassUtils.getPackageName((Class)null));
113     }
114     
115     public void test_getPackageName_String() {
116         assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(ClassUtils.class.getName()));
117         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName()));
118         assertEquals("", ClassUtils.getPackageName((String)null));
119         assertEquals("", ClassUtils.getPackageName(""));
120     }
121     
122     // -------------------------------------------------------------------------
123     public void test_getAllSuperclasses_Class() {
124         List list = ClassUtils.getAllSuperclasses(CY.class);
125         assertEquals(2, list.size());
126         assertEquals(CX.class, list.get(0));
127         assertEquals(Object.class, list.get(1));
128         
129         assertEquals(null, ClassUtils.getAllSuperclasses(null));
130     }
131     
132     public void test_getAllInterfaces_Class() {
133         List list = ClassUtils.getAllInterfaces(CY.class);
134         assertEquals(6, list.size());
135         assertEquals(IB.class, list.get(0));
136         assertEquals(IC.class, list.get(1));
137         assertEquals(ID.class, list.get(2));
138         assertEquals(IE.class, list.get(3));
139         assertEquals(IF.class, list.get(4));
140         assertEquals(IA.class, list.get(5));
141         
142         assertEquals(null, ClassUtils.getAllInterfaces(null));
143     }
144     
145     private static interface IA {
146     }
147     private static interface IB {
148     }
149     private static interface IC extends ID, IE {
150     }
151     private static interface ID {
152     }
153     private static interface IE extends IF {
154     }
155     private static interface IF {
156     }
157     private static class CX implements IB, IA, IE {
158     }
159     private static class CY extends CX implements IB, IC {
160     }
161     
162     // -------------------------------------------------------------------------
163     public void test_convertClassNamesToClasses_List() {
164         List list = new ArrayList();
165         List result = ClassUtils.convertClassNamesToClasses(list);
166         assertEquals(0, result.size());
167         
168         list.add("java.lang.String");
169         list.add("java.lang.xxx");
170         list.add("java.lang.Object");
171         result = ClassUtils.convertClassNamesToClasses(list);
172         assertEquals(3, result.size());
173         assertEquals(String.class, result.get(0));
174         assertEquals(null, result.get(1));
175         assertEquals(Object.class, result.get(2));
176 
177         list.add(new Object());
178         try {
179             ClassUtils.convertClassNamesToClasses(list);
180             fail();
181         } catch (ClassCastException ex) {}
182         assertEquals(null, ClassUtils.convertClassNamesToClasses(null));
183     }
184     
185     public void test_convertClassesToClassNames_List() {
186         List list = new ArrayList();
187         List result = ClassUtils.convertClassesToClassNames(list);
188         assertEquals(0, result.size());
189         
190         list.add(String.class);
191         list.add(null);
192         list.add(Object.class);
193         result = ClassUtils.convertClassesToClassNames(list);
194         assertEquals(3, result.size());
195         assertEquals("java.lang.String", result.get(0));
196         assertEquals(null, result.get(1));
197         assertEquals("java.lang.Object", result.get(2));
198 
199         list.add(new Object());
200         try {
201             ClassUtils.convertClassesToClassNames(list);
202             fail();
203         } catch (ClassCastException ex) {}
204         assertEquals(null, ClassUtils.convertClassesToClassNames(null));
205     }
206     
207     // -------------------------------------------------------------------------
208     public void test_isInnerClass_Class() {
209         assertEquals(true, ClassUtils.isInnerClass(Inner.class));
210         assertEquals(true, ClassUtils.isInnerClass(Map.Entry.class));
211         assertEquals(true, ClassUtils.isInnerClass(new Cloneable() {
212         }.getClass()));
213         assertEquals(false, ClassUtils.isInnerClass(this.getClass()));
214         assertEquals(false, ClassUtils.isInnerClass(String.class));
215         assertEquals(false, ClassUtils.isInnerClass(null));
216     }
217     
218     // -------------------------------------------------------------------------
219     public void test_isAssignable_ClassArray_ClassArray() throws Exception {
220         Class[] array2 = new Class[] {Object.class, Object.class};
221         Class[] array1 = new Class[] {Object.class};
222         Class[] array1s = new Class[] {String.class};
223         Class[] array0 = new Class[] {};
224 
225         assertEquals(false, ClassUtils.isAssignable(array1, array2));
226         assertEquals(false, ClassUtils.isAssignable(null, array2));
227         assertEquals(true, ClassUtils.isAssignable(null, array0));
228         assertEquals(true, ClassUtils.isAssignable(array0, array0));
229         assertEquals(true, ClassUtils.isAssignable(array0, null));
230         assertEquals(true, ClassUtils.isAssignable((Class[]) null, (Class[]) null));
231         
232         assertEquals(false, ClassUtils.isAssignable(array1, array1s));
233         assertEquals(true, ClassUtils.isAssignable(array1s, array1s));
234         assertEquals(true, ClassUtils.isAssignable(array1s, array1));
235     }
236     
237     public void test_isAssignable() throws Exception {
238         assertEquals(false, ClassUtils.isAssignable((Class) null, null));
239         assertEquals(false, ClassUtils.isAssignable(String.class, null));
240         
241         assertEquals(true, ClassUtils.isAssignable(null, Object.class));
242         assertEquals(true, ClassUtils.isAssignable(null, Integer.class));
243         assertEquals(false, ClassUtils.isAssignable(null, Integer.TYPE));
244         assertEquals(true, ClassUtils.isAssignable(String.class, Object.class));
245         assertEquals(true, ClassUtils.isAssignable(String.class, String.class));
246         assertEquals(false, ClassUtils.isAssignable(Object.class, String.class));
247         assertEquals(false, ClassUtils.isAssignable(Integer.TYPE, Integer.class));
248         assertEquals(false, ClassUtils.isAssignable(Integer.class, Integer.TYPE));
249         assertEquals(true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
250         assertEquals(true, ClassUtils.isAssignable(Integer.class, Integer.class));
251     }
252     
253     public void test_isAssignable_Widening() throws Exception {
254         // test byte conversions
255         assertEquals("byte -> char", false, ClassUtils.isAssignable(Byte.TYPE, Character.TYPE));
256         assertEquals("byte -> byte", true, ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE));
257         assertEquals("byte -> short", true, ClassUtils.isAssignable(Byte.TYPE, Short.TYPE));
258         assertEquals("byte -> int", true, ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE));
259         assertEquals("byte -> long", true, ClassUtils.isAssignable(Byte.TYPE, Long.TYPE));
260         assertEquals("byte -> float", true, ClassUtils.isAssignable(Byte.TYPE, Float.TYPE));
261         assertEquals("byte -> double", true, ClassUtils.isAssignable(Byte.TYPE, Double.TYPE));
262         assertEquals("byte -> boolean", false, ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE));
263         
264         // test short conversions
265         assertEquals("short -> char", false, ClassUtils.isAssignable(Short.TYPE, Character.TYPE));
266         assertEquals("short -> byte", false, ClassUtils.isAssignable(Short.TYPE, Byte.TYPE));
267         assertEquals("short -> short", true, ClassUtils.isAssignable(Short.TYPE, Short.TYPE));
268         assertEquals("short -> int", true, ClassUtils.isAssignable(Short.TYPE, Integer.TYPE));
269         assertEquals("short -> long", true, ClassUtils.isAssignable(Short.TYPE, Long.TYPE));
270         assertEquals("short -> float", true, ClassUtils.isAssignable(Short.TYPE, Float.TYPE));
271         assertEquals("short -> double", true, ClassUtils.isAssignable(Short.TYPE, Double.TYPE));
272         assertEquals("short -> boolean", false, ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE));
273         
274         // test char conversions
275         assertEquals("char -> char", true, ClassUtils.isAssignable(Character.TYPE, Character.TYPE));
276         assertEquals("char -> byte", false, ClassUtils.isAssignable(Character.TYPE, Byte.TYPE));
277         assertEquals("char -> short", false, ClassUtils.isAssignable(Character.TYPE, Short.TYPE));
278         assertEquals("char -> int", true, ClassUtils.isAssignable(Character.TYPE, Integer.TYPE));
279         assertEquals("char -> long", true, ClassUtils.isAssignable(Character.TYPE, Long.TYPE));
280         assertEquals("char -> float", true, ClassUtils.isAssignable(Character.TYPE, Float.TYPE));
281         assertEquals("char -> double", true, ClassUtils.isAssignable(Character.TYPE, Double.TYPE));
282         assertEquals("char -> boolean", false, ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE));
283         
284         // test int conversions
285         assertEquals("int -> char", false, ClassUtils.isAssignable(Integer.TYPE, Character.TYPE));
286         assertEquals("int -> byte", false, ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE));
287         assertEquals("int -> short", false, ClassUtils.isAssignable(Integer.TYPE, Short.TYPE));
288         assertEquals("int -> int", true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
289         assertEquals("int -> long", true, ClassUtils.isAssignable(Integer.TYPE, Long.TYPE));
290         assertEquals("int -> float", true, ClassUtils.isAssignable(Integer.TYPE, Float.TYPE));
291         assertEquals("int -> double", true, ClassUtils.isAssignable(Integer.TYPE, Double.TYPE));
292         assertEquals("int -> boolean", false, ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE));
293  
294         // test long conversions
295         assertEquals("long -> char", false, ClassUtils.isAssignable(Long.TYPE, Character.TYPE));
296         assertEquals("long -> byte", false, ClassUtils.isAssignable(Long.TYPE, Byte.TYPE));
297         assertEquals("long -> short", false, ClassUtils.isAssignable(Long.TYPE, Short.TYPE));
298         assertEquals("long -> int", false, ClassUtils.isAssignable(Long.TYPE, Integer.TYPE));
299         assertEquals("long -> long", true, ClassUtils.isAssignable(Long.TYPE, Long.TYPE));
300         assertEquals("long -> float", true, ClassUtils.isAssignable(Long.TYPE, Float.TYPE));
301         assertEquals("long -> double", true, ClassUtils.isAssignable(Long.TYPE, Double.TYPE));
302         assertEquals("long -> boolean", false, ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE));
303  
304         // test float conversions
305         assertEquals("float -> char", false, ClassUtils.isAssignable(Float.TYPE, Character.TYPE));
306         assertEquals("float -> byte", false, ClassUtils.isAssignable(Float.TYPE, Byte.TYPE));
307         assertEquals("float -> short", false, ClassUtils.isAssignable(Float.TYPE, Short.TYPE));
308         assertEquals("float -> int", false, ClassUtils.isAssignable(Float.TYPE, Integer.TYPE));
309         assertEquals("float -> long", false, ClassUtils.isAssignable(Float.TYPE, Long.TYPE));
310         assertEquals("float -> float", true, ClassUtils.isAssignable(Float.TYPE, Float.TYPE));
311         assertEquals("float -> double", true, ClassUtils.isAssignable(Float.TYPE, Double.TYPE));
312         assertEquals("float -> boolean", false, ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE));
313         
314         // test float conversions
315         assertEquals("double -> char", false, ClassUtils.isAssignable(Double.TYPE, Character.TYPE));
316         assertEquals("double -> byte", false, ClassUtils.isAssignable(Double.TYPE, Byte.TYPE));
317         assertEquals("double -> short", false, ClassUtils.isAssignable(Double.TYPE, Short.TYPE));
318         assertEquals("double -> int", false, ClassUtils.isAssignable(Double.TYPE, Integer.TYPE));
319         assertEquals("double -> long", false, ClassUtils.isAssignable(Double.TYPE, Long.TYPE));
320         assertEquals("double -> float", false, ClassUtils.isAssignable(Double.TYPE, Float.TYPE));
321         assertEquals("double -> double", true, ClassUtils.isAssignable(Double.TYPE, Double.TYPE));
322         assertEquals("double -> boolean", false, ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE));
323         
324         // test float conversions
325         assertEquals("boolean -> char", false, ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE));
326         assertEquals("boolean -> byte", false, ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE));
327         assertEquals("boolean -> short", false, ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE));
328         assertEquals("boolean -> int", false, ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE));
329         assertEquals("boolean -> long", false, ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE));
330         assertEquals("boolean -> float", false, ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE));
331         assertEquals("boolean -> double", false, ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE));
332         assertEquals("boolean -> boolean", true, ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE));
333     }
334     
335     public void testPrimitiveToWrapper() {
336        
337         // test primitive classes
338         assertEquals("boolean -> Boolean.class", 
339             Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE));   
340         assertEquals("byte -> Byte.class",
341             Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE));
342         assertEquals("char -> Character.class",
343             Character.class, ClassUtils.primitiveToWrapper(Character.TYPE));
344         assertEquals("short -> Short.class",
345             Short.class, ClassUtils.primitiveToWrapper(Short.TYPE));
346         assertEquals("int -> Integer.class",
347             Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE));
348         assertEquals("long -> Long.class",
349             Long.class, ClassUtils.primitiveToWrapper(Long.TYPE));
350         assertEquals("double -> Double.class",
351             Double.class, ClassUtils.primitiveToWrapper(Double.TYPE));
352         assertEquals("float -> Float.class",
353             Float.class, ClassUtils.primitiveToWrapper(Float.TYPE));
354         
355         // test a few other classes
356         assertEquals("String.class -> String.class",
357             String.class, ClassUtils.primitiveToWrapper(String.class));
358         assertEquals("ClassUtils.class -> ClassUtils.class",
359             org.apache.commons.lang.ClassUtils.class, 
360             ClassUtils.primitiveToWrapper(org.apache.commons.lang.ClassUtils.class));
361         assertEquals("Void.TYPE -> Void.TYPE",
362             Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE));
363             
364         // test null     
365         assertNull("null -> null",
366             ClassUtils.primitiveToWrapper(null));
367     }
368 
369     public void testPrimitivesToWrappers() {
370         // test null
371         assertNull("null -> null",
372             ClassUtils.primitivesToWrappers(null));
373         // test empty array
374         assertEquals("empty -> empty",
375                 ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY));
376 
377         // test an array of various classes
378         final Class[] primitives = new Class[] {
379                 Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, 
380                 Integer.TYPE, Long.TYPE, Double.TYPE, Float.TYPE,
381                 String.class, ClassUtils.class
382         };
383         Class[] wrappers= ClassUtils.primitivesToWrappers(primitives);
384         
385         for (int i=0; i < primitives.length; i++) {
386             // test each returned wrapper
387             Class primitive = primitives[i];
388             Class expectedWrapper = ClassUtils.primitiveToWrapper(primitive);
389             
390             assertEquals(primitive + " -> " + expectedWrapper, expectedWrapper, wrappers[i]);
391         }
392 
393         // test an array of no primitive classes
394         final Class[] noPrimitives = new Class[] {
395                 String.class, ClassUtils.class, Void.TYPE
396         };
397         // This used to return the exact same array, but no longer does.
398         assertNotSame("unmodified", noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives));
399     }
400 
401     public void testWrapperToPrimitive() {
402         // an array with classes to convert
403         final Class[] primitives = {
404                 Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE,
405                 Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE
406         };
407         for (int i = 0; i < primitives.length; i++) {
408             Class wrapperCls = ClassUtils.primitiveToWrapper(primitives[i]);
409             assertFalse("Still primitive", wrapperCls.isPrimitive());
410             assertEquals(wrapperCls + " -> " + primitives[i], primitives[i],
411                     ClassUtils.wrapperToPrimitive(wrapperCls));
412         }
413     }
414 
415     public void testWrapperToPrimitiveNoWrapper() {
416         assertNull("Wrong result for non wrapper class", ClassUtils.wrapperToPrimitive(String.class));
417     }
418 
419     public void testWrapperToPrimitiveNull() {
420         assertNull("Wrong result for null class", ClassUtils.wrapperToPrimitive(null));
421     }
422 
423     public void testWrappersToPrimitives() {
424         // an array with classes to test
425         final Class[] classes = {
426                 Boolean.class, Byte.class, Character.class, Short.class,
427                 Integer.class, Long.class, Float.class, Double.class,
428                 String.class, ClassUtils.class, null
429         };
430 
431         Class[] primitives = ClassUtils.wrappersToPrimitives(classes);
432         // now test the result
433         assertEquals("Wrong length of result array", classes.length, primitives.length);
434         for (int i = 0; i < classes.length; i++) {
435             Class expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]);
436             assertEquals(classes[i] + " -> " + expectedPrimitive, expectedPrimitive,
437                     primitives[i]);
438         }
439     }
440 
441     public void testWrappersToPrimitivesNull() {
442         assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null));
443     }
444 
445     public void testWrappersToPrimitivesEmpty() {
446         Class[] empty = new Class[0];
447         assertEquals("Wrong result for empty input", empty, ClassUtils.wrappersToPrimitives(empty));
448     }
449 
450     public void testGetClassClassNotFound() throws Exception {
451         assertGetClassThrowsClassNotFound( "bool" );
452         assertGetClassThrowsClassNotFound( "bool[]" );
453         assertGetClassThrowsClassNotFound( "integer[]" );
454     }
455 
456     public void testGetClassInvalidArguments() throws Exception {
457         assertGetClassThrowsIllegalArgument( null );
458         assertGetClassThrowsClassNotFound( "[][][]" );
459         assertGetClassThrowsClassNotFound( "[[]" );
460         assertGetClassThrowsClassNotFound( "[" );
461         assertGetClassThrowsClassNotFound( "java.lang.String][" );
462         assertGetClassThrowsClassNotFound( ".hello.world" );
463         assertGetClassThrowsClassNotFound( "hello..world" );
464     }
465 
466     public void testWithInterleavingWhitespace() throws ClassNotFoundException {
467         assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) );
468         assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) );
469         assertEquals( short[].class, ClassUtils.getClass( "\tshort                \t\t[]" ) );
470         assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r]   " ) );
471     }
472 
473     public void testGetClassByNormalNameArrays() throws ClassNotFoundException {
474         assertEquals( int[].class, ClassUtils.getClass( "int[]" ) );
475         assertEquals( long[].class, ClassUtils.getClass( "long[]" ) );
476         assertEquals( short[].class, ClassUtils.getClass( "short[]" ) );
477         assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) );
478         assertEquals( char[].class, ClassUtils.getClass( "char[]" ) );
479         assertEquals( float[].class, ClassUtils.getClass( "float[]" ) );
480         assertEquals( double[].class, ClassUtils.getClass( "double[]" ) );
481         assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) );
482         assertEquals( String[].class, ClassUtils.getClass( "java.lang.String[]" ) );
483     }
484 
485     public void testGetClassByNormalNameArrays2D() throws ClassNotFoundException {
486         assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) );
487         assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) );
488         assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) );
489         assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) );
490         assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) );
491         assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) );
492         assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) );
493         assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" ) );
494         assertEquals( String[][].class, ClassUtils.getClass( "java.lang.String[][]" ) );
495     }
496 
497     public void testGetClassWithArrayClasses2D() throws Exception {
498         assertGetClassReturnsClass( String[][].class );
499         assertGetClassReturnsClass( int[][].class );
500         assertGetClassReturnsClass( long[][].class );
501         assertGetClassReturnsClass( short[][].class );
502         assertGetClassReturnsClass( byte[][].class );
503         assertGetClassReturnsClass( char[][].class );
504         assertGetClassReturnsClass( float[][].class );
505         assertGetClassReturnsClass( double[][].class );
506         assertGetClassReturnsClass( boolean[][].class );
507     }
508 
509     public void testGetClassWithArrayClasses() throws Exception {
510         assertGetClassReturnsClass( String[].class );
511         assertGetClassReturnsClass( int[].class );
512         assertGetClassReturnsClass( long[].class );
513         assertGetClassReturnsClass( short[].class );
514         assertGetClassReturnsClass( byte[].class );
515         assertGetClassReturnsClass( char[].class );
516         assertGetClassReturnsClass( float[].class );
517         assertGetClassReturnsClass( double[].class );
518         assertGetClassReturnsClass( boolean[].class );
519     }
520 
521     public void testGetClassRawPrimitives() throws ClassNotFoundException {
522         assertEquals( int.class, ClassUtils.getClass( "int" ) );
523         assertEquals( long.class, ClassUtils.getClass( "long" ) );
524         assertEquals( short.class, ClassUtils.getClass( "short" ) );
525         assertEquals( byte.class, ClassUtils.getClass( "byte" ) );
526         assertEquals( char.class, ClassUtils.getClass( "char" ) );
527         assertEquals( float.class, ClassUtils.getClass( "float" ) );
528         assertEquals( double.class, ClassUtils.getClass( "double" ) );
529         assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) );
530     }
531 
532     private void assertGetClassReturnsClass( Class c ) throws Exception {
533         assertEquals( c, ClassUtils.getClass( c.getName() ) );
534     }
535 
536     private void assertGetClassThrowsException( String className, Class exceptionType ) throws Exception {
537         try {
538             ClassUtils.getClass( className );
539             fail( "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\"." );
540         }
541         catch( Exception e ) {
542             assertTrue( exceptionType.isAssignableFrom( e.getClass() ) );
543         }
544     }
545 
546     private void assertGetClassThrowsIllegalArgument( String className ) throws Exception {
547         assertGetClassThrowsException( className, IllegalArgumentException.class );
548     }
549 
550     private void assertGetClassThrowsClassNotFound( String className ) throws Exception {
551         assertGetClassThrowsException( className, ClassNotFoundException.class );
552     }
553 
554     // Show the Java bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4071957
555     // We may have to delete this if a JDK fixes the bug.
556     public void testShowJavaBug() throws Exception {
557         // Tests with Collections$UnmodifiableSet
558         Set set = Collections.unmodifiableSet(new HashSet());
559         Method isEmptyMethod = set.getClass().getMethod("isEmpty",  new Class[0]);
560         try {
561             isEmptyMethod.invoke(set, new Object[0]);
562             fail("Failed to throw IllegalAccessException as expected");
563         } catch(IllegalAccessException iae) {
564             // expected
565         }
566     }
567 
568     public void testGetPublicMethod() throws Exception {
569         // Tests with Collections$UnmodifiableSet
570         Set set = Collections.unmodifiableSet(new HashSet());
571         Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty",  new Class[0]);
572             assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers()));
573  
574         try {
575             isEmptyMethod.invoke(set, new Object[0]);
576         } catch(java.lang.IllegalAccessException iae) {
577             fail("Should not have thrown IllegalAccessException");
578         }
579                
580         // Tests with a public Class
581         Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString",  new Class[0]);
582             assertEquals(Object.class.getMethod("toString", new Class[0]), toStringMethod);
583     }
584  
585     public void testToClass_object() {
586         assertEquals(null, ClassUtils.toClass(null));
587 
588         assertSame(
589             ArrayUtils.EMPTY_CLASS_ARRAY,
590             ClassUtils.toClass(new Class[0]));
591 
592         Object[] array = new Object[3];
593         array[0] = new String("Test");
594         array[1] = new Integer(1);
595         array[2] = new Double(99);
596 
597         Class[] results = ClassUtils.toClass(array);
598         assertEquals("String", ClassUtils.getShortClassName(results[0]));
599         assertEquals("Integer", ClassUtils.getShortClassName(results[1]));
600         assertEquals("Double", ClassUtils.getShortClassName(results[2]));
601     }
602 
603     public void test_getShortCanonicalName_Object() {
604         assertEquals("<null>", ClassUtils.getShortCanonicalName(null, "<null>"));
605         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "<null>"));
606         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "<null>"));
607         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "<null>"));
608         assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "<null>"));
609         assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "<null>"));
610     }
611 
612     public void test_getShortCanonicalName_Class() {
613         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class));
614         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class));
615         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class));
616         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class));
617         assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class));
618     }
619 
620     public void test_getShortCanonicalName_String() {
621         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang.ClassUtils"));
622         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang.ClassUtils;"));
623         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang.ClassUtils;"));
624         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang.ClassUtils[]"));
625         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang.ClassUtils[][]"));
626         assertEquals("int[]", ClassUtils.getShortCanonicalName("[I"));
627         assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I"));
628         assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]"));
629         assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]"));
630     }
631 
632     public void test_getPackageCanonicalName_Object() {
633         assertEquals("<null>", ClassUtils.getPackageCanonicalName(null, "<null>"));
634         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(new ClassUtils(), "<null>"));
635         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "<null>"));
636         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "<null>"));
637         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "<null>"));
638         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "<null>"));
639     }
640 
641     public void test_getPackageCanonicalName_Class() {
642         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(ClassUtils.class));
643         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(ClassUtils[].class));
644         assertEquals("org.apache.commons.lang", ClassUtils.getPackageCanonicalName(ClassUtils[][].class));
645         assertEquals("", ClassUtils.getPackageCanonicalName(int[].class));
646         assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class));
647     }
648 
649     public void test_getPackageCanonicalName_String() {
650         assertEquals("org.apache.commons.lang", 
651             ClassUtils.getPackageCanonicalName("org.apache.commons.lang.ClassUtils"));
652         assertEquals("org.apache.commons.lang", 
653             ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang.ClassUtils;"));
654         assertEquals("org.apache.commons.lang", 
655             ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang.ClassUtils;"));
656         assertEquals("org.apache.commons.lang", 
657             ClassUtils.getPackageCanonicalName("org.apache.commons.lang.ClassUtils[]"));
658         assertEquals("org.apache.commons.lang", 
659             ClassUtils.getPackageCanonicalName("org.apache.commons.lang.ClassUtils[][]"));
660         assertEquals("", ClassUtils.getPackageCanonicalName("[I"));
661         assertEquals("", ClassUtils.getPackageCanonicalName("[[I"));
662         assertEquals("", ClassUtils.getPackageCanonicalName("int[]"));
663         assertEquals("", ClassUtils.getPackageCanonicalName("int[][]"));
664     }
665 
666 }