1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
56
57 @SuppressWarnings("boxing")
58 class ClassUtilsTest extends AbstractLangTest {
59
60 private static class CX implements IB, IA, IE {
61
62 }
63
64 @SuppressWarnings("unused")
65 private static final class CY extends CX implements IB, IC {
66
67 }
68
69 private interface IA {
70
71 }
72
73 private interface IB {
74
75 }
76
77 private interface IC extends ID, IE {
78
79 }
80
81 private interface ID {
82
83 }
84
85 private interface IE extends IF {
86
87 }
88
89 private interface IF {
90
91 }
92
93 private static final class Inner {
94 private static final class DeeplyNested {
95
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")
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")
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
209 void test_getAbbreviatedName_Class_NegativeLen() {
210 assertIllegalArgumentException(() -> ClassUtils.getAbbreviatedName(String.class, -10));
211 }
212
213 @Test
214
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
244
245
246
247 @Test
248
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
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
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
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
314 final class Named {
315
316 }
317 assertEquals(StringUtils.EMPTY, ClassUtils.getCanonicalName(new Object() {
318
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
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
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
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
359 final class Named {
360
361 }
362 assertEquals("X", ClassUtils.getCanonicalName(new Object() {
363
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
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
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
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
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
411 final class Named {
412
413 }
414 assertEquals("org.apache.commons.lang3.ClassUtilsTest$3", ClassUtils.getName(new Object() {
415
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
430 final class Named {
431
432 }
433 assertEquals("org.apache.commons.lang3.ClassUtilsTest$4", ClassUtils.getName(new Object() {
434
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
449 final class Named {
450
451 }
452 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() {
453
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
470 final class Named {
471
472 }
473 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageCanonicalName(new Object() {
474
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
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
506 assertEquals("java.lang", ClassUtils.getPackageName(String[].class));
507
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
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
521 final class Named {
522
523 }
524 assertEquals("org.apache.commons.lang3", ClassUtils.getPackageName(new Object() {
525
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
559 final class Named {
560
561 }
562 assertEquals("", ClassUtils.getShortCanonicalName(new Object() {
563
564 }.getClass()));
565
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
582 final class Named {
583
584 }
585 assertEquals("", ClassUtils.getShortCanonicalName(new Object() {
586
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
610
611
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
617
618
619 assertEquals("ClassUtilsTest.6", ClassUtils.getShortCanonicalName("org.apache.commons.lang3.ClassUtilsTest$6"));
620
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
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
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
653 assertEquals("String[]", ClassUtils.getShortClassName(String[].class));
654 assertEquals("Map.Entry[]", ClassUtils.getShortClassName(Map.Entry[].class));
655
656
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
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
677 assertEquals("String[][]", ClassUtils.getShortClassName(String[][].class));
678 assertEquals("String[][][]", ClassUtils.getShortClassName(String[][][].class));
679 assertEquals("String[][][][]", ClassUtils.getShortClassName(String[][][][].class));
680
681
682 final class Named {
683
684 }
685
686 assertEquals("ClassUtilsTest.13", ClassUtils.getShortClassName(new Object() {
687
688 }.getClass()));
689
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
702 final class Named {
703
704 }
705
706 assertEquals("ClassUtilsTest.14", ClassUtils.getShortClassName(new Object() {
707
708 }, "<null>"));
709
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
729 assertEquals("String[]", ClassUtils.getSimpleName(String[].class));
730 assertEquals("Entry[]", ClassUtils.getSimpleName(Map.Entry[].class));
731
732
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
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
753 assertEquals("String[][]", ClassUtils.getSimpleName(String[][].class));
754 assertEquals("String[][][]", ClassUtils.getSimpleName(String[][][].class));
755 assertEquals("String[][][][]", ClassUtils.getSimpleName(String[][][][].class));
756
757
758 final class Named {
759
760 }
761 assertEquals("", ClassUtils.getSimpleName(new Object() {
762
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));
848 assertTrue(ClassUtils.isAssignable(null, (Class<?>[]) null));
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1350 assertEquals(String.class, ClassUtils.getClass(" java.lang.String"));
1351 assertEquals(String.class, ClassUtils.getClass("java .lang.String"));
1352 }
1353
1354
1355
1356
1357
1358 @Test
1359 public void testGetClassStringMalformedMiddleJunkRejected() {
1360 assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass("java.lang.String[]junk[]"));
1361 }
1362
1363
1364
1365
1366
1367
1368 @Test
1369 public void testGetClassStringMalformedUnpairedBracketsRejected() {
1370 assertThrows(IllegalArgumentException.class, () -> ClassUtils.getClass("java.lang.String[]][]"));
1371 }
1372
1373
1374
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
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
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
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
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
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
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
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
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
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
1513
1514 assertNull(ClassUtils.primitivesToWrappers((Class<?>[]) null), "null -> null");
1515
1516 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(), "empty -> empty");
1517 final Class<?>[] castNull = ClassUtils.primitivesToWrappers((Class<?>) null);
1518 assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]");
1519
1520 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.primitivesToWrappers(ArrayUtils.EMPTY_CLASS_ARRAY), "empty -> empty");
1521
1522
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
1529 final Class<?> primitive = primitives[i];
1530 final Class<?> expectedWrapper = ClassUtils.primitiveToWrapper(primitive);
1531
1532 assertEquals(expectedWrapper, wrappers[i], primitive + " -> " + expectedWrapper);
1533 }
1534
1535
1536 final Class<?>[] noPrimitives = new Class[] {String.class, ClassUtils.class, Void.TYPE};
1537
1538 assertNotSame(noPrimitives, ClassUtils.primitivesToWrappers(noPrimitives), "unmodified");
1539 }
1540
1541 @Test
1542 void testPrimitiveToWrapper() {
1543
1544
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
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
1560 assertNull(ClassUtils.primitiveToWrapper(null), "null -> null");
1561 }
1562
1563
1564
1565 @Test
1566 void testShowJavaBug() throws Exception {
1567
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
1576 assertNull(ClassUtils.toClass((Object[]) null));
1577
1578
1579 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.toClass(), "empty -> empty");
1580 final Class<?>[] castNull = ClassUtils.toClass((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
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
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
1622 assertNull(ClassUtils.wrappersToPrimitives((Class<?>[]) null), "Wrong result for null input");
1623
1624 assertArrayEquals(ArrayUtils.EMPTY_CLASS_ARRAY, ClassUtils.wrappersToPrimitives(), "empty -> empty");
1625 final Class<?>[] castNull = ClassUtils.wrappersToPrimitives((Class<?>) null);
1626 assertArrayEquals(new Class<?>[] {null}, castNull, "(Class<?>) null -> [null]");
1627 }
1628
1629 @Test
1630 void testWrapperToPrimitive() {
1631
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 }