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    *      https://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.LangAssertions.assertIllegalArgumentException;
20  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
21  import static org.junit.jupiter.api.Assertions.assertEquals;
22  import static org.junit.jupiter.api.Assertions.assertFalse;
23  import static org.junit.jupiter.api.Assertions.assertNotNull;
24  import static org.junit.jupiter.api.Assertions.assertNotSame;
25  import static org.junit.jupiter.api.Assertions.assertNull;
26  import static org.junit.jupiter.api.Assertions.assertSame;
27  import static org.junit.jupiter.api.Assertions.assertThrows;
28  import static org.junit.jupiter.api.Assertions.assertTrue;
29  import static org.junit.jupiter.api.Assertions.fail;
30  
31  import java.io.Serializable;
32  import java.lang.reflect.Constructor;
33  import java.lang.reflect.Method;
34  import java.lang.reflect.Modifier;
35  import java.util.ArrayList;
36  import java.util.Collections;
37  import java.util.HashSet;
38  import java.util.Iterator;
39  import java.util.List;
40  import java.util.Map;
41  import java.util.Objects;
42  import java.util.Set;
43  import java.util.TreeMap;
44  import java.util.function.Function;
45  
46  import org.apache.commons.lang3.ClassUtils.Interfaces;
47  import org.apache.commons.lang3.reflect.testbed.GenericConsumer;
48  import org.apache.commons.lang3.reflect.testbed.GenericParent;
49  import org.apache.commons.lang3.reflect.testbed.StringParameterizedChild;
50  import org.junit.jupiter.api.Test;
51  import org.junit.jupiter.params.ParameterizedTest;
52  import org.junitpioneer.jupiter.params.IntRangeSource;
53  
54  /**
55   * Tests {@link ClassUtils}.
56   */
57  @SuppressWarnings("boxing") // JUnit4 does not support primitive equality testing apart from long
58  class ClassUtilsTest extends AbstractLangTest {
59  
60      private static class CX implements IB, IA, IE {
61          // empty
62      }
63  
64      @SuppressWarnings("unused") // IB is redundant but what a test checks
65      private static final class CY extends CX implements IB, IC {
66          // empty
67      }
68  
69      private interface IA {
70          // empty
71      }
72  
73      private interface IB {
74          // empty
75      }
76  
77      private interface IC extends ID, IE {
78          // empty
79      }
80  
81      private interface ID {
82          // empty
83      }
84  
85      private interface IE extends IF {
86          // empty
87      }
88  
89      private interface IF {
90          // empty
91      }
92  
93      private static final class Inner {
94          private static final class DeeplyNested {
95              // empty
96          }
97      }
98  
99      private static final int MAX_ARRAY_DIMENSIONS = 255;
100 
101     private static final String OBJECT_CANONICAL_NAME = "java.lang.Object";
102 
103     private void assertGetClassReturnsClass(final Class<?> c) throws Exception {
104         assertEquals(c, ClassUtils.getClass(c.getName()));
105     }
106 
107     private void assertGetClassThrowsClassNotFound(final String className) {
108         assertGetClassThrowsException(className, ClassNotFoundException.class);
109     }
110 
111     private void assertGetClassThrowsException(final String className, final Class<? extends Exception> exceptionType) {
112         final Exception exception = assertThrows(exceptionType, () -> ClassUtils.getClass(className),
113             "ClassUtils.getClass() should fail with an exception of type " + exceptionType.getName() + " when given class name \"" + className + "\".");
114         if (className != null) {
115             assertEquals(className, exception.getMessage());
116         }
117     }
118 
119     private void assertGetClassThrowsNullPointerException(final String className) {
120         assertGetClassThrowsException(className, NullPointerException.class);
121     }
122 
123     private int getDimension(final Class<?> clazz) {
124         Objects.requireNonNull(clazz, "clazz");
125         if (!clazz.isArray()) {
126             fail("Not an array: " + clazz);
127         }
128         final String className = clazz.getName();
129         int dimension = 0;
130         for (final char c : className.toCharArray()) {
131             if (c != '[') {
132                 break;
133             }
134             dimension++;
135         }
136         return dimension;
137     }
138 
139     @Test
140     void test_convertClassesToClassNames_List() {
141         final List<Class<?>> list = new ArrayList<>();
142         List<String> result = ClassUtils.convertClassesToClassNames(list);
143         assertEquals(0, result.size());
144 
145         list.add(String.class);
146         list.add(null);
147         list.add(Object.class);
148         result = ClassUtils.convertClassesToClassNames(list);
149         assertEquals(3, result.size());
150         assertEquals("java.lang.String", result.get(0));
151         assertNull(result.get(1));
152         assertEquals(OBJECT_CANONICAL_NAME, result.get(2));
153 
154         @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element
155         final List<Object> olist = (List<Object>) (List<?>) list;
156         olist.add(new Object());
157         assertThrows(ClassCastException.class, () -> ClassUtils.convertClassesToClassNames(list), "Should not have been able to convert list");
158         assertNull(ClassUtils.convertClassesToClassNames(null));
159     }
160 
161     @Test
162     void test_convertClassNamesToClasses_List() {
163         final List<String> list = new ArrayList<>();
164         List<Class<?>> result = ClassUtils.convertClassNamesToClasses(list);
165         assertEquals(0, result.size());
166 
167         list.add("java.lang.String");
168         list.add("java.lang.xxx");
169         list.add(OBJECT_CANONICAL_NAME);
170         result = ClassUtils.convertClassNamesToClasses(list);
171         assertEquals(3, result.size());
172         assertEquals(String.class, result.get(0));
173         assertNull(result.get(1));
174         assertEquals(Object.class, result.get(2));
175 
176         @SuppressWarnings("unchecked") // test what happens when non-generic code adds wrong type of element
177         final List<Object> olist = (List<Object>) (List<?>) list;
178         olist.add(new Object());
179         assertThrows(ClassCastException.class, () -> ClassUtils.convertClassNamesToClasses(list), "Should not have been able to convert list");
180         assertNull(ClassUtils.convertClassNamesToClasses(null));
181     }
182 
183     @Test
184     void test_getAbbreviatedName_Class() {
185         assertEquals("", ClassUtils.getAbbreviatedName((Class<?>) null, 1));
186         assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 1));
187         assertEquals("j.l.String", ClassUtils.getAbbreviatedName(String.class, 5));
188         assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName(ClassUtils.class, 18));
189         assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 13));
190         assertEquals("j.lang.String", ClassUtils.getAbbreviatedName(String.class, 15));
191         assertEquals("java.lang.String", ClassUtils.getAbbreviatedName(String.class, 20));
192     }
193 
194     @Test
195     void test_getAbbreviatedName_Class_Array() {
196         assertEquals("[Lj.l.String;", ClassUtils.getAbbreviatedName(String[].class, 1));
197         assertEquals("[[Lj.l.String;", ClassUtils.getAbbreviatedName(String[][].class, 1));
198         assertEquals("[Lj.lang.String;", ClassUtils.getAbbreviatedName(String[].class, "[Lj.lang.String;".length()));
199         assertEquals("[Lj.l.String;", ClassUtils.getAbbreviatedName(String[].class, "[Lj.lang.String;".length() - 1));
200         assertEquals("[Ljava.lang.String;", ClassUtils.getAbbreviatedName(String[].class, 30));
201         assertEquals("[Lo.a.c.l.ClassUtils;", ClassUtils.getAbbreviatedName(ClassUtils[].class, 21));
202         assertEquals("[I", ClassUtils.getAbbreviatedName(int[].class, 1));
203         assertEquals("[[I", ClassUtils.getAbbreviatedName(int[][].class, 1));
204         assertEquals("[Lj.l.String;", ClassUtils.getAbbreviatedName("[Ljava.lang.String;", 1));
205     }
206 
207     @Test
208     /** When the desired length is negative then exception is thrown */
209     void test_getAbbreviatedName_Class_NegativeLen() {
210         assertIllegalArgumentException(() -> ClassUtils.getAbbreviatedName(String.class, -10));
211     }
212 
213     @Test
214     /** When the desired length is zero then exception is thrown */
215     void test_getAbbreviatedName_Class_ZeroLen() {
216         assertIllegalArgumentException(() -> ClassUtils.getAbbreviatedName(String.class, 0));
217     }
218 
219     @Test
220     void test_getAbbreviatedName_String() {
221         assertEquals("", ClassUtils.getAbbreviatedName((String) null, 1));
222         assertEquals("", ClassUtils.getAbbreviatedName("", 1));
223         assertEquals("WithoutPackage", ClassUtils.getAbbreviatedName("WithoutPackage", 1));
224         assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", 1));
225         assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName("org.apache.commons.lang3.ClassUtils", 18));
226         assertEquals("org.apache.commons.lang3.ClassUtils",
227             ClassUtils.getAbbreviatedName("org.apache.commons.lang3.ClassUtils", "org.apache.commons.lang3.ClassUtils".length()));
228         assertEquals("o.a.c.l.ClassUtils", ClassUtils.getAbbreviatedName("o.a.c.l.ClassUtils", 18));
229         assertEquals("o..c.l.ClassUtils", ClassUtils.getAbbreviatedName("o..c.l.ClassUtils", 18));
230         assertEquals(".", ClassUtils.getAbbreviatedName(".", 18));
231         assertEquals(".", ClassUtils.getAbbreviatedName(".", 1));
232         assertEquals("..", ClassUtils.getAbbreviatedName("..", 1));
233         assertEquals("...", ClassUtils.getAbbreviatedName("...", 2));
234         assertEquals("...", ClassUtils.getAbbreviatedName("...", 3));
235         assertEquals("java.lang.String", ClassUtils.getAbbreviatedName("java.lang.String", Integer.MAX_VALUE));
236         assertEquals("j.lang.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.lang.String".length()));
237         assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.lang.String".length() - 1));
238         assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.l.String".length()));
239         assertEquals("j.l.String", ClassUtils.getAbbreviatedName("java.lang.String", "j.l.String".length() - 1));
240     }
241 
242     /**
243      * Test that in case the required length is larger than the name and thus there is no need for any shortening then the
244      * returned string object is the same as the one passed as argument. Note, however, that this is tested as an internal
245      * implementation detail, but it is not a guaranteed feature of the implementation.
246      */
247     @Test
248     /** When the length hint is longer than the actual length then the same String object is returned */
249     void test_getAbbreviatedName_TooLongHint() {
250         final String className = "java.lang.String";
251         assertSame(className, ClassUtils.getAbbreviatedName(className, className.length() + 1));
252         assertSame(className, ClassUtils.getAbbreviatedName(className, className.length()));
253     }
254 
255     @Test
256     void test_getAllInterfaces_Class() {
257         final List<?> list = ClassUtils.getAllInterfaces(CY.class);
258         assertEquals(6, list.size());
259         assertEquals(IB.class, list.get(0));
260         assertEquals(IC.class, list.get(1));
261         assertEquals(ID.class, list.get(2));
262         assertEquals(IE.class, list.get(3));
263         assertEquals(IF.class, list.get(4));
264         assertEquals(IA.class, list.get(5));
265 
266         assertNull(ClassUtils.getAllInterfaces(null));
267     }
268 
269     @Test
270     void test_getAllSuperclasses_Class() {
271         final List<?> list = ClassUtils.getAllSuperclasses(CY.class);
272         assertEquals(2, list.size());
273         assertEquals(CX.class, list.get(0));
274         assertEquals(Object.class, list.get(1));
275 
276         assertNull(ClassUtils.getAllSuperclasses(null));
277     }
278 
279     @Test
280     void test_getCanonicalName_Class() {
281         assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getCanonicalName(ClassUtils.class));
282         assertEquals("java.util.Map.Entry", ClassUtils.getCanonicalName(Map.Entry.class));
283         assertEquals("", ClassUtils.getCanonicalName((Class<?>) null));
284 
285         assertEquals("java.lang.String[]", ClassUtils.getCanonicalName(String[].class));
286         assertEquals("java.util.Map.Entry[]", ClassUtils.getCanonicalName(Map.Entry[].class));
287 
288         // Primitives
289         assertEquals("boolean", ClassUtils.getCanonicalName(boolean.class));
290         assertEquals("byte", ClassUtils.getCanonicalName(byte.class));
291         assertEquals("char", ClassUtils.getCanonicalName(char.class));
292         assertEquals("short", ClassUtils.getCanonicalName(short.class));
293         assertEquals("int", ClassUtils.getCanonicalName(int.class));
294         assertEquals("long", ClassUtils.getCanonicalName(long.class));
295         assertEquals("float", ClassUtils.getCanonicalName(float.class));
296         assertEquals("double", ClassUtils.getCanonicalName(double.class));
297 
298         // Primitive Arrays
299         assertEquals("boolean[]", ClassUtils.getCanonicalName(boolean[].class));
300         assertEquals("byte[]", ClassUtils.getCanonicalName(byte[].class));
301         assertEquals("char[]", ClassUtils.getCanonicalName(char[].class));
302         assertEquals("short[]", ClassUtils.getCanonicalName(short[].class));
303         assertEquals("int[]", ClassUtils.getCanonicalName(int[].class));
304         assertEquals("long[]", ClassUtils.getCanonicalName(long[].class));
305         assertEquals("float[]", ClassUtils.getCanonicalName(float[].class));
306         assertEquals("double[]", ClassUtils.getCanonicalName(double[].class));
307 
308         // Arrays of arrays of ...
309         assertEquals("java.lang.String[][]", ClassUtils.getCanonicalName(String[][].class));
310         assertEquals("java.lang.String[][][]", ClassUtils.getCanonicalName(String[][][].class));
311         assertEquals("java.lang.String[][][][]", ClassUtils.getCanonicalName(String[][][][].class));
312 
313         // Inner types
314         final class Named {
315             // empty
316         }
317         assertEquals(StringUtils.EMPTY, ClassUtils.getCanonicalName(new Object() {
318             // empty
319         }.getClass()));
320         assertEquals(StringUtils.EMPTY, ClassUtils.getCanonicalName(Named.class));
321         assertEquals("org.apache.commons.lang3.ClassUtilsTest.Inner", ClassUtils.getCanonicalName(Inner.class));
322     }
323 
324     @Test
325     void test_getCanonicalName_Class_String() {
326         assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getCanonicalName(ClassUtils.class, "X"));
327         assertEquals("java.util.Map.Entry", ClassUtils.getCanonicalName(Map.Entry.class, "X"));
328         assertEquals("X", ClassUtils.getCanonicalName((Class<?>) null, "X"));
329 
330         assertEquals("java.lang.String[]", ClassUtils.getCanonicalName(String[].class, "X"));
331         assertEquals("java.util.Map.Entry[]", ClassUtils.getCanonicalName(Map.Entry[].class, "X"));
332 
333         // Primitives
334         assertEquals("boolean", ClassUtils.getCanonicalName(boolean.class, "X"));
335         assertEquals("byte", ClassUtils.getCanonicalName(byte.class, "X"));
336         assertEquals("char", ClassUtils.getCanonicalName(char.class, "X"));
337         assertEquals("short", ClassUtils.getCanonicalName(short.class, "X"));
338         assertEquals("int", ClassUtils.getCanonicalName(int.class, "X"));
339         assertEquals("long", ClassUtils.getCanonicalName(long.class, "X"));
340         assertEquals("float", ClassUtils.getCanonicalName(float.class, "X"));
341         assertEquals("double", ClassUtils.getCanonicalName(double.class, "X"));
342 
343         // Primitive Arrays
344         assertEquals("boolean[]", ClassUtils.getCanonicalName(boolean[].class, "X"));
345         assertEquals("byte[]", ClassUtils.getCanonicalName(byte[].class, "X"));
346         assertEquals("char[]", ClassUtils.getCanonicalName(char[].class, "X"));
347         assertEquals("short[]", ClassUtils.getCanonicalName(short[].class, "X"));
348         assertEquals("int[]", ClassUtils.getCanonicalName(int[].class, "X"));
349         assertEquals("long[]", ClassUtils.getCanonicalName(long[].class, "X"));
350         assertEquals("float[]", ClassUtils.getCanonicalName(float[].class, "X"));
351         assertEquals("double[]", ClassUtils.getCanonicalName(double[].class, "X"));
352 
353         // Arrays of arrays of ...
354         assertEquals("java.lang.String[][]", ClassUtils.getCanonicalName(String[][].class, "X"));
355         assertEquals("java.lang.String[][][]", ClassUtils.getCanonicalName(String[][][].class, "X"));
356         assertEquals("java.lang.String[][][][]", ClassUtils.getCanonicalName(String[][][][].class, "X"));
357 
358         // Inner types
359         final class Named {
360             // empty
361         }
362         assertEquals("X", ClassUtils.getCanonicalName(new Object() {
363             // empty
364         }.getClass(), "X"));
365         assertEquals("X", ClassUtils.getCanonicalName(Named.class, "X"));
366         assertEquals("org.apache.commons.lang3.ClassUtilsTest.Inner", ClassUtils.getCanonicalName(Inner.class, "X"));
367         assertEquals("X", ClassUtils.getCanonicalName((Object) null, "X"));
368         assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getCanonicalName(new Object()));
369     }
370 
371     @Test
372     void test_getClass() {
373        // assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(ClassLoader.class, "@"));
374     }
375 
376     @Test
377     void test_getName_Class() {
378         assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(ClassUtils.class));
379         assertEquals("java.util.Map$Entry", ClassUtils.getName(Map.Entry.class));
380         assertEquals("", ClassUtils.getName((Class<?>) null));
381 
382         assertEquals("[Ljava.lang.String;", ClassUtils.getName(String[].class));
383         assertEquals("[Ljava.util.Map$Entry;", ClassUtils.getName(Map.Entry[].class));
384 
385         // Primitives
386         assertEquals("boolean", ClassUtils.getName(boolean.class));
387         assertEquals("byte", ClassUtils.getName(byte.class));
388         assertEquals("char", ClassUtils.getName(char.class));
389         assertEquals("short", ClassUtils.getName(short.class));
390         assertEquals("int", ClassUtils.getName(int.class));
391         assertEquals("long", ClassUtils.getName(long.class));
392         assertEquals("float", ClassUtils.getName(float.class));
393         assertEquals("double", ClassUtils.getName(double.class));
394 
395         // Primitive Arrays
396         assertEquals("[Z", ClassUtils.getName(boolean[].class));
397         assertEquals("[B", ClassUtils.getName(byte[].class));
398         assertEquals("[C", ClassUtils.getName(char[].class));
399         assertEquals("[S", ClassUtils.getName(short[].class));
400         assertEquals("[I", ClassUtils.getName(int[].class));
401         assertEquals("[J", ClassUtils.getName(long[].class));
402         assertEquals("[F", ClassUtils.getName(float[].class));
403         assertEquals("[D", ClassUtils.getName(double[].class));
404 
405         // Arrays of arrays of ...
406         assertEquals("[[Ljava.lang.String;", ClassUtils.getName(String[][].class));
407         assertEquals("[[[Ljava.lang.String;", ClassUtils.getName(String[][][].class));
408         assertEquals("[[[[Ljava.lang.String;", ClassUtils.getName(String[][][][].class));
409 
410         // Inner types
411         final class Named {
412             // empty
413         }
414         assertEquals("org.apache.commons.lang3.ClassUtilsTest$3", ClassUtils.getName(new Object() {
415             // empty
416         }.getClass()));
417         assertEquals("org.apache.commons.lang3.ClassUtilsTest$3Named", ClassUtils.getName(Named.class));
418         assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(Inner.class));
419         assertEquals(OBJECT_CANONICAL_NAME, ClassUtils.getName(new Object()));
420     }
421 
422     @Test
423     void test_getName_Object() {
424         assertEquals("org.apache.commons.lang3.ClassUtils", ClassUtils.getName(new ClassUtils(), "<null>"));
425         assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(new Inner(), "<null>"));
426         assertEquals("java.lang.String", ClassUtils.getName("hello", "<null>"));
427         assertEquals("<null>", ClassUtils.getName(null, "<null>"));
428 
429         // Inner types
430         final class Named {
431             // empty
432         }
433         assertEquals("org.apache.commons.lang3.ClassUtilsTest$4", ClassUtils.getName(new Object() {
434             // empty
435         }, "<null>"));
436         assertEquals("org.apache.commons.lang3.ClassUtilsTest$4Named", ClassUtils.getName(new Named(), "<null>"));
437         assertEquals("org.apache.commons.lang3.ClassUtilsTest$Inner", ClassUtils.getName(new Inner(), "<null>"));
438     }
439 
440     @Test
441     void test_getPackageCanonicalName_Class() {
442         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils.class));
443         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[].class));
444         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(ClassUtils[][].class));
445         assertEquals("", ClassUtils.getPackageCanonicalName(int[].class));
446         assertEquals("", ClassUtils.getPackageCanonicalName(int[][].class));
447 
448         // Inner types
449         final class Named {
450             // empty
451         }
452         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() {
453             // empty
454         }.getClass()));
455         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Named.class));
456         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(Inner.class));
457         assertEquals(StringUtils.EMPTY, ClassUtils.getPackageCanonicalName((Class<?>) null));
458     }
459 
460     @Test
461     void test_getPackageCanonicalName_Object() {
462         assertEquals("<null>", ClassUtils.getPackageCanonicalName(null, "<null>"));
463         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils(), "<null>"));
464         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0], "<null>"));
465         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new ClassUtils[0][0], "<null>"));
466         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0], "<null>"));
467         assertEquals("", ClassUtils.getPackageCanonicalName(new int[0][0], "<null>"));
468 
469         // Inner types
470         final class Named {
471             // empty
472         }
473         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() {
474             // empty
475         }, "<null>"));
476         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Named(), "<null>"));
477         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Inner(), "<null>"));
478     }
479 
480     @Test
481     void test_getPackageCanonicalName_String() {
482         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils"));
483         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;"));
484         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;"));
485         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Lorg.apache.commons.lang3.ClassUtils;"));
486         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[]"));
487         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][]"));
488         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtils[][][][][][][][][][][][][][][][]"));
489         assertEquals("", ClassUtils.getPackageCanonicalName("[I"));
490         assertEquals("", ClassUtils.getPackageCanonicalName("[[I"));
491         assertEquals("", ClassUtils.getPackageCanonicalName("int[]"));
492         assertEquals("", ClassUtils.getPackageCanonicalName("int[][]"));
493         // Inner types
494         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
495         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));
496         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner"));
497         assertEquals("a.b.c.D.e.f", ClassUtils.getPackageCanonicalName("a.b.c.D.e.f.D"));
498     }
499 
500     @Test
501     void test_getPackageName_Class() {
502         assertEquals("java.lang", ClassUtils.getPackageName(String.class));
503         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class));
504         assertEquals("", ClassUtils.getPackageName((Class<?>) null));
505         // LANG-535
506         assertEquals("java.lang", ClassUtils.getPackageName(String[].class));
507         // Primitive Arrays
508         assertEquals("", ClassUtils.getPackageName(boolean[].class));
509         assertEquals("", ClassUtils.getPackageName(byte[].class));
510         assertEquals("", ClassUtils.getPackageName(char[].class));
511         assertEquals("", ClassUtils.getPackageName(short[].class));
512         assertEquals("", ClassUtils.getPackageName(int[].class));
513         assertEquals("", ClassUtils.getPackageName(long[].class));
514         assertEquals("", ClassUtils.getPackageName(float[].class));
515         assertEquals("", ClassUtils.getPackageName(double[].class));
516         // Arrays of arrays of ...
517         assertEquals("java.lang", ClassUtils.getPackageName(String[][].class));
518         assertEquals("java.lang", ClassUtils.getPackageName(String[][][].class));
519         assertEquals("java.lang", ClassUtils.getPackageName(String[][][][].class));
520         // On-the-fly types
521         final class Named {
522             // empty
523         }
524         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() {
525             // empty
526         }.getClass()));
527         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(Named.class));
528         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Serializable() {
529             private static final long serialVersionUID = 1L;
530         }.getClass()));
531         assertEquals("java.util.function", ClassUtils.getPackageName(Function.identity().getClass()));
532     }
533 
534     @Test
535     void test_getPackageName_Object() {
536         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new ClassUtils(), "<null>"));
537         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Inner(), "<null>"));
538         assertEquals("<null>", ClassUtils.getPackageName(null, "<null>"));
539     }
540 
541     @Test
542     void test_getPackageName_String() {
543         assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(ClassUtils.class.getName()));
544         assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName()));
545         assertEquals("", ClassUtils.getPackageName((String) null));
546         assertEquals("", ClassUtils.getPackageName(""));
547     }
548 
549     @Test
550     void test_getShortCanonicalName_Class() {
551         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(ClassUtils.class));
552         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(ClassUtils[].class));
553         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(ClassUtils[][].class));
554         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class));
555         assertEquals("int[][]", ClassUtils.getShortCanonicalName(int[][].class));
556         assertEquals("int[][][][][][][][][][]", ClassUtils.getShortCanonicalName(int[][][][][][][][][][].class));
557 
558         // Inner types
559         final class Named {
560             // empty
561         }
562         assertEquals("", ClassUtils.getShortCanonicalName(new Object() {
563             // empty
564         }.getClass()));
565         // WARNING: this is fragile, implementation may change, naming is not guaranteed
566         assertEquals("", ClassUtils.getShortCanonicalName(Named.class));
567         assertEquals("Inner", ClassUtils.getShortCanonicalName(Inner.class));
568         assertEquals(StringUtils.EMPTY, ClassUtils.getShortCanonicalName((Class<?>) null));
569     }
570 
571     @Test
572     void test_getShortCanonicalName_Object() {
573         assertEquals("<null>", ClassUtils.getShortCanonicalName(null, "<null>"));
574         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName(new ClassUtils(), "<null>"));
575         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName(new ClassUtils[0], "<null>"));
576         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName(new ClassUtils[0][0], "<null>"));
577         assertEquals("int[]", ClassUtils.getShortCanonicalName(new int[0], "<null>"));
578         assertEquals("int[][]", ClassUtils.getShortCanonicalName(new int[0][0], "<null>"));
579         assertEquals("int[][][][][][][][][][]", ClassUtils.getShortCanonicalName(new int[0][0][0][0][0][0][0][0][0][0], "<null>"));
580 
581         // Inner types
582         final class Named {
583             // empty
584         }
585         assertEquals("", ClassUtils.getShortCanonicalName(new Object() {
586             // empty
587         }, "<null>"));
588         assertEquals("", ClassUtils.getShortCanonicalName(new Named(), "<null>"));
589         assertEquals("Inner", ClassUtils.getShortCanonicalName(new Inner(), "<null>"));
590     }
591 
592     @Test
593     void test_getShortCanonicalName_String() {
594         assertEquals("", ClassUtils.getShortCanonicalName((String) null));
595         assertEquals("Map.Entry", ClassUtils.getShortCanonicalName(java.util.Map.Entry.class.getName()));
596         assertEquals("Entry", ClassUtils.getShortCanonicalName(java.util.Map.Entry.class.getCanonicalName()));
597         assertEquals("ClassUtils", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils"));
598         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtils;"));
599         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("[[Lorg.apache.commons.lang3.ClassUtils;"));
600         assertEquals("ClassUtils[]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[]"));
601         assertEquals("ClassUtils[][]", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtils[][]"));
602         assertEquals("int[]", ClassUtils.getShortCanonicalName("[I"));
603         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class.getCanonicalName()));
604         assertEquals("int[]", ClassUtils.getShortCanonicalName(int[].class.getName()));
605         assertEquals("int[][]", ClassUtils.getShortCanonicalName("[[I"));
606         assertEquals("int[]", ClassUtils.getShortCanonicalName("int[]"));
607         assertEquals("int[][]", ClassUtils.getShortCanonicalName("int[][]"));
608         assertEquals("int[][][][][][][][][][][][]", ClassUtils.getShortCanonicalName("int[][][][][][][][][][][][]"));
609         // this is to demonstrate that the documentation and the naming of the methods
610         // uses the class name and canonical name totally mixed up, which cannot be
611         // fixed without backward compatibility break
612         assertEquals("int[]", int[].class.getCanonicalName());
613         assertEquals("[I", int[].class.getName());
614         assertIllegalArgumentException(() -> ClassUtils.getShortCanonicalName(StringUtils.repeat("[", 256) + "I"));
615         assertEquals("int" + StringUtils.repeat("[]", 255), ClassUtils.getShortCanonicalName(StringUtils.repeat("[", 255) + "I"));
616         // Inner types... the problem is that these are not canonical names, classes with this name do not even have canonical
617         // name
618         // WARNING: this is fragile, implementation may change, naming is not guaranteed
619         assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
620         // WARNING: this is fragile, implementation may change, naming is not guaranteed
621         assertEquals("ClassUtilsTest.5Named", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$5Named"));
622         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$Inner"));
623         // demonstrating what a canonical name is... it is a bigger issue to clean this up
624         assertEquals("org.apache.commons.lang3.ClassUtilsTest$11", new org.apache.commons.lang3.ClassUtilsTest() {
625         }.getClass().getName());
626         assertNull(new org.apache.commons.lang3.ClassUtilsTest() {
627         }.getClass().getCanonicalName());
628         assertEquals("String[]", ClassUtils.getShortCanonicalName(String[].class.getName()));
629         assertEquals("String[]", ClassUtils.getShortCanonicalName(String[].class.getCanonicalName()));
630         assertEquals("String[]", ClassUtils.getShortCanonicalName("String[]"));
631         // Note that we throw IllegalArgumentException for the following bad inputs:
632         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName(""));
633         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("["));
634         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[]"));
635         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[;"));
636         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[];"));
637         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName(" "));
638         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[$"));
639         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[$a"));
640         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[["));
641         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[[L"));
642         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[org.apache.commons.lang3.ClassUtilsTest"));
643         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getShortCanonicalName("[Lorg.apache.commons.lang3.ClassUtilsTest"));
644     }
645 
646     @Test
647     void test_getShortClassName_Class() {
648         assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class));
649         assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class));
650         assertEquals("", ClassUtils.getShortClassName((Class<?>) null));
651 
652         // LANG-535
653         assertEquals("String[]", ClassUtils.getShortClassName(String[].class));
654         assertEquals("Map.Entry[]", ClassUtils.getShortClassName(Map.Entry[].class));
655 
656         // Primitives
657         assertEquals("boolean", ClassUtils.getShortClassName(boolean.class));
658         assertEquals("byte", ClassUtils.getShortClassName(byte.class));
659         assertEquals("char", ClassUtils.getShortClassName(char.class));
660         assertEquals("short", ClassUtils.getShortClassName(short.class));
661         assertEquals("int", ClassUtils.getShortClassName(int.class));
662         assertEquals("long", ClassUtils.getShortClassName(long.class));
663         assertEquals("float", ClassUtils.getShortClassName(float.class));
664         assertEquals("double", ClassUtils.getShortClassName(double.class));
665 
666         // Primitive Arrays
667         assertEquals("boolean[]", ClassUtils.getShortClassName(boolean[].class));
668         assertEquals("byte[]", ClassUtils.getShortClassName(byte[].class));
669         assertEquals("char[]", ClassUtils.getShortClassName(char[].class));
670         assertEquals("short[]", ClassUtils.getShortClassName(short[].class));
671         assertEquals("int[]", ClassUtils.getShortClassName(int[].class));
672         assertEquals("long[]", ClassUtils.getShortClassName(long[].class));
673         assertEquals("float[]", ClassUtils.getShortClassName(float[].class));
674         assertEquals("double[]", ClassUtils.getShortClassName(double[].class));
675 
676         // Arrays of arrays of ...
677         assertEquals("String[][]", ClassUtils.getShortClassName(String[][].class));
678         assertEquals("String[][][]", ClassUtils.getShortClassName(String[][][].class));
679         assertEquals("String[][][][]", ClassUtils.getShortClassName(String[][][][].class));
680 
681         // Inner types
682         final class Named {
683             // empty
684         }
685         // WARNING: this is fragile, implementation may change, naming is not guaranteed
686         assertEquals("ClassUtilsTest.13", ClassUtils.getShortClassName(new Object() {
687             // empty
688         }.getClass()));
689         // WARNING: this is fragile, implementation may change, naming is not guaranteed
690         assertEquals("ClassUtilsTest.10Named", ClassUtils.getShortClassName(Named.class));
691         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(Inner.class));
692     }
693 
694     @Test
695     void test_getShortClassName_Object() {
696         assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>"));
697         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
698         assertEquals("String", ClassUtils.getShortClassName("hello", "<null>"));
699         assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>"));
700 
701         // Inner types
702         final class Named {
703             // empty
704         }
705         // WARNING: this is fragile, implementation may change, naming is not guaranteed
706         assertEquals("ClassUtilsTest.14", ClassUtils.getShortClassName(new Object() {
707             // empty
708         }, "<null>"));
709         // WARNING: this is fragile, implementation may change, naming is not guaranteed
710         assertEquals("ClassUtilsTest.11Named", ClassUtils.getShortClassName(new Named(), "<null>"));
711         assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
712     }
713 
714     @Test
715     void test_getShortClassName_String() {
716         assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName()));
717         assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName()));
718         assertEquals("", ClassUtils.getShortClassName((String) null));
719         assertEquals("", ClassUtils.getShortClassName(""));
720     }
721 
722     @Test
723     void test_getSimpleName_Class() {
724         assertEquals("ClassUtils", ClassUtils.getSimpleName(ClassUtils.class));
725         assertEquals("Entry", ClassUtils.getSimpleName(Map.Entry.class));
726         assertEquals("", ClassUtils.getSimpleName(null));
727 
728         // LANG-535
729         assertEquals("String[]", ClassUtils.getSimpleName(String[].class));
730         assertEquals("Entry[]", ClassUtils.getSimpleName(Map.Entry[].class));
731 
732         // Primitives
733         assertEquals("boolean", ClassUtils.getSimpleName(boolean.class));
734         assertEquals("byte", ClassUtils.getSimpleName(byte.class));
735         assertEquals("char", ClassUtils.getSimpleName(char.class));
736         assertEquals("short", ClassUtils.getSimpleName(short.class));
737         assertEquals("int", ClassUtils.getSimpleName(int.class));
738         assertEquals("long", ClassUtils.getSimpleName(long.class));
739         assertEquals("float", ClassUtils.getSimpleName(float.class));
740         assertEquals("double", ClassUtils.getSimpleName(double.class));
741 
742         // Primitive Arrays
743         assertEquals("boolean[]", ClassUtils.getSimpleName(boolean[].class));
744         assertEquals("byte[]", ClassUtils.getSimpleName(byte[].class));
745         assertEquals("char[]", ClassUtils.getSimpleName(char[].class));
746         assertEquals("short[]", ClassUtils.getSimpleName(short[].class));
747         assertEquals("int[]", ClassUtils.getSimpleName(int[].class));
748         assertEquals("long[]", ClassUtils.getSimpleName(long[].class));
749         assertEquals("float[]", ClassUtils.getSimpleName(float[].class));
750         assertEquals("double[]", ClassUtils.getSimpleName(double[].class));
751 
752         // Arrays of arrays of ...
753         assertEquals("String[][]", ClassUtils.getSimpleName(String[][].class));
754         assertEquals("String[][][]", ClassUtils.getSimpleName(String[][][].class));
755         assertEquals("String[][][][]", ClassUtils.getSimpleName(String[][][][].class));
756 
757         // On-the-fly types
758         final class Named {
759             // empty
760         }
761         assertEquals("", ClassUtils.getSimpleName(new Object() {
762             // empty
763         }.getClass()));
764         assertEquals("Named", ClassUtils.getSimpleName(Named.class));
765     }
766 
767     @Test
768     void test_getSimpleName_Object() {
769         assertEquals("ClassUtils", ClassUtils.getSimpleName(new ClassUtils()));
770         assertEquals("Inner", ClassUtils.getSimpleName(new Inner()));
771         assertEquals("String", ClassUtils.getSimpleName("hello"));
772         assertEquals(StringUtils.EMPTY, ClassUtils.getSimpleName(null));
773         assertEquals(StringUtils.EMPTY, ClassUtils.getSimpleName(null));
774     }
775 
776     @Test
777     void test_getSimpleName_Object_String() {
778         assertEquals("ClassUtils", ClassUtils.getSimpleName(new ClassUtils(), "<null>"));
779         assertEquals("Inner", ClassUtils.getSimpleName(new Inner(), "<null>"));
780         assertEquals("String", ClassUtils.getSimpleName("hello", "<null>"));
781         assertEquals("<null>", ClassUtils.getSimpleName(null, "<null>"));
782         assertNull(ClassUtils.getSimpleName(null, null));
783     }
784 
785     @Test
786     void test_isAssignable() {
787         assertFalse(ClassUtils.isAssignable((Class<?>) null, null));
788         assertFalse(ClassUtils.isAssignable(String.class, null));
789 
790         assertTrue(ClassUtils.isAssignable(null, Object.class));
791         assertTrue(ClassUtils.isAssignable(null, Integer.class));
792         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE));
793         assertTrue(ClassUtils.isAssignable(String.class, Object.class));
794         assertTrue(ClassUtils.isAssignable(String.class, String.class));
795         assertFalse(ClassUtils.isAssignable(Object.class, String.class));
796 
797         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class));
798         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class));
799         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE));
800         assertTrue(ClassUtils.isAssignable(Integer.class, Object.class));
801         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
802         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class));
803         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class));
804         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Object.class));
805         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE));
806         assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class));
807         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE));
808         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class));
809     }
810 
811     @Test
812     void test_isAssignable_Autoboxing() {
813         assertFalse(ClassUtils.isAssignable((Class<?>) null, null, true));
814         assertFalse(ClassUtils.isAssignable(String.class, null, true));
815         assertTrue(ClassUtils.isAssignable(null, Object.class, true));
816         assertTrue(ClassUtils.isAssignable(null, Integer.class, true));
817         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, true));
818         assertTrue(ClassUtils.isAssignable(String.class, Object.class, true));
819         assertTrue(ClassUtils.isAssignable(String.class, String.class, true));
820         assertFalse(ClassUtils.isAssignable(Object.class, String.class, true));
821         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.class, true));
822         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Object.class, true));
823         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true));
824         assertTrue(ClassUtils.isAssignable(Integer.class, Object.class, true));
825         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, true));
826         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, true));
827         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, true));
828         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true));
829         assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, true));
830         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, true));
831         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, true));
832     }
833 
834     @Test
835     void test_isAssignable_ClassArray_ClassArray() {
836         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
837         final Class<?>[] array1 = new Class[] {Object.class};
838         final Class<?>[] array1s = new Class[] {String.class};
839         final Class<?>[] array0 = new Class[] {};
840         final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE};
841         final Class<?>[] arrayWrappers = {Integer.class, Boolean.class};
842 
843         assertFalse(ClassUtils.isAssignable(array1, array2));
844         assertFalse(ClassUtils.isAssignable(null, array2));
845         assertTrue(ClassUtils.isAssignable(null, array0));
846         assertTrue(ClassUtils.isAssignable(array0, array0));
847         assertTrue(ClassUtils.isAssignable(array0, (Class<?>[]) null)); // explicit cast to avoid warning
848         assertTrue(ClassUtils.isAssignable(null, (Class<?>[]) null)); // explicit cast to avoid warning
849 
850         assertFalse(ClassUtils.isAssignable(array1, array1s));
851         assertTrue(ClassUtils.isAssignable(array1s, array1s));
852         assertTrue(ClassUtils.isAssignable(array1s, array1));
853 
854         assertTrue(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers));
855         assertTrue(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives));
856         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1));
857         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1));
858         assertTrue(ClassUtils.isAssignable(arrayPrimitives, array2));
859         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2));
860     }
861 
862     @Test
863     void test_isAssignable_ClassArray_ClassArray_Autoboxing() {
864         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
865         final Class<?>[] array1 = new Class[] {Object.class};
866         final Class<?>[] array1s = new Class[] {String.class};
867         final Class<?>[] array0 = new Class[] {};
868         final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE};
869         final Class<?>[] arrayWrappers = {Integer.class, Boolean.class};
870 
871         assertFalse(ClassUtils.isAssignable(array1, array2, true));
872         assertFalse(ClassUtils.isAssignable(null, array2, true));
873         assertTrue(ClassUtils.isAssignable(null, array0, true));
874         assertTrue(ClassUtils.isAssignable(array0, array0, true));
875         assertTrue(ClassUtils.isAssignable(array0, null, true));
876         assertTrue(ClassUtils.isAssignable((Class[]) null, null, true));
877 
878         assertFalse(ClassUtils.isAssignable(array1, array1s, true));
879         assertTrue(ClassUtils.isAssignable(array1s, array1s, true));
880         assertTrue(ClassUtils.isAssignable(array1s, array1, true));
881 
882         assertTrue(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, true));
883         assertTrue(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, true));
884         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, true));
885         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, true));
886         assertTrue(ClassUtils.isAssignable(arrayPrimitives, array2, true));
887         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, true));
888     }
889 
890     @Test
891     void test_isAssignable_ClassArray_ClassArray_NoAutoboxing() {
892         final Class<?>[] array2 = new Class[] {Object.class, Object.class};
893         final Class<?>[] array1 = new Class[] {Object.class};
894         final Class<?>[] array1s = new Class[] {String.class};
895         final Class<?>[] array0 = new Class[] {};
896         final Class<?>[] arrayPrimitives = {Integer.TYPE, Boolean.TYPE};
897         final Class<?>[] arrayWrappers = {Integer.class, Boolean.class};
898 
899         assertFalse(ClassUtils.isAssignable(array1, array2, false));
900         assertFalse(ClassUtils.isAssignable(null, array2, false));
901         assertTrue(ClassUtils.isAssignable(null, array0, false));
902         assertTrue(ClassUtils.isAssignable(array0, array0, false));
903         assertTrue(ClassUtils.isAssignable(array0, null, false));
904         assertTrue(ClassUtils.isAssignable((Class[]) null, null, false));
905 
906         assertFalse(ClassUtils.isAssignable(array1, array1s, false));
907         assertTrue(ClassUtils.isAssignable(array1s, array1s, false));
908         assertTrue(ClassUtils.isAssignable(array1s, array1, false));
909 
910         assertFalse(ClassUtils.isAssignable(arrayPrimitives, arrayWrappers, false));
911         assertFalse(ClassUtils.isAssignable(arrayWrappers, arrayPrimitives, false));
912         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array1, false));
913         assertFalse(ClassUtils.isAssignable(arrayWrappers, array1, false));
914         assertTrue(ClassUtils.isAssignable(arrayWrappers, array2, false));
915         assertFalse(ClassUtils.isAssignable(arrayPrimitives, array2, false));
916     }
917 
918     @Test
919     void test_isAssignable_DefaultUnboxing_Widening() {
920         // test byte conversions
921         assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE), "byte -> char");
922         assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE), "byte -> byte");
923         assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE), "byte -> short");
924         assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE), "byte -> int");
925         assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE), "byte -> long");
926         assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE), "byte -> float");
927         assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE), "byte -> double");
928         assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE), "byte -> boolean");
929 
930         // test short conversions
931         assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE), "short -> char");
932         assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE), "short -> byte");
933         assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE), "short -> short");
934         assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE), "short -> int");
935         assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE), "short -> long");
936         assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE), "short -> float");
937         assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE), "short -> double");
938         assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE), "short -> boolean");
939 
940         // test char conversions
941         assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE), "char -> char");
942         assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE), "char -> byte");
943         assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE), "char -> short");
944         assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE), "char -> int");
945         assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE), "char -> long");
946         assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE), "char -> float");
947         assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE), "char -> double");
948         assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE), "char -> boolean");
949 
950         // test int conversions
951         assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE), "int -> char");
952         assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE), "int -> byte");
953         assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE), "int -> short");
954         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE), "int -> int");
955         assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE), "int -> long");
956         assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE), "int -> float");
957         assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE), "int -> double");
958         assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE), "int -> boolean");
959 
960         // test long conversions
961         assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE), "long -> char");
962         assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE), "long -> byte");
963         assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE), "long -> short");
964         assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE), "long -> int");
965         assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE), "long -> long");
966         assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE), "long -> float");
967         assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE), "long -> double");
968         assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE), "long -> boolean");
969 
970         // test float conversions
971         assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE), "float -> char");
972         assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE), "float -> byte");
973         assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE), "float -> short");
974         assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE), "float -> int");
975         assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE), "float -> long");
976         assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE), "float -> float");
977         assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE), "float -> double");
978         assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE), "float -> boolean");
979 
980         // test double conversions
981         assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE), "double -> char");
982         assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE), "double -> byte");
983         assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE), "double -> short");
984         assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE), "double -> int");
985         assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE), "double -> long");
986         assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE), "double -> float");
987         assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE), "double -> double");
988         assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE), "double -> boolean");
989 
990         // test boolean conversions
991         assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE), "boolean -> char");
992         assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE), "boolean -> byte");
993         assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE), "boolean -> short");
994         assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE), "boolean -> int");
995         assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE), "boolean -> long");
996         assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE), "boolean -> float");
997         assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE), "boolean -> double");
998         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE), "boolean -> boolean");
999     }
1000 
1001     @Test
1002     void test_isAssignable_NoAutoboxing() {
1003         assertFalse(ClassUtils.isAssignable((Class<?>) null, null, false));
1004         assertFalse(ClassUtils.isAssignable(String.class, null, false));
1005         assertTrue(ClassUtils.isAssignable(null, Object.class, false));
1006         assertTrue(ClassUtils.isAssignable(null, Integer.class, false));
1007         assertFalse(ClassUtils.isAssignable(null, Integer.TYPE, false));
1008         assertTrue(ClassUtils.isAssignable(String.class, Object.class, false));
1009         assertTrue(ClassUtils.isAssignable(String.class, String.class, false));
1010         assertFalse(ClassUtils.isAssignable(Object.class, String.class, false));
1011         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Integer.class, false));
1012         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Object.class, false));
1013         assertFalse(ClassUtils.isAssignable(Integer.class, Integer.TYPE, false));
1014         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE, false));
1015         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.class, false));
1016         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Boolean.class, false));
1017         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Object.class, false));
1018         assertFalse(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, false));
1019         assertTrue(ClassUtils.isAssignable(Boolean.class, Object.class, false));
1020         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE, false));
1021         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.class, false));
1022     }
1023 
1024     @Test
1025     void test_isAssignable_Unboxing_Widening() {
1026         // test byte conversions
1027         assertFalse(ClassUtils.isAssignable(Byte.class, Character.TYPE, true), "byte -> char");
1028         assertTrue(ClassUtils.isAssignable(Byte.class, Byte.TYPE, true), "byte -> byte");
1029         assertTrue(ClassUtils.isAssignable(Byte.class, Short.TYPE, true), "byte -> short");
1030         assertTrue(ClassUtils.isAssignable(Byte.class, Integer.TYPE, true), "byte -> int");
1031         assertTrue(ClassUtils.isAssignable(Byte.class, Long.TYPE, true), "byte -> long");
1032         assertTrue(ClassUtils.isAssignable(Byte.class, Float.TYPE, true), "byte -> float");
1033         assertTrue(ClassUtils.isAssignable(Byte.class, Double.TYPE, true), "byte -> double");
1034         assertFalse(ClassUtils.isAssignable(Byte.class, Boolean.TYPE, true), "byte -> boolean");
1035         // test short conversions
1036         assertFalse(ClassUtils.isAssignable(Short.class, Character.TYPE, true), "short -> char");
1037         assertFalse(ClassUtils.isAssignable(Short.class, Byte.TYPE, true), "short -> byte");
1038         assertTrue(ClassUtils.isAssignable(Short.class, Short.TYPE, true), "short -> short");
1039         assertTrue(ClassUtils.isAssignable(Short.class, Integer.TYPE, true), "short -> int");
1040         assertTrue(ClassUtils.isAssignable(Short.class, Long.TYPE, true), "short -> long");
1041         assertTrue(ClassUtils.isAssignable(Short.class, Float.TYPE, true), "short -> float");
1042         assertTrue(ClassUtils.isAssignable(Short.class, Double.TYPE, true), "short -> double");
1043         assertFalse(ClassUtils.isAssignable(Short.class, Boolean.TYPE, true), "short -> boolean");
1044         // test char conversions
1045         assertTrue(ClassUtils.isAssignable(Character.class, Character.TYPE, true), "char -> char");
1046         assertFalse(ClassUtils.isAssignable(Character.class, Byte.TYPE, true), "char -> byte");
1047         assertFalse(ClassUtils.isAssignable(Character.class, Short.TYPE, true), "char -> short");
1048         assertTrue(ClassUtils.isAssignable(Character.class, Integer.TYPE, true), "char -> int");
1049         assertTrue(ClassUtils.isAssignable(Character.class, Long.TYPE, true), "char -> long");
1050         assertTrue(ClassUtils.isAssignable(Character.class, Float.TYPE, true), "char -> float");
1051         assertTrue(ClassUtils.isAssignable(Character.class, Double.TYPE, true), "char -> double");
1052         assertFalse(ClassUtils.isAssignable(Character.class, Boolean.TYPE, true), "char -> boolean");
1053         // test int conversions
1054         assertFalse(ClassUtils.isAssignable(Integer.class, Character.TYPE, true), "int -> char");
1055         assertFalse(ClassUtils.isAssignable(Integer.class, Byte.TYPE, true), "int -> byte");
1056         assertFalse(ClassUtils.isAssignable(Integer.class, Short.TYPE, true), "int -> short");
1057         assertTrue(ClassUtils.isAssignable(Integer.class, Integer.TYPE, true), "int -> int");
1058         assertTrue(ClassUtils.isAssignable(Integer.class, Long.TYPE, true), "int -> long");
1059         assertTrue(ClassUtils.isAssignable(Integer.class, Float.TYPE, true), "int -> float");
1060         assertTrue(ClassUtils.isAssignable(Integer.class, Double.TYPE, true), "int -> double");
1061         assertFalse(ClassUtils.isAssignable(Integer.class, Boolean.TYPE, true), "int -> boolean");
1062         // test long conversions
1063         assertFalse(ClassUtils.isAssignable(Long.class, Character.TYPE, true), "long -> char");
1064         assertFalse(ClassUtils.isAssignable(Long.class, Byte.TYPE, true), "long -> byte");
1065         assertFalse(ClassUtils.isAssignable(Long.class, Short.TYPE, true), "long -> short");
1066         assertFalse(ClassUtils.isAssignable(Long.class, Integer.TYPE, true), "long -> int");
1067         assertTrue(ClassUtils.isAssignable(Long.class, Long.TYPE, true), "long -> long");
1068         assertTrue(ClassUtils.isAssignable(Long.class, Float.TYPE, true), "long -> float");
1069         assertTrue(ClassUtils.isAssignable(Long.class, Double.TYPE, true), "long -> double");
1070         assertFalse(ClassUtils.isAssignable(Long.class, Boolean.TYPE, true), "long -> boolean");
1071         // test float conversions
1072         assertFalse(ClassUtils.isAssignable(Float.class, Character.TYPE, true), "float -> char");
1073         assertFalse(ClassUtils.isAssignable(Float.class, Byte.TYPE, true), "float -> byte");
1074         assertFalse(ClassUtils.isAssignable(Float.class, Short.TYPE, true), "float -> short");
1075         assertFalse(ClassUtils.isAssignable(Float.class, Integer.TYPE, true), "float -> int");
1076         assertFalse(ClassUtils.isAssignable(Float.class, Long.TYPE, true), "float -> long");
1077         assertTrue(ClassUtils.isAssignable(Float.class, Float.TYPE, true), "float -> float");
1078         assertTrue(ClassUtils.isAssignable(Float.class, Double.TYPE, true), "float -> double");
1079         assertFalse(ClassUtils.isAssignable(Float.class, Boolean.TYPE, true), "float -> boolean");
1080         // test double conversions
1081         assertFalse(ClassUtils.isAssignable(Double.class, Character.TYPE, true), "double -> char");
1082         assertFalse(ClassUtils.isAssignable(Double.class, Byte.TYPE, true), "double -> byte");
1083         assertFalse(ClassUtils.isAssignable(Double.class, Short.TYPE, true), "double -> short");
1084         assertFalse(ClassUtils.isAssignable(Double.class, Integer.TYPE, true), "double -> int");
1085         assertFalse(ClassUtils.isAssignable(Double.class, Long.TYPE, true), "double -> long");
1086         assertFalse(ClassUtils.isAssignable(Double.class, Float.TYPE, true), "double -> float");
1087         assertTrue(ClassUtils.isAssignable(Double.class, Double.TYPE, true), "double -> double");
1088         assertFalse(ClassUtils.isAssignable(Double.class, Boolean.TYPE, true), "double -> boolean");
1089         // test boolean conversions
1090         assertFalse(ClassUtils.isAssignable(Boolean.class, Character.TYPE, true), "boolean -> char");
1091         assertFalse(ClassUtils.isAssignable(Boolean.class, Byte.TYPE, true), "boolean -> byte");
1092         assertFalse(ClassUtils.isAssignable(Boolean.class, Short.TYPE, true), "boolean -> short");
1093         assertFalse(ClassUtils.isAssignable(Boolean.class, Integer.TYPE, true), "boolean -> int");
1094         assertFalse(ClassUtils.isAssignable(Boolean.class, Long.TYPE, true), "boolean -> long");
1095         assertFalse(ClassUtils.isAssignable(Boolean.class, Float.TYPE, true), "boolean -> float");
1096         assertFalse(ClassUtils.isAssignable(Boolean.class, Double.TYPE, true), "boolean -> double");
1097         assertTrue(ClassUtils.isAssignable(Boolean.class, Boolean.TYPE, true), "boolean -> boolean");
1098     }
1099 
1100     @Test
1101     void test_isAssignable_Widening() {
1102         // test byte conversions
1103         assertFalse(ClassUtils.isAssignable(Byte.TYPE, Character.TYPE), "byte -> char");
1104         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE), "byte -> byte");
1105         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Short.TYPE), "byte -> short");
1106         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE), "byte -> int");
1107         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Long.TYPE), "byte -> long");
1108         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Float.TYPE), "byte -> float");
1109         assertTrue(ClassUtils.isAssignable(Byte.TYPE, Double.TYPE), "byte -> double");
1110         assertFalse(ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE), "byte -> boolean");
1111         // test short conversions
1112         assertFalse(ClassUtils.isAssignable(Short.TYPE, Character.TYPE), "short -> char");
1113         assertFalse(ClassUtils.isAssignable(Short.TYPE, Byte.TYPE), "short -> byte");
1114         assertTrue(ClassUtils.isAssignable(Short.TYPE, Short.TYPE), "short -> short");
1115         assertTrue(ClassUtils.isAssignable(Short.TYPE, Integer.TYPE), "short -> int");
1116         assertTrue(ClassUtils.isAssignable(Short.TYPE, Long.TYPE), "short -> long");
1117         assertTrue(ClassUtils.isAssignable(Short.TYPE, Float.TYPE), "short -> float");
1118         assertTrue(ClassUtils.isAssignable(Short.TYPE, Double.TYPE), "short -> double");
1119         assertFalse(ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE), "short -> boolean");
1120         // test char conversions
1121         assertTrue(ClassUtils.isAssignable(Character.TYPE, Character.TYPE), "char -> char");
1122         assertFalse(ClassUtils.isAssignable(Character.TYPE, Byte.TYPE), "char -> byte");
1123         assertFalse(ClassUtils.isAssignable(Character.TYPE, Short.TYPE), "char -> short");
1124         assertTrue(ClassUtils.isAssignable(Character.TYPE, Integer.TYPE), "char -> int");
1125         assertTrue(ClassUtils.isAssignable(Character.TYPE, Long.TYPE), "char -> long");
1126         assertTrue(ClassUtils.isAssignable(Character.TYPE, Float.TYPE), "char -> float");
1127         assertTrue(ClassUtils.isAssignable(Character.TYPE, Double.TYPE), "char -> double");
1128         assertFalse(ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE), "char -> boolean");
1129         // test int conversions
1130         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Character.TYPE), "int -> char");
1131         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE), "int -> byte");
1132         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Short.TYPE), "int -> short");
1133         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE), "int -> int");
1134         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Long.TYPE), "int -> long");
1135         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Float.TYPE), "int -> float");
1136         assertTrue(ClassUtils.isAssignable(Integer.TYPE, Double.TYPE), "int -> double");
1137         assertFalse(ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE), "int -> boolean");
1138         // test long conversions
1139         assertFalse(ClassUtils.isAssignable(Long.TYPE, Character.TYPE), "long -> char");
1140         assertFalse(ClassUtils.isAssignable(Long.TYPE, Byte.TYPE), "long -> byte");
1141         assertFalse(ClassUtils.isAssignable(Long.TYPE, Short.TYPE), "long -> short");
1142         assertFalse(ClassUtils.isAssignable(Long.TYPE, Integer.TYPE), "long -> int");
1143         assertTrue(ClassUtils.isAssignable(Long.TYPE, Long.TYPE), "long -> long");
1144         assertTrue(ClassUtils.isAssignable(Long.TYPE, Float.TYPE), "long -> float");
1145         assertTrue(ClassUtils.isAssignable(Long.TYPE, Double.TYPE), "long -> double");
1146         assertFalse(ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE), "long -> boolean");
1147         // test float conversions
1148         assertFalse(ClassUtils.isAssignable(Float.TYPE, Character.TYPE), "float -> char");
1149         assertFalse(ClassUtils.isAssignable(Float.TYPE, Byte.TYPE), "float -> byte");
1150         assertFalse(ClassUtils.isAssignable(Float.TYPE, Short.TYPE), "float -> short");
1151         assertFalse(ClassUtils.isAssignable(Float.TYPE, Integer.TYPE), "float -> int");
1152         assertFalse(ClassUtils.isAssignable(Float.TYPE, Long.TYPE), "float -> long");
1153         assertTrue(ClassUtils.isAssignable(Float.TYPE, Float.TYPE), "float -> float");
1154         assertTrue(ClassUtils.isAssignable(Float.TYPE, Double.TYPE), "float -> double");
1155         assertFalse(ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE), "float -> boolean");
1156         // test double conversions
1157         assertFalse(ClassUtils.isAssignable(Double.TYPE, Character.TYPE), "double -> char");
1158         assertFalse(ClassUtils.isAssignable(Double.TYPE, Byte.TYPE), "double -> byte");
1159         assertFalse(ClassUtils.isAssignable(Double.TYPE, Short.TYPE), "double -> short");
1160         assertFalse(ClassUtils.isAssignable(Double.TYPE, Integer.TYPE), "double -> int");
1161         assertFalse(ClassUtils.isAssignable(Double.TYPE, Long.TYPE), "double -> long");
1162         assertFalse(ClassUtils.isAssignable(Double.TYPE, Float.TYPE), "double -> float");
1163         assertTrue(ClassUtils.isAssignable(Double.TYPE, Double.TYPE), "double -> double");
1164         assertFalse(ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE), "double -> boolean");
1165         // test boolean conversions
1166         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE), "boolean -> char");
1167         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE), "boolean -> byte");
1168         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE), "boolean -> short");
1169         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE), "boolean -> int");
1170         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE), "boolean -> long");
1171         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE), "boolean -> float");
1172         assertFalse(ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE), "boolean -> double");
1173         assertTrue(ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE), "boolean -> boolean");
1174     }
1175 
1176     @Test
1177     void test_isInnerClass_Class() {
1178         assertTrue(ClassUtils.isInnerClass(Inner.class));
1179         assertTrue(ClassUtils.isInnerClass(Map.Entry.class));
1180         assertTrue(ClassUtils.isInnerClass(new Cloneable() {
1181             // empty
1182         }.getClass()));
1183         assertFalse(ClassUtils.isInnerClass(this.getClass()));
1184         assertFalse(ClassUtils.isInnerClass(String.class));
1185         assertFalse(ClassUtils.isInnerClass(null));
1186     }
1187 
1188     @Test
1189     void testComparable() {
1190         final TreeMap<Class<?>, String> map = new TreeMap<>(ClassUtils.comparator());
1191         map.put(String.class, "lastEntry");
1192         map.toString();
1193         map.put(Character.class, "firstEntry");
1194         map.toString();
1195         assertEquals("firstEntry", map.firstEntry().getValue());
1196         assertEquals(Character.class, map.firstEntry().getKey());
1197         //
1198         assertEquals("lastEntry", map.lastEntry().getValue());
1199         assertEquals(String.class, map.lastEntry().getKey());
1200         //
1201         map.put(null, "null");
1202         map.toString();
1203         assertEquals("null", map.get(null));
1204     }
1205 
1206     @Test
1207     void testConstructor() {
1208         assertNotNull(new ClassUtils());
1209         final Constructor<?>[] cons = ClassUtils.class.getDeclaredConstructors();
1210         assertEquals(1, cons.length);
1211         assertTrue(Modifier.isPublic(cons[0].getModifiers()));
1212         assertTrue(Modifier.isPublic(ClassUtils.class.getModifiers()));
1213         assertFalse(Modifier.isFinal(ClassUtils.class.getModifiers()));
1214     }
1215 
1216     @ParameterizedTest
1217     @IntRangeSource(from = 1, to = 255)
1218     void testGetClassArray(final int dimensions) throws ClassNotFoundException {
1219         assertEquals(dimensions,
1220                 getDimension(ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" + StringUtils.repeat("[]", dimensions))));
1221         assertEquals(dimensions, getDimension(ClassUtils.getClass("java.lang.String" + StringUtils.repeat("[]", dimensions))));
1222     }
1223 
1224     @ParameterizedTest
1225     @IntRangeSource(from = 256, to = 300)
1226     void testGetClassArrayIllegal(final int dimensions) throws ClassNotFoundException {
1227         assertThrows(IllegalArgumentException.class, () -> assertEquals(dimensions,
1228                 getDimension(ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested" + StringUtils.repeat("[]", dimensions)))));
1229         assertThrows(IllegalArgumentException.class,
1230                 () -> assertEquals(dimensions, getDimension(ClassUtils.getClass("java.lang.String" + StringUtils.repeat("[]", dimensions)))));
1231     }
1232 
1233     @Test
1234     void testGetClassByNormalNameArrays() throws ClassNotFoundException {
1235         assertEquals(int[].class, ClassUtils.getClass("int[]"));
1236         assertEquals(long[].class, ClassUtils.getClass("long[]"));
1237         assertEquals(short[].class, ClassUtils.getClass("short[]"));
1238         assertEquals(byte[].class, ClassUtils.getClass("byte[]"));
1239         assertEquals(char[].class, ClassUtils.getClass("char[]"));
1240         assertEquals(float[].class, ClassUtils.getClass("float[]"));
1241         assertEquals(double[].class, ClassUtils.getClass("double[]"));
1242         assertEquals(boolean[].class, ClassUtils.getClass("boolean[]"));
1243         assertEquals(String[].class, ClassUtils.getClass("java.lang.String[]"));
1244         assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("java.util.Map.Entry[]"));
1245         assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("java.util.Map$Entry[]"));
1246         assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("[Ljava.util.Map.Entry;"));
1247         assertEquals(java.util.Map.Entry[].class, ClassUtils.getClass("[Ljava.util.Map$Entry;"));
1248         assertEquals(java.util.Map.Entry[][].class, ClassUtils.getClass("[[Ljava.util.Map$Entry;"));
1249     }
1250 
1251     @Test
1252     void testGetClassByNormalNameArrays2D() throws ClassNotFoundException {
1253         assertEquals(int[][].class, ClassUtils.getClass("int[][]"));
1254         assertEquals(long[][].class, ClassUtils.getClass("long[][]"));
1255         assertEquals(short[][].class, ClassUtils.getClass("short[][]"));
1256         assertEquals(byte[][].class, ClassUtils.getClass("byte[][]"));
1257         assertEquals(char[][].class, ClassUtils.getClass("char[][]"));
1258         assertEquals(float[][].class, ClassUtils.getClass("float[][]"));
1259         assertEquals(double[][].class, ClassUtils.getClass("double[][]"));
1260         assertEquals(boolean[][].class, ClassUtils.getClass("boolean[][]"));
1261         assertEquals(String[][].class, ClassUtils.getClass("java.lang.String[][]"));
1262     }
1263 
1264     @Test
1265     void testGetClassClassNotFound() throws Exception {
1266         assertGetClassThrowsClassNotFound("bool");
1267         assertGetClassThrowsClassNotFound("bool[]");
1268         assertGetClassThrowsClassNotFound("integer[]");
1269         assertGetClassThrowsClassNotFound("org.apache.commons.lang3.ClassUtilsTest.AClassThatCannotBeFound");
1270     }
1271 
1272     @Test
1273     void testGetClassInner() throws ClassNotFoundException {
1274         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested"));
1275         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested"));
1276         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested"));
1277         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested"));
1278         assertEquals(Inner.DeeplyNested[].class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested[]"));
1279         //
1280         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested", true));
1281         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested", true));
1282         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested", true));
1283         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass("org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested", true));
1284         //
1285         final ClassLoader classLoader = Inner.DeeplyNested.class.getClassLoader();
1286         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested"));
1287         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest.Inner$DeeplyNested"));
1288         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest$Inner$DeeplyNested"));
1289         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClass(classLoader, "org.apache.commons.lang3.ClassUtilsTest$Inner.DeeplyNested"));
1290     }
1291 
1292     @Test
1293     void testGetClassInvalidArguments() throws Exception {
1294         assertGetClassThrowsNullPointerException(null);
1295         assertGetClassThrowsClassNotFound("[][][]");
1296         assertGetClassThrowsClassNotFound("[[]");
1297         assertGetClassThrowsClassNotFound("[");
1298         assertGetClassThrowsClassNotFound("java.lang.String][");
1299         assertGetClassThrowsClassNotFound(".hello.world");
1300         assertGetClassThrowsClassNotFound("hello..world");
1301     }
1302 
1303     @ParameterizedTest
1304     @IntRangeSource(from = 65536, to = 65555)
1305     void testGetClassLengthIllegal(final int classNameLength) throws ClassNotFoundException {
1306         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass(StringUtils.repeat("a", classNameLength)));
1307         assertThrows(IllegalArgumentException.class, () -> assertEquals(classNameLength, ClassUtils.getClass(StringUtils.repeat("a.", classNameLength / 2))));
1308     }
1309 
1310     @Test
1311     void testGetClassLongestCheck() throws ClassNotFoundException {
1312         final String maxClassName = StringUtils.repeat("a", 65535);
1313         final String maxDimensions = StringUtils.repeat("[]", MAX_ARRAY_DIMENSIONS);
1314         final String maxOpens = StringUtils.repeat("[", MAX_ARRAY_DIMENSIONS);
1315         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClass(maxClassName));
1316         assertNotNull(ClassUtils.getClass("java.lang.String" + maxDimensions));
1317         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClass(maxClassName + maxDimensions));
1318         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClass(maxOpens + "L" + maxClassName + ";"));
1319         // maxOpens + 1
1320         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass(maxOpens + "[L" + maxClassName + ";"));
1321     }
1322 
1323     @Test
1324     void testGetClassRawPrimitives() throws ClassNotFoundException {
1325         assertEquals(int.class, ClassUtils.getClass("int"));
1326         assertEquals(long.class, ClassUtils.getClass("long"));
1327         assertEquals(short.class, ClassUtils.getClass("short"));
1328         assertEquals(byte.class, ClassUtils.getClass("byte"));
1329         assertEquals(char.class, ClassUtils.getClass("char"));
1330         assertEquals(float.class, ClassUtils.getClass("float"));
1331         assertEquals(double.class, ClassUtils.getClass("double"));
1332         assertEquals(boolean.class, ClassUtils.getClass("boolean"));
1333         assertEquals(void.class, ClassUtils.getClass("void"));
1334     }
1335 
1336     @Test
1337     void testGetClassStrict() throws Exception {
1338         // Same resolution as getClass for exact binary names.
1339         assertEquals(String.class, ClassUtils.getClassStrict("java.lang.String"));
1340         assertEquals(Inner.DeeplyNested.class, ClassUtils.getClassStrict("org.apache.commons.lang3.ClassUtilsTest.Inner.DeeplyNested"));
1341         final ClassLoader classLoader = Inner.DeeplyNested.class.getClassLoader();
1342         assertEquals(String.class, ClassUtils.getClassStrict(classLoader, "java.lang.String", true));
1343         // No whitespace normalization: whitespace-bearing spellings fail, matching Class.forName.
1344         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClassStrict(" java.lang.String"));
1345         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClassStrict("java .lang.String"));
1346         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClassStrict("java.lang\t.String"));
1347         assertThrows(ClassNotFoundException.class, () -> ClassUtils.getClassStrict(classLoader, "java.lang.String ", true));
1348         assertThrows(NullPointerException.class, () -> ClassUtils.getClassStrict(null));
1349         // The normalizing overloads keep their documented behavior.
1350         assertEquals(String.class, ClassUtils.getClass(" java.lang.String"));
1351         assertEquals(String.class, ClassUtils.getClass("java .lang.String"));
1352     }
1353 
1354     /**
1355      * Pre-patch: getClass("java.lang.String[]junk[]") silently returns String[][][][] (4 dims, because (24 - 16)/2 = 4 — junk is 4 chars). Post-patch: must
1356      * throw IllegalArgumentException.
1357      */
1358     @Test
1359     public void testGetClassStringMalformedMiddleJunkRejected() {
1360         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass("java.lang.String[]junk[]"));
1361     }
1362 
1363     /**
1364      * Mutation control: suffix ends with "[]" so the array-branch is entered, and the suffix from arrIdx contains only '[' and ']' chars but NOT as well-formed
1365      * pairs ("[]][]"). A char-class-only patch would accept this; the correct pair-validating patch must reject. Without this case, a weaker patch would still
1366      * pass.
1367      */
1368     @Test
1369     public void testGetClassStringMalformedUnpairedBracketsRejected() {
1370         assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass("java.lang.String[]][]"));
1371     }
1372 
1373     /**
1374      * Negative control: well-formed multi-dim array still resolves. Confirms the fix is minimal and does not over-reject.
1375      */
1376     @Test
1377     public void testGetClassStringWellFormedArrayStillResolves() throws Exception {
1378         assertNotNull(ClassUtils.getClass("java.lang.String[]"));
1379         assertNotNull(ClassUtils.getClass("java.lang.String[][]"));
1380     }
1381 
1382     @Test
1383     void testGetClassWithArrayClasses() throws Exception {
1384         assertGetClassReturnsClass(String[].class);
1385         assertGetClassReturnsClass(int[].class);
1386         assertGetClassReturnsClass(long[].class);
1387         assertGetClassReturnsClass(short[].class);
1388         assertGetClassReturnsClass(byte[].class);
1389         assertGetClassReturnsClass(char[].class);
1390         assertGetClassReturnsClass(float[].class);
1391         assertGetClassReturnsClass(double[].class);
1392         assertGetClassReturnsClass(boolean[].class);
1393     }
1394 
1395     @Test
1396     void testGetClassWithArrayClasses2D() throws Exception {
1397         assertGetClassReturnsClass(String[][].class);
1398         assertGetClassReturnsClass(int[][].class);
1399         assertGetClassReturnsClass(long[][].class);
1400         assertGetClassReturnsClass(short[][].class);
1401         assertGetClassReturnsClass(byte[][].class);
1402         assertGetClassReturnsClass(char[][].class);
1403         assertGetClassReturnsClass(float[][].class);
1404         assertGetClassReturnsClass(double[][].class);
1405         assertGetClassReturnsClass(boolean[][].class);
1406     }
1407 
1408     @Test
1409     void testGetComponentType() {
1410         final CX[] newArray = {};
1411         @SuppressWarnings("unchecked")
1412         final Class<CX[]> classCxArray = (Class<CX[]>) newArray.getClass();
1413         // No type-cast required.
1414         final Class<CX> componentType = ClassUtils.getComponentType(classCxArray);
1415         assertEquals(CX.class, componentType);
1416         assertNull(ClassUtils.getComponentType(null));
1417     }
1418 
1419     @Test
1420     void testGetPublicMethod() throws Exception {
1421         // Tests with Collections$UnmodifiableSet
1422         final Set<?> set = Collections.unmodifiableSet(new HashSet<>());
1423         final Method isEmptyMethod = ClassUtils.getPublicMethod(set.getClass(), "isEmpty");
1424         assertTrue(Modifier.isPublic(isEmptyMethod.getDeclaringClass().getModifiers()));
1425         assertTrue((Boolean) isEmptyMethod.invoke(set));
1426 
1427         // Tests with a public Class
1428         final Method toStringMethod = ClassUtils.getPublicMethod(Object.class, "toString");
1429         assertEquals(Object.class.getMethod("toString"), toStringMethod);
1430     }
1431 
1432     @Test
1433     void testHierarchyExcludingInterfaces() {
1434         final Iterator<Class<?>> iter = ClassUtils.hierarchy(StringParameterizedChild.class).iterator();
1435         assertEquals(StringParameterizedChild.class, iter.next());
1436         assertEquals(GenericParent.class, iter.next());
1437         assertEquals(Object.class, iter.next());
1438         assertFalse(iter.hasNext());
1439     }
1440 
1441     @Test
1442     void testHierarchyIncludingInterfaces() {
1443         final Iterator<Class<?>> iter = ClassUtils.hierarchy(StringParameterizedChild.class, Interfaces.INCLUDE).iterator();
1444         assertEquals(StringParameterizedChild.class, iter.next());
1445         assertEquals(GenericParent.class, iter.next());
1446         assertEquals(GenericConsumer.class, iter.next());
1447         assertEquals(Object.class, iter.next());
1448         assertFalse(iter.hasNext());
1449     }
1450 
1451     @Test
1452     void testIsPrimitiveOrWrapper() {
1453         // test primitive wrapper classes
1454         assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.class), "Boolean.class");
1455         assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.class), "Byte.class");
1456         assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.class), "Character.class");
1457         assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.class), "Short.class");
1458         assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.class), "Integer.class");
1459         assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.class), "Long.class");
1460         assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.class), "Double.class");
1461         assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.class), "Float.class");
1462         // test primitive classes
1463         assertTrue(ClassUtils.isPrimitiveOrWrapper(Boolean.TYPE), "boolean");
1464         assertTrue(ClassUtils.isPrimitiveOrWrapper(Byte.TYPE), "byte");
1465         assertTrue(ClassUtils.isPrimitiveOrWrapper(Character.TYPE), "char");
1466         assertTrue(ClassUtils.isPrimitiveOrWrapper(Short.TYPE), "short");
1467         assertTrue(ClassUtils.isPrimitiveOrWrapper(Integer.TYPE), "int");
1468         assertTrue(ClassUtils.isPrimitiveOrWrapper(Long.TYPE), "long");
1469         assertTrue(ClassUtils.isPrimitiveOrWrapper(Double.TYPE), "double");
1470         assertTrue(ClassUtils.isPrimitiveOrWrapper(Float.TYPE), "float");
1471         assertTrue(ClassUtils.isPrimitiveOrWrapper(Void.TYPE), "Void.TYPE");
1472         // others
1473         assertFalse(ClassUtils.isPrimitiveOrWrapper(null), "null");
1474         assertFalse(ClassUtils.isPrimitiveOrWrapper(Void.class), "Void.class");
1475         assertFalse(ClassUtils.isPrimitiveOrWrapper(String.class), "String.class");
1476         assertFalse(ClassUtils.isPrimitiveOrWrapper(this.getClass()), "this.getClass()");
1477     }
1478 
1479     @Test
1480     void testIsPrimitiveWrapper() {
1481 
1482         // test primitive wrapper classes
1483         assertTrue(ClassUtils.isPrimitiveWrapper(Boolean.class), "Boolean.class");
1484         assertTrue(ClassUtils.isPrimitiveWrapper(Byte.class), "Byte.class");
1485         assertTrue(ClassUtils.isPrimitiveWrapper(Character.class), "Character.class");
1486         assertTrue(ClassUtils.isPrimitiveWrapper(Short.class), "Short.class");
1487         assertTrue(ClassUtils.isPrimitiveWrapper(Integer.class), "Integer.class");
1488         assertTrue(ClassUtils.isPrimitiveWrapper(Long.class), "Long.class");
1489         assertTrue(ClassUtils.isPrimitiveWrapper(Double.class), "Double.class");
1490         assertTrue(ClassUtils.isPrimitiveWrapper(Float.class), "Float.class");
1491 
1492         // test primitive classes
1493         assertFalse(ClassUtils.isPrimitiveWrapper(Boolean.TYPE), "boolean");
1494         assertFalse(ClassUtils.isPrimitiveWrapper(Byte.TYPE), "byte");
1495         assertFalse(ClassUtils.isPrimitiveWrapper(Character.TYPE), "char");
1496         assertFalse(ClassUtils.isPrimitiveWrapper(Short.TYPE), "short");
1497         assertFalse(ClassUtils.isPrimitiveWrapper(Integer.TYPE), "int");
1498         assertFalse(ClassUtils.isPrimitiveWrapper(Long.TYPE), "long");
1499         assertFalse(ClassUtils.isPrimitiveWrapper(Double.TYPE), "double");
1500         assertFalse(ClassUtils.isPrimitiveWrapper(Float.TYPE), "float");
1501 
1502         // others
1503         assertFalse(ClassUtils.isPrimitiveWrapper(null), "null");
1504         assertFalse(ClassUtils.isPrimitiveWrapper(Void.class), "Void.class");
1505         assertFalse(ClassUtils.isPrimitiveWrapper(Void.TYPE), "Void.TYPE");
1506         assertFalse(ClassUtils.isPrimitiveWrapper(String.class), "String.class");
1507         assertFalse(ClassUtils.isPrimitiveWrapper(this.getClass()), "this.getClass()");
1508     }
1509 
1510     @Test
1511     void testPrimitivesToWrappers() {
1512         // test null
1513 //        assertNull("null -> null", ClassUtils.primitivesToWrappers(null)); // generates warning
1514         assertNull(ClassUtils.primitivesToWrappers((Class<?>[]) null), "null -> null"); // equivalent cast to avoid warning
1515         // Other possible casts for null
1516         assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(), "empty -> empty");
1517         final Class<?>[] castNull = ClassUtils.primitivesToWrappers((Class<?>) null); // == new Class<?>[]{null}
1518         assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]");
1519         // test empty array is returned unchanged
1520         assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY), "empty -> empty");
1521 
1522         // test an array of various classes
1523         final Class<?>[] primitives = new Class[] {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Double.TYPE, Float.TYPE,
1524             String.class, ClassUtils.class};
1525         final Class<?>[] wrappers = ClassUtils.primitivesToWrappers(primitives);
1526 
1527         for (int i = 0; i < primitives.length; i++) {
1528             // test each returned wrapper
1529             final Class<?> primitive = primitives[i];
1530             final Class<?> expectedWrapper = ClassUtils.primitiveToWrapper(primitive);
1531 
1532             assertEquals(expectedWrapper, wrappers[i], primitive + " -> " + expectedWrapper);
1533         }
1534 
1535         // test an array of no primitive classes
1536         final Class<?>[] noPrimitives = new Class[] {String.class, ClassUtils.class, Void.TYPE};
1537         // This used to return the exact same array, but no longer does.
1538         assertNotSame(noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives), "unmodified");
1539     }
1540 
1541     @Test
1542     void testPrimitiveToWrapper() {
1543 
1544         // test primitive classes
1545         assertEquals(Boolean.class, ClassUtils.primitiveToWrapper(Boolean.TYPE), "boolean -> Boolean.class");
1546         assertEquals(Byte.class, ClassUtils.primitiveToWrapper(Byte.TYPE), "byte -> Byte.class");
1547         assertEquals(Character.class, ClassUtils.primitiveToWrapper(Character.TYPE), "char -> Character.class");
1548         assertEquals(Short.class, ClassUtils.primitiveToWrapper(Short.TYPE), "short -> Short.class");
1549         assertEquals(Integer.class, ClassUtils.primitiveToWrapper(Integer.TYPE), "int -> Integer.class");
1550         assertEquals(Long.class, ClassUtils.primitiveToWrapper(Long.TYPE), "long -> Long.class");
1551         assertEquals(Double.class, ClassUtils.primitiveToWrapper(Double.TYPE), "double -> Double.class");
1552         assertEquals(Float.class, ClassUtils.primitiveToWrapper(Float.TYPE), "float -> Float.class");
1553 
1554         // test a few other classes
1555         assertEquals(String.class, ClassUtils.primitiveToWrapper(String.class), "String.class -> String.class");
1556         assertEquals(ClassUtils.class, ClassUtils.primitiveToWrapper(ClassUtils.class), "ClassUtils.class -> ClassUtils.class");
1557         assertEquals(Void.TYPE, ClassUtils.primitiveToWrapper(Void.TYPE), "Void.TYPE -> Void.TYPE");
1558 
1559         // test null
1560         assertNull(ClassUtils.primitiveToWrapper(null), "null -> null");
1561     }
1562 
1563     // Show the Java bug: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=4071957
1564     // We may have to delete this if a JDK fixes the bug.
1565     @Test
1566     void testShowJavaBug() throws Exception {
1567         // Tests with Collections$UnmodifiableSet
1568         final Set<?> set = Collections.unmodifiableSet(new HashSet<>());
1569         final Method isEmptyMethod = set.getClass().getMethod("isEmpty");
1570         assertThrows(IllegalAccessException.class, () -> isEmptyMethod.invoke(set));
1571     }
1572 
1573     @Test
1574     void testToClass_object() {
1575 //        assertNull(ClassUtils.toClass(null)); // generates warning
1576         assertNull(ClassUtils.toClass((Object[]) null)); // equivalent explicit cast
1577 
1578         // Additional varargs tests
1579         assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(), "empty -> empty");
1580         final Class<?>[] castNull = ClassUtils.toClass((Object) null); // == new Object[]{null}
1581         assertArrayEquals(new Object[] {null}, castNull, "(Object) null -> [null]");
1582 
1583         assertSame(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(ArrayUtils.EMPTY_OBJECT_ARRAY));
1584 
1585         assertArrayEquals(new Class[] {String.class, Integer.class, Double.class}, ClassUtils.toClass("Test", Integer.valueOf(1), Double.valueOf(99d)));
1586 
1587         assertArrayEquals(new Class[] {String.class, null, Double.class}, ClassUtils.toClass("Test", null, Double.valueOf(99d)));
1588     }
1589 
1590     @Test
1591     void testWithInterleavingWhitespace() throws ClassNotFoundException {
1592         assertEquals(int[].class, ClassUtils.getClass(" int [ ] "));
1593         assertEquals(long[].class, ClassUtils.getClass("\rlong\t[\n]\r"));
1594         assertEquals(short[].class, ClassUtils.getClass("\tshort                \t\t[]"));
1595         assertEquals(byte[].class, ClassUtils.getClass("byte[\t\t\n\r]   "));
1596     }
1597 
1598     @Test
1599     void testWrappersToPrimitives() {
1600         // an array with classes to test
1601         final Class<?>[] classes = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class, String.class,
1602             ClassUtils.class, null};
1603 
1604         final Class<?>[] primitives = ClassUtils.wrappersToPrimitives(classes);
1605         // now test the result
1606         assertEquals(classes.length, primitives.length, "Wrong length of result array");
1607         for (int i = 0; i < classes.length; i++) {
1608             final Class<?> expectedPrimitive = ClassUtils.wrapperToPrimitive(classes[i]);
1609             assertEquals(expectedPrimitive, primitives[i], classes[i] + " -> " + expectedPrimitive);
1610         }
1611     }
1612 
1613     @Test
1614     void testWrappersToPrimitivesEmpty() {
1615         final Class<?>[] empty = new Class[0];
1616         assertArrayEquals(empty, ClassUtils.wrappersToPrimitives(empty), "Wrong result for empty input");
1617     }
1618 
1619     @Test
1620     void testWrappersToPrimitivesNull() {
1621 //        assertNull("Wrong result for null input", ClassUtils.wrappersToPrimitives(null)); // generates warning
1622         assertNull(ClassUtils.wrappersToPrimitives((Class<?>[]) null), "Wrong result for null input"); // equivalent cast
1623         // Other possible casts for null
1624         assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives(), "empty -> empty");
1625         final Class<?>[] castNull = ClassUtils.wrappersToPrimitives((Class<?>) null); // == new Class<?>[]{null}
1626         assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]");
1627     }
1628 
1629     @Test
1630     void testWrapperToPrimitive() {
1631         // an array with classes to convert
1632         final Class<?>[] primitives = {Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE};
1633         for (final Class<?> primitive : primitives) {
1634             final Class<?> wrapperCls = ClassUtils.primitiveToWrapper(primitive);
1635             assertFalse(wrapperCls.isPrimitive(), "Still primitive");
1636             assertEquals(primitive, ClassUtils.wrapperToPrimitive(wrapperCls), wrapperCls + " -> " + primitive);
1637         }
1638     }
1639 
1640     @Test
1641     void testWrapperToPrimitiveNoWrapper() {
1642         assertNull(ClassUtils.wrapperToPrimitive(String.class), "Wrong result for non wrapper class");
1643     }
1644 
1645     @Test
1646     void testWrapperToPrimitiveNull() {
1647         assertNull(ClassUtils.wrapperToPrimitive(null), "Wrong result for null class");
1648     }
1649 }