1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.juneau.commons.reflect;
18
19 import static java.lang.annotation.ElementType.*;
20 import static java.lang.annotation.RetentionPolicy.*;
21 import static org.apache.juneau.TestUtils.*;
22 import static org.apache.juneau.commons.reflect.ClassArrayFormat.*;
23 import static org.apache.juneau.commons.reflect.ClassInfo.*;
24 import static org.apache.juneau.commons.reflect.ClassNameFormat.*;
25 import static org.apache.juneau.commons.reflect.ElementFlag.*;
26 import static org.apache.juneau.commons.utils.CollectionUtils.*;
27 import static org.junit.jupiter.api.Assertions.*;
28
29 import java.io.*;
30 import java.lang.annotation.*;
31 import java.lang.reflect.*;
32 import java.util.*;
33 import java.util.function.*;
34 import java.util.stream.*;
35
36 import org.apache.juneau.*;
37 import org.apache.juneau.annotation.*;
38 import org.apache.juneau.commons.lang.*;
39 import org.apache.juneau.svl.*;
40 import org.junit.jupiter.api.*;
41
42 public class ClassInfo_Test extends TestBase {
43
44 @Documented
45 @Target(TYPE)
46 @Retention(RUNTIME)
47 @Inherited
48 public static @interface A {
49 int value();
50 }
51
52
53 @Repeatable(TestRepeatableContainer.class)
54 @Retention(RUNTIME)
55 @Target({TYPE, METHOD, FIELD})
56 public static @interface TestRepeatable {
57 String value();
58 }
59
60 @Retention(RUNTIME)
61 @Target({TYPE, METHOD, FIELD})
62 public static @interface TestRepeatableContainer {
63 TestRepeatable[] value();
64 }
65
66
67 @Repeatable(OtherRepeatableContainer.class)
68 @Retention(RUNTIME)
69 @Target({TYPE, METHOD, FIELD})
70 public static @interface OtherRepeatable {
71 String value();
72 }
73
74 @Retention(RUNTIME)
75 @Target({TYPE, METHOD, FIELD})
76 public static @interface OtherRepeatableContainer {
77 OtherRepeatable[] value();
78 }
79
80
81 @Retention(RUNTIME)
82 @Target({TYPE, METHOD, FIELD})
83 public static @interface NonRepeatableArrayContainer {
84 String[] value();
85 }
86
87
88
89
90 @Retention(RUNTIME)
91 @Target({TYPE, METHOD, FIELD})
92 public static @interface WrongContainer {
93 TestRepeatable[] value();
94 }
95
96 @Documented
97 @Target(TYPE)
98 @Retention(RUNTIME)
99 @Inherited
100 public static @interface B {
101 int value();
102 }
103
104 @Documented
105 @Target(TYPE)
106 @Retention(RUNTIME)
107 @Inherited
108 @ContextApply(AConfigApply.class)
109 static @interface AConfig {
110 int value();
111 }
112
113 public static class AConfigApply extends AnnotationApplier<AConfig,Context.Builder> {
114 protected AConfigApply(VarResolverSession vr) {
115 super(AConfig.class, Context.Builder.class, vr);
116 }
117
118 @Override
119 public void apply(AnnotationInfo<AConfig> a, Context.Builder b) {}
120 }
121
122 private static void check(String expected, Object o) {
123 if (o instanceof List<?> l) {
124 var actual = l.stream().map(TO_STRING).collect(Collectors.joining(","));
125 assertEquals(expected, actual);
126 } else if (o instanceof Iterable o2) {
127 var actual = StreamSupport.stream(((Iterable<?>)o2).spliterator(), false).map(TO_STRING).collect(Collectors.joining(","));
128 assertEquals(expected, actual);
129 } else {
130 assertEquals(expected, TO_STRING.apply(o));
131 }
132 }
133
134 private static final Function<Object,String> TO_STRING = t -> {
135 if (t == null)
136 return null;
137 if (t instanceof Class t2)
138 return t2.getSimpleName();
139 if (t instanceof Package t3)
140 return t3.getName();
141 if (t instanceof PackageInfo t4)
142 return t4.getName();
143 if (t instanceof ClassInfo t5)
144 return t5.getNameSimple();
145 if (t instanceof MethodInfo t6)
146 return t6.getDeclaringClass().getNameSimple() + '.' + t6.getShortName();
147 if (t instanceof ConstructorInfo t7)
148 return t7.getShortName();
149 if (t instanceof FieldInfo t8)
150 return t8.getDeclaringClass().getNameSimple() + '.' + t8.getName();
151 if (t instanceof A t9)
152 return "@A(" + t9.value() + ")";
153 if (t instanceof PA t10)
154 return "@PA(" + t10.value() + ")";
155 if (t instanceof AConfig t11)
156 return "@AConfig(" + t11.value() + ")";
157 if (t instanceof AnnotationInfo t12)
158 return ClassInfo_Test.TO_STRING.apply(t12.inner());
159 return t.toString();
160 };
161
162
163
164
165
166 public class A1 {}
167
168 public class A2 extends Value<A1> {}
169
170 public class A3 extends Value<Map<String,List<String>>> {}
171
172 public class A4 extends Value<Map<String,String[][]>> {}
173
174 public static Type aType, pType, pTypeDimensional, pTypeGeneric, pTypeGenericArg;
175 static {
176 aType = ((ParameterizedType)A2.class.getGenericSuperclass()).getActualTypeArguments()[0];
177 pType = ((ParameterizedType)A3.class.getGenericSuperclass()).getActualTypeArguments()[0];
178 pTypeDimensional = ((ParameterizedType)A4.class.getGenericSuperclass()).getActualTypeArguments()[0];
179 pTypeGeneric = HashMap.class.getGenericSuperclass();
180 pTypeGenericArg = ((ParameterizedType)pTypeGeneric).getActualTypeArguments()[1];
181 }
182
183 static ClassInfo aTypeInfo = of(aType), pTypeInfo = of(pType), pTypeDimensionalInfo = of(pTypeDimensional), pTypeGenericInfo = of(pTypeGeneric), pTypeGenericArgInfo = of(pTypeGenericArg);
184 static ClassInfo aClass = of(AClass.class), aInterface = of(AInterface.class);
185
186 public static class A6 {
187 public Optional<A1> m1(Optional<A1> bar) {
188 return null;
189 }
190
191 public Value<A1> m2(Value<A1> bar) {
192 return null;
193 }
194 }
195
196 interface BI1 {}
197
198 interface BI2 extends BI1 {}
199
200 interface BI3 {}
201
202 interface BI4 {}
203
204 static class BC1 implements BI1, BI2 {}
205
206 static class BC2 extends BC1 implements BI3 {}
207
208 static class BC3 extends BC2 {}
209
210 static ClassInfo bi1 = of(BI1.class), bi2 = of(BI2.class), bi3 = of(BI3.class), bi4 = of(BI4.class), bc1 = of(BC1.class), bc2 = of(BC2.class), bc3 = of(BC3.class), object = of(Object.class);
211
212 interface CI1 {
213 void i1a();
214
215 void i1b();
216 }
217
218 interface CI2 extends CI1 {
219 void i2b();
220
221 void i2a();
222 }
223
224 interface CI3 {}
225
226 interface CI4 {}
227
228 abstract static class CC1 implements CI1, CI2 {
229 @Override
230 public void i1a() {}
231
232 protected void c1b() {}
233
234 public void c1a() {}
235 }
236
237 static class CC2 extends CC1 implements CI3 {
238 public void c2b() {}
239
240 @Override
241 public void i1b() {}
242
243 @Override
244 public void i2b() {}
245
246 @Override
247 public void i2a() {}
248
249 protected void c2a() {}
250 }
251
252 static class CC3 extends CC2 {
253 @Override
254 public void i2b() {}
255
256 public void c3a() {}
257
258 protected void c3b() {}
259 }
260
261 static ClassInfo cc3 = of(CC3.class), ci2 = of(CI2.class);
262
263 static class E1 {
264 public E1() {}
265
266 public E1(String a) {}
267
268 public E1(Writer a) {}
269
270 public E1(String a, Writer b) {}
271
272 protected E1(int a) {}
273
274 E1(float a) {}
275 }
276
277 static class E2 {
278 protected E2() {}
279 }
280
281 abstract static class E3 {
282 public E3() {}
283 }
284
285 class E4 {
286 public E4() {}
287 }
288
289 static class E5 {
290 @Deprecated
291 public E5() {}
292 }
293
294 class E6 {
295 public E6(String a) {}
296 }
297
298 static ClassInfo e1 = of(E1.class), e2 = of(E2.class), e3 = of(E3.class), e4 = of(E4.class), e5 = of(E5.class), e6 = of(E6.class);
299
300 abstract static class F1 {
301 public int f1a;
302 public int f1b;
303 }
304
305 static class F2 extends F1 {
306 public int f1a;
307 public int f2b;
308 @Deprecated
309 int f2c;
310 protected int f2d;
311 }
312
313 static ClassInfo f1 = of(F1.class), f2 = of(F2.class);
314
315 static class F3 {
316 public int a1;
317 int a2;
318 }
319
320 static ClassInfo f3 = of(F3.class);
321
322 @A(1)
323 interface GI1 {}
324
325 @A(2)
326 interface GI2 extends GI1 {}
327
328 @A(3)
329 interface GI3 {}
330
331 @A(4)
332 interface GI4 {}
333
334 @A(5)
335 static class G1 implements GI1, GI2 {}
336
337 @A(6)
338 static class G2 extends G1 implements GI3 {}
339
340 @A(7)
341 static class G3 extends G2 {}
342
343 static class G4 extends G3 {}
344
345 static class G5 implements GI3 {}
346
347 static ClassInfo g3 = of(G3.class), g4 = of(G4.class), g5 = of(G5.class);
348
349 @A(1)
350 @AConfig(1)
351 interface GBI1 {}
352
353 @A(2)
354 @AConfig(2)
355 interface GBI2 extends GBI1 {}
356
357 @A(3)
358 @AConfig(3)
359 interface GBI3 {}
360
361 @A(4)
362 @AConfig(4)
363 interface GBI4 {}
364
365 @A(5)
366 @AConfig(5)
367 static class GB1 implements GBI1, GBI2 {}
368
369 @A(6)
370 @AConfig(6)
371 static class GB2 extends GB1 implements GBI3 {}
372
373 @A(7)
374 @AConfig(7)
375 static class GB3 extends GB2 {}
376
377 static class GB4 extends GB3 {}
378
379 static class GB5 implements GBI3 {}
380
381 static ClassInfo gb3 = of(GB3.class), gb4 = of(GB4.class), gb5 = of(GB5.class);
382
383 public static class H_Public {}
384
385 static class H_Package {}
386
387 protected static class H_Protected {}
388
389 private static class H_Private {}
390
391 public class H_PublicMember {}
392
393 public abstract class H_AbstractPublic {}
394
395 @Deprecated
396 public class H_PublicDeprecated {}
397
398 static ClassInfo hPublic = of(H_Public.class), hPackage = of(H_Package.class), hProtected = of(H_Protected.class), hPrivate = of(H_Private.class), hPublicMember = of(H_PublicMember.class),
399 hAbstractPublic = of(H_AbstractPublic.class), hPublicDeprecated = of(H_PublicDeprecated.class);
400
401 @Deprecated
402 public abstract static class H2a {}
403
404 private interface H2b {}
405
406 @Deprecated
407 class H2_Deprecated {}
408
409 class H2_NotDeprecated {}
410
411 public class H2_Public {}
412
413 class H2_NotPublic {}
414
415 public static class H2_Static {}
416
417 class H2_NotStatic {}
418
419 class H2_Member {}
420
421 static class H2_StaticMember {}
422
423 abstract class H2_Abstract {}
424
425 class H2_NotAbstract {}
426
427 static ClassInfo h2a = of(H2a.class), h2b = of(H2b.class), h2Deprecated = of(H2_Deprecated.class), h2NotDeprecated = of(H2_NotDeprecated.class), h2Public = of(H2_Public.class),
428 h2NotPublic = of(H2_NotPublic.class), h2Static = of(H2_Static.class), h2NotStatic = of(H2_NotStatic.class), h2Member = of(H2_Member.class), h2StaticMember = of(H2_StaticMember.class),
429 h2Abstract = of(H2_Abstract.class), h2NotAbstract = of(H2_NotAbstract.class);
430
431 static List<Class<?>> primitives = l(boolean.class, byte.class, short.class, char.class, int.class, long.class, float.class, double.class);
432 static List<Class<?>> primitiveWrappers = l(Boolean.class, Byte.class, Short.class, Character.class, Integer.class, Long.class, Float.class, Double.class);
433 static List<Object> primitiveDefaults = l(false, (byte)0, (short)0, (char)0, 0, 0L, 0f, 0d);
434
435 public class J1 {}
436
437 public static class J2 {}
438
439 static ClassInfo j1 = of(J1.class), j2 = of(J2.class), j1_3d = of(J1[][].class), j2_3d = of(J2[][].class);
440
441 public interface KA {}
442
443 public static class KB implements KA {}
444
445 public static class KC extends KB {}
446
447 static ClassInfo ka = of(KA.class), kb = of(KB.class), kc = of(KC.class);
448
449 public static class LA {}
450
451 static ClassInfo la = of(LA.class);
452
453 @SuppressWarnings("serial")
454 public static class MA extends HashMap<String,Integer> {}
455
456 @SuppressWarnings("serial")
457 public static class MB extends MA {}
458
459 @SuppressWarnings("serial")
460 public static class MC<K,E> extends HashMap<K,E> {}
461
462 @SuppressWarnings("serial")
463 public static class MD extends MC<String,Integer> {}
464
465 @SuppressWarnings("serial")
466 public static class ME extends HashMap<String,HashMap<String,Integer>> {}
467
468 @SuppressWarnings("serial")
469 public static class MF extends HashMap<String,String[]> {}
470
471 @SuppressWarnings("serial")
472 public static class MG extends HashMap<String,HashMap<String,Integer>[]> {}
473
474 @SuppressWarnings({ "serial", "rawtypes" })
475 public static class MH extends HashMap<String,LinkedList[]> {}
476
477 @SuppressWarnings({ "serial" })
478 public static class MI<X> extends HashMap<String,X[]> {}
479
480 @SuppressWarnings({ "serial" })
481 public static class MJ<X extends Number> extends HashMap<String,X> {}
482
483 public class MK {}
484
485 @SuppressWarnings({ "serial" })
486 public class ML extends HashMap<String,MK> {}
487
488 public static class MM {
489 @SuppressWarnings({ "serial" })
490 public class MN extends HashMap<String,MM> {}
491 }
492
493 static ClassInfo ma = of(MA.class), mb = of(MB.class), mc = of(MC.class), md = of(MD.class), me = of(ME.class), mf = of(MF.class), mg = of(MG.class), mh = of(MH.class), mi = of(MI.class),
494 mj = of(MJ.class), ml = of(ML.class), mn = of(MM.MN.class);
495
496 interface ISuperGrandParent {}
497
498 interface IGrandParent extends ISuperGrandParent {}
499
500 interface ISuperParent {}
501
502 interface IParent extends ISuperParent {}
503
504 interface IChild {}
505
506 static class GrandParent implements IGrandParent {}
507
508 static class Parent extends GrandParent implements IParent {}
509
510 static class Child extends Parent implements IChild {}
511
512 @SuppressWarnings("unused")
513 private static class GenericsTestClass {
514 HashMap<String,Integer> hashMap;
515 HashMap<String,ArrayList<Integer>> nestedMap;
516 ArrayList<String>[] listArray;
517 }
518
519
520
521
522 @Test
523 void a001_appendNameFormatted() {
524 var ci = ClassInfo.of(String.class);
525 var sb = new StringBuilder("Type: ");
526 ci.appendNameFormatted(sb, FULL, false, '$', BRACKETS);
527 assertEquals("Type: java.lang.String", sb.toString());
528
529
530 var result = ci.appendNameFormatted(sb, SIMPLE, false, '$', BRACKETS);
531 assertSame(sb, result);
532 assertEquals("Type: java.lang.StringString", sb.toString());
533 }
534
535
536
537
538 @Test
539 void a002_arrayType() {
540 var ci = ClassInfo.of(String.class);
541 var arrayType = ci.arrayType();
542 assertNotNull(arrayType);
543 assertEquals(String[].class, arrayType.inner());
544
545
546 var ci2 = ClassInfo.of(String[].class);
547 var arrayType2 = ci2.arrayType();
548 assertNotNull(arrayType2);
549 assertEquals(String[][].class, arrayType2.inner());
550
551
552 var ci3 = ClassInfo.of((Class<?>)null, pType);
553 assertNull(ci3.arrayType());
554
555
556
557
558
559
560
561
562
563 var ci4 = ClassInfo.of(Integer.class);
564 var arrayType3 = ci4.arrayType();
565 assertNotNull(arrayType3);
566 assertEquals(Integer[].class, arrayType3.inner());
567
568
569
570 }
571
572
573
574
575 @Test
576 void a002b_asSubclass() {
577
578 var ci = ClassInfo.of(String.class);
579 var result = ci.asSubclass(CharSequence.class);
580 assertSame(ci, result);
581
582
583 assertThrows(ClassCastException.class, () -> ci.asSubclass(Integer.class));
584
585
586 var ci2 = ClassInfo.of((Class<?>)null, pType);
587 assertNull(ci2.asSubclass(CharSequence.class));
588 }
589
590
591
592
593 @Test
594 void a003_getAllFields() {
595 check("F1.f1a,F1.f1b,F2.f1a,F2.f2b,F2.f2c,F2.f2d", f2.getAllFields());
596
597 check("F1.f1a,F1.f1b,F2.f1a,F2.f2b,F2.f2c,F2.f2d", f2.getAllFields());
598 }
599
600
601
602
603 @Test
604 void a004_getAllMethods() {
605 check("CC3.c3a(),CC3.c3b(),CC3.i2b(),CC2.c2a(),CC2.c2b(),CC2.i1b(),CC2.i2a(),CC2.i2b(),CC1.c1a(),CC1.c1b(),CC1.i1a(),CI1.i1a(),CI1.i1b(),CI2.i2a(),CI2.i2b()", cc3.getAllMethods());
606
607 check("CC3.c3a(),CC3.c3b(),CC3.i2b(),CC2.c2a(),CC2.c2b(),CC2.i1b(),CC2.i2a(),CC2.i2b(),CC1.c1a(),CC1.c1b(),CC1.i1a(),CI1.i1a(),CI1.i1b(),CI2.i2a(),CI2.i2b()", cc3.getAllMethods());
608 }
609
610
611
612
613 @Test
614 void a005_getAllMethodsTopDown() {
615
616
617 check("CI2.i2a(),CI2.i2b(),CI1.i1a(),CI1.i1b(),CC1.c1a(),CC1.c1b(),CC1.i1a(),CC2.c2a(),CC2.c2b(),CC2.i1b(),CC2.i2a(),CC2.i2b(),CC3.c3a(),CC3.c3b(),CC3.i2b()", cc3.getAllMethodsTopDown());
618
619 check("CI2.i2a(),CI2.i2b(),CI1.i1a(),CI1.i1b(),CC1.c1a(),CC1.c1b(),CC1.i1a(),CC2.c2a(),CC2.c2b(),CC2.i1b(),CC2.i2a(),CC2.i2b(),CC3.c3a(),CC3.c3b(),CC3.i2b()", cc3.getAllMethodsTopDown());
620
621
622
623 var objectCi = ClassInfo.of(Object.class);
624 var objectMethods = objectCi.getAllMethodsTopDown();
625 assertNotNull(objectMethods);
626
627
628
629
630
631 var emptyInterface = ClassInfo.of(EmptyInterface.class);
632 var emptyMethods = emptyInterface.getAllMethodsTopDown();
633 assertNotNull(emptyMethods);
634
635 assertTrue(emptyMethods.isEmpty() || emptyMethods.size() >= 0);
636 }
637
638
639 interface EmptyInterface {}
640
641
642
643
644 @Test
645 void a006_getAllParents() {
646 check("BC3,BC2,BC1,BI3,BI1,BI2", bc3.getAllParents());
647 check("", object.getAllParents());
648 check("BI1", bi1.getAllParents());
649
650 check("BC3,BC2,BC1,BI3,BI1,BI2", bc3.getAllParents());
651 }
652
653
654
655
656 @Test
657 void a007_getAnnotatableType() {
658 assertEquals(AnnotatableType.CLASS_TYPE, aClass.getAnnotatableType());
659 assertEquals(AnnotatableType.CLASS_TYPE, aInterface.getAnnotatableType());
660 assertEquals(AnnotatableType.CLASS_TYPE, aTypeInfo.getAnnotatableType());
661 }
662
663
664
665
666 @Test
667 void a008_getAnnotatedInterfaces() {
668 var annotated = ci2.getAnnotatedInterfaces();
669 assertNotNull(annotated);
670
671 assertFalse(annotated.isEmpty());
672 }
673
674
675
676
677 @Test
678 void a009_getAnnotatedSuperclass() {
679
680 var annotated = bc2.getAnnotatedSuperclass();
681 assertNotNull(annotated);
682
683
684 assertNull(object.getAnnotatedSuperclass());
685
686
687 assertNull(bi1.getAnnotatedSuperclass());
688
689
690 assertNull(pTypeGenericArgInfo.getAnnotatedSuperclass());
691 }
692
693
694
695
696 @Test
697 void a010_getAnnotations() {
698
699 var allAnnotations = g3.getAnnotations();
700 assertNotNull(allAnnotations);
701 assertFalse(allAnnotations.isEmpty());
702
703
704 var aAnnotations = g3.getAnnotations(A.class);
705 assertNotNull(aAnnotations);
706 var first = aAnnotations.findFirst().map(AnnotationInfo::inner).orElse(null);
707 check("@A(7)", first);
708
709
710 check("@A(7)", g3.getAnnotations(A.class).findFirst().map(AnnotationInfo::inner).orElse(null));
711
712
713 check("@A(7)", g4.getAnnotations(A.class).findFirst().map(AnnotationInfo::inner).orElse(null));
714
715
716 check("@A(3)", g5.getAnnotations(A.class).findFirst().map(AnnotationInfo::inner).orElse(null));
717
718
719 assertTrue(g3.getAnnotations(B.class).findFirst().isEmpty());
720
721
722 assertThrows(IllegalArgumentException.class, () -> g3.getAnnotations(null));
723
724
725 check("@PA(10),@A(2),@A(1),@A(5),@A(3),@A(6),@A(7)", rstream(g3.getAnnotations()).collect(Collectors.toList()));
726 check("@PA(10),@A(2),@A(1),@A(5),@A(3),@A(6),@A(7)", rstream(g4.getAnnotations()).collect(Collectors.toList()));
727 check("@PA(10),@A(3)", rstream(g5.getAnnotations()).collect(Collectors.toList()));
728 }
729
730
731
732
733 @Test
734 void a011_getClassLoader() {
735 var cl = aClass.getClassLoader();
736 assertNotNull(cl);
737
738
739 assertNull(pTypeGenericArgInfo.getClassLoader());
740 }
741
742
743
744
745 @Test
746 void a011b_canAcceptArg() {
747
748 assertTrue(ClassInfo.of(String.class).canAcceptArg("test"));
749 assertTrue(ClassInfo.of(Integer.class).canAcceptArg(42));
750 assertTrue(ClassInfo.of(int.class).canAcceptArg(42));
751
752
753 assertTrue(ClassInfo.of(String.class).canAcceptArg(null));
754 assertTrue(ClassInfo.of(Integer.class).canAcceptArg(null));
755
756
757 assertFalse(ClassInfo.of(int.class).canAcceptArg(null));
758 assertFalse(ClassInfo.of(boolean.class).canAcceptArg(null));
759
760
761 assertFalse(ClassInfo.of(String.class).canAcceptArg(42));
762
763
764 var ci = ClassInfo.of((Class<?>)null, pType);
765 assertFalse(ci.canAcceptArg("test"));
766 assertFalse(ci.canAcceptArg(null));
767
768
769
770 assertTrue(ClassInfo.of(int.class).canAcceptArg(Integer.valueOf(42)));
771 assertTrue(ClassInfo.of(long.class).canAcceptArg(Long.valueOf(42L)));
772
773 assertTrue(ClassInfo.of(Integer.class).canAcceptArg(42));
774 assertTrue(ClassInfo.of(Long.class).canAcceptArg(42L));
775
776 assertTrue(ClassInfo.of(Number.class).canAcceptArg(42));
777 assertTrue(ClassInfo.of(Number.class).canAcceptArg(Integer.valueOf(42)));
778
779
780
781
782
783
784
785
786
787
788
789 assertFalse(ClassInfo.of(String.class).canAcceptArg(new Object()));
790 assertFalse(ClassInfo.of(String.class).canAcceptArg(42));
791
792
793 assertFalse(ClassInfo.of(int.class).canAcceptArg(Long.valueOf(42L)));
794 }
795
796
797
798
799 @Test
800 void a011c_cast() {
801
802 var ci = ClassInfo.of(String.class);
803 var result = ci.cast("test");
804 assertEquals("test", result);
805
806
807 assertNull(ci.cast(null));
808
809
810 assertThrows(ClassCastException.class, () -> ci.cast(42));
811
812
813 var ci2 = ClassInfo.of((Class<?>)null, pType);
814 assertNull(ci2.cast("test"));
815 assertNull(ci2.cast(null));
816 }
817
818
819
820
821 @Test
822 void a012_getComponentType() {
823
824 assertEquals(ka, ka.getComponentType());
825
826 assertEquals(ka, ka.getComponentType());
827
828
829 check("KA", of(KA[][].class).getComponentType());
830
831
832 assertEquals(aTypeInfo, aTypeInfo.getComponentType());
833 assertEquals(pTypeInfo, pTypeInfo.getComponentType());
834 assertEquals(pTypeDimensionalInfo, pTypeDimensionalInfo.getComponentType());
835 assertEquals(pTypeGenericInfo, pTypeGenericInfo.getComponentType());
836 assertEquals(pTypeGenericArgInfo, pTypeGenericArgInfo.getComponentType());
837
838
839 var ci = ClassInfo.of((Class<?>)null, pType);
840 assertNull(ci.componentType());
841
842
843
844 var nonArray = ClassInfo.of(String.class);
845 var ct = nonArray.componentType();
846
847
848 assertNull(ct);
849
850
851 var array = ClassInfo.of(String[].class);
852 var ct2 = array.componentType();
853 assertNotNull(ct2);
854 assertEquals(String.class, ct2.inner());
855 }
856
857
858
859
860 @Test
861 void a012b_descriptorString() {
862
863 assertEquals("Ljava/lang/String;", ClassInfo.of(String.class).descriptorString());
864 assertEquals("I", ClassInfo.of(int.class).descriptorString());
865 assertEquals("[Ljava/lang/String;", ClassInfo.of(String[].class).descriptorString());
866
867
868 var ci = ClassInfo.of((Class<?>)null, pType);
869 assertNull(ci.descriptorString());
870 }
871
872
873
874
875 @Test
876 void a012c_equals() {
877
878 var ci1 = ClassInfo.of(String.class);
879 var ci2 = ClassInfo.of(String.class);
880 assertEquals(ci1, ci2);
881
882
883 var ci3 = ClassInfo.of(Integer.class);
884 assertNotEquals(ci1, ci3);
885
886
887 assertEquals(pTypeInfo, ClassInfo.of(pType));
888
889
890 assertNotEquals(pTypeInfo, pTypeDimensionalInfo);
891
892
893 assertNotEquals(ci1, "not a ClassInfo");
894 assertNotEquals(ci1, null);
895 }
896
897
898
899
900 @Test
901 void a013_getDeclaredAnnotations() {
902 var declared = g3.getDeclaredAnnotations();
903 assertNotNull(declared);
904
905 assertFalse(declared.isEmpty());
906
907
908 var declared2 = g4.getDeclaredAnnotations();
909 assertTrue(declared2.isEmpty());
910
911
912 var ci = ClassInfo.of((Class<?>)null, pType);
913 var declared3 = ci.getDeclaredAnnotations();
914 assertNotNull(declared3);
915 assertTrue(declared3.isEmpty());
916 }
917
918
919
920
921 @Test
922 void a014_getDeclaredConstructor() {
923 check("E1(int)", e1.getDeclaredConstructor(x -> x.isVisible(Visibility.PROTECTED) && x.hasParameterTypes(int.class)).orElse(null));
924 check("E1(int)", e1.getDeclaredConstructor(x -> x.isVisible(Visibility.PRIVATE) && x.hasParameterTypes(int.class)).orElse(null));
925 check(null, e1.getDeclaredConstructor(x -> x.isVisible(Visibility.PUBLIC) && x.hasParameterTypes(int.class)).orElse(null));
926 check("E3()", e3.getDeclaredConstructor(x -> x.isVisible(Visibility.PUBLIC)).orElse(null));
927 check("E4(ClassInfo_Test)", e4.getDeclaredConstructor(x -> x.isVisible(Visibility.PUBLIC)).orElse(null));
928 check("E5()", e5.getDeclaredConstructor(x -> x.isVisible(Visibility.PUBLIC)).orElse(null));
929 }
930
931
932
933
934 @Test
935 void a015_getDeclaredConstructors() {
936 check("E1(),E1(float),E1(int),E1(Writer),E1(String),E1(String,Writer)", e1.getDeclaredConstructors());
937
938 check("E1(),E1(float),E1(int),E1(Writer),E1(String),E1(String,Writer)", e1.getDeclaredConstructors());
939
940
941 check("A1(ClassInfo_Test)", aTypeInfo.getDeclaredConstructors());
942 check("", pTypeInfo.getDeclaredConstructors());
943 check("", pTypeDimensionalInfo.getDeclaredConstructors());
944 check("AbstractMap()", pTypeGenericInfo.getDeclaredConstructors());
945 check("", pTypeGenericArgInfo.getDeclaredConstructors());
946 }
947
948
949
950
951 @Test
952 void a016_getDeclaredField() {
953 check("F3.a1", f3.getDeclaredField(x -> x.hasName("a1")).orElse(null));
954 check("F3.a2", f3.getDeclaredField(x -> x.hasName("a2")).orElse(null));
955 check(null, f3.getDeclaredField(x -> x.hasName("a3")).orElse(null));
956 }
957
958
959
960
961 @Test
962 void a017_getDeclaredFields() {
963 check("F2.f1a,F2.f2b,F2.f2c,F2.f2d", f2.getDeclaredFields());
964
965 check("F2.f1a,F2.f2b,F2.f2c,F2.f2d", f2.getDeclaredFields());
966
967
968 check("A1.this$0", aTypeInfo.getDeclaredFields());
969 check("", pTypeInfo.getDeclaredFields());
970 check("", pTypeDimensionalInfo.getDeclaredFields());
971 check("AbstractMap.keySet,AbstractMap.values", pTypeGenericInfo.getDeclaredFields());
972 check("", pTypeGenericArgInfo.getDeclaredFields());
973 }
974
975
976
977
978 @Test
979 void a018_getDeclaredInterfaces() {
980 check("", bi4.getDeclaredInterfaces());
981 check("BI1,BI2", bc1.getDeclaredInterfaces());
982 check("BI3", bc2.getDeclaredInterfaces());
983 check("", bc3.getDeclaredInterfaces());
984
985 check("BI1,BI2", bc1.getDeclaredInterfaces());
986
987
988 check("", aTypeInfo.getDeclaredInterfaces());
989 check("", pTypeInfo.getDeclaredInterfaces());
990 check("", pTypeDimensionalInfo.getDeclaredInterfaces());
991 check("Map", pTypeGenericInfo.getDeclaredInterfaces());
992 check("", pTypeGenericArgInfo.getDeclaredInterfaces());
993
994
995
996 var ci = ClassInfo.of((Class<?>)null, pType);
997 var declaredInterfaces = ci.getDeclaredInterfaces();
998 assertNotNull(declaredInterfaces);
999 assertTrue(declaredInterfaces.isEmpty());
1000 }
1001
1002
1003
1004
1005 @Test
1006 void a019_getDeclaredMemberClasses() {
1007
1008 var memberClasses = MM.class.getDeclaredClasses();
1009 assertNotNull(memberClasses);
1010
1011 assertTrue(memberClasses.length > 0);
1012
1013
1014 var mmCi = ClassInfo.of(MM.class);
1015 var declaredMemberClasses = mmCi.getDeclaredMemberClasses();
1016 assertNotNull(declaredMemberClasses);
1017 assertFalse(declaredMemberClasses.isEmpty());
1018
1019
1020 var empty = pTypeGenericArgInfo.getDeclaredMemberClasses();
1021 assertTrue(empty.isEmpty());
1022
1023
1024 var ci = ClassInfo.of((Class<?>)null, pType);
1025 var empty2 = ci.getDeclaredMemberClasses();
1026 assertNotNull(empty2);
1027 assertTrue(empty2.isEmpty());
1028 }
1029
1030
1031
1032
1033 @Test
1034 void a020_getDeclaredMethod() {
1035 var method = cc3.getDeclaredMethod(x -> x.hasName("c3a"));
1036 assertTrue(method.isPresent());
1037 assertEquals("c3a", method.get().getName());
1038
1039
1040 var method2 = cc3.getDeclaredMethod(x -> x.hasName("nonexistent"));
1041 assertFalse(method2.isPresent());
1042 }
1043
1044
1045
1046
1047 @Test
1048 void a021_getDeclaredMethods() {
1049 check("CC3.c3a(),CC3.c3b(),CC3.i2b()", cc3.getDeclaredMethods());
1050 check("CI2.i2a(),CI2.i2b()", ci2.getDeclaredMethods());
1051
1052 check("CI2.i2a(),CI2.i2b()", ci2.getDeclaredMethods());
1053
1054
1055 check("", aTypeInfo.getDeclaredMethods());
1056 check("", pTypeGenericArgInfo.getDeclaredMethods());
1057 }
1058
1059
1060
1061
1062 @Test
1063 void a022_getDeclaringClass() {
1064
1065 var declaring = aTypeInfo.getDeclaringClass();
1066 assertNotNull(declaring);
1067 assertEquals(ClassInfo_Test.class.getName(), declaring.inner().getName());
1068
1069
1070 var declaring2 = aClass.getDeclaringClass();
1071 assertNull(declaring2);
1072
1073
1074 var ci = ClassInfo.of((Class<?>)null, pType);
1075 assertNull(ci.getDeclaringClass());
1076 }
1077
1078
1079
1080
1081 @Test
1082 void a023_getDimensions() {
1083 assertEquals(0, ka.getDimensions());
1084 assertEquals(2, of(KA[][].class).getDimensions());
1085
1086 assertEquals(0, ka.getDimensions());
1087
1088
1089 assertEquals(0, aTypeInfo.getDimensions());
1090 assertEquals(0, pTypeInfo.getDimensions());
1091 assertEquals(0, pTypeDimensionalInfo.getDimensions());
1092 assertEquals(0, pTypeGenericInfo.getDimensions());
1093 assertEquals(0, pTypeGenericArgInfo.getDimensions());
1094 }
1095
1096
1097
1098
1099 @Test
1100 void a024_getEnclosingClass() {
1101
1102 var ci = ClassInfo.of((Class<?>)null, pType);
1103 assertNull(ci.getEnclosingClass());
1104
1105
1106 var enclosing = aTypeInfo.getEnclosingClass();
1107 assertNotNull(enclosing);
1108 assertEquals(ClassInfo_Test.class.getName(), enclosing.inner().getName());
1109
1110
1111 var enclosing2 = aClass.getEnclosingClass();
1112 assertNull(enclosing2);
1113 }
1114
1115
1116 static class EnclosingConstructorTestClass {
1117 EnclosingConstructorTestClass() {
1118
1119 class LocalInConstructor {}
1120
1121 ClassInfo_Test.localInConstructorClass = LocalInConstructor.class;
1122 }
1123 }
1124 static Class<?> localInConstructorClass;
1125
1126
1127
1128
1129 @Test
1130 void a025_getEnclosingConstructor() {
1131
1132 var ci = ClassInfo.of((Class<?>)null, pType);
1133 assertNull(ci.getEnclosingConstructor());
1134
1135
1136
1137 assertNull(aClass.getEnclosingConstructor());
1138 assertNull(ClassInfo.of(String.class).getEnclosingConstructor());
1139
1140 class LocalClass {}
1141 var local = ClassInfo.of(LocalClass.class);
1142 var constructor = local.getEnclosingConstructor();
1143 assertNull(constructor);
1144
1145
1146
1147 new EnclosingConstructorTestClass();
1148 if (localInConstructorClass != null) {
1149 var localInCtor = ClassInfo.of(localInConstructorClass);
1150 var enclosingCtor = localInCtor.getEnclosingConstructor();
1151
1152
1153
1154 assertNotNull(enclosingCtor, "Expected non-null enclosing constructor for local class in constructor");
1155 }
1156 }
1157
1158
1159
1160
1161 @Test
1162 void a026_getEnclosingMethod() {
1163
1164 var ci = ClassInfo.of((Class<?>)null, pType);
1165 assertNull(ci.getEnclosingMethod());
1166
1167
1168
1169 assertNull(aClass.getEnclosingMethod());
1170 assertNull(ClassInfo.of(String.class).getEnclosingMethod());
1171
1172 class LocalClass {}
1173 var local = ClassInfo.of(LocalClass.class);
1174 var method = local.getEnclosingMethod();
1175 assertNotNull(method);
1176 }
1177
1178
1179
1180
1181 @Test
1182 void a027_getGenericInterfaces() {
1183 var list = ci2.getGenericInterfaces();
1184 assertNotNull(list);
1185
1186 assertFalse(list.isEmpty());
1187 }
1188
1189
1190
1191
1192 @Test
1193 void a028_getGenericSuperclass() {
1194
1195 var superclass = bc2.getGenericSuperclass();
1196 assertNotNull(superclass);
1197
1198
1199 assertNull(object.getGenericSuperclass());
1200
1201
1202 assertNull(bi1.getGenericSuperclass());
1203
1204
1205 assertNull(pTypeGenericArgInfo.getGenericSuperclass());
1206 }
1207
1208
1209
1210
1211 @Test
1212 void a029_getInterfaces() {
1213 check("", bi4.getInterfaces());
1214 check("BI1,BI2", bc1.getInterfaces());
1215 check("BI3,BI1,BI2", bc2.getInterfaces());
1216 check("BI3,BI1,BI2", bc3.getInterfaces());
1217
1218 check("BI3,BI1,BI2", bc2.getInterfaces());
1219 }
1220
1221
1222
1223
1224 @Test
1225 void a030_getLabel() {
1226 assertEquals("AClass", aClass.getLabel());
1227 assertEquals("A1", aTypeInfo.getLabel());
1228 assertEquals("AInterface", aInterface.getLabel());
1229 }
1230
1231
1232
1233
1234 @Test
1235 void a031_getMemberClasses() {
1236
1237 var memberClasses = MM.class.getClasses();
1238 assertNotNull(memberClasses);
1239
1240 assertTrue(memberClasses.length > 0);
1241
1242
1243 var mmCi = ClassInfo.of(MM.class);
1244 var memberClassesList = mmCi.getMemberClasses();
1245 assertNotNull(memberClassesList);
1246 assertFalse(memberClassesList.isEmpty());
1247
1248
1249 var empty = pTypeGenericArgInfo.getMemberClasses();
1250 assertTrue(empty.isEmpty());
1251
1252
1253 var ci = ClassInfo.of((Class<?>)null, pType);
1254 var empty2 = ci.getMemberClasses();
1255 assertNotNull(empty2);
1256 assertTrue(empty2.isEmpty());
1257 }
1258
1259
1260
1261
1262 @Test
1263 void a032_getMethod() {
1264 var method = cc3.getMethod(x -> x.hasName("c3a"));
1265 assertTrue(method.isPresent());
1266 assertEquals("c3a", method.get().getName());
1267
1268
1269 var method2 = cc3.getMethod(x -> x.hasName("nonexistent"));
1270 assertFalse(method2.isPresent());
1271 }
1272
1273
1274
1275
1276 @Test
1277 void a033_getModule() {
1278 var module = aClass.getModule();
1279 assertNotNull(module);
1280
1281
1282 assertNull(pTypeGenericArgInfo.getModule());
1283 }
1284
1285
1286
1287
1288 @Test
1289 void a034_getName() {
1290 assertEquals("org.apache.juneau.commons.reflect.AClass", aClass.getName());
1291 assertEquals("java.util.AbstractMap", pTypeGenericInfo.getName());
1292 assertEquals("V", pTypeGenericArgInfo.getName());
1293 }
1294
1295
1296
1297
1298 @Test
1299 void a035_getNameCanonical() {
1300
1301 assertEquals("org.apache.juneau.commons.reflect.AClass", aClass.getNameCanonical());
1302 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test.A1", aTypeInfo.getNameCanonical());
1303
1304
1305
1306 assertNull(pTypeInfo.getNameCanonical());
1307 assertNull(pTypeDimensionalInfo.getNameCanonical());
1308 assertNull(pTypeGenericInfo.getNameCanonical());
1309
1310
1311
1312
1313
1314
1315 var typeVariableInfo = ClassInfo.of((Class<?>)null, aType);
1316
1317
1318 assertNull(typeVariableInfo.getNameCanonical());
1319 }
1320
1321
1322
1323
1324 @Test
1325 void a036_getNameFormatted() throws Exception {
1326 var ci = ClassInfo.of(String.class);
1327
1328
1329 assertEquals("String", ci.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1330 assertEquals("String", ci.getNameFormatted(SIMPLE, false, '.', BRACKETS));
1331 assertEquals("String", ci.getNameFormatted(SIMPLE, true, '$', BRACKETS));
1332
1333
1334 assertEquals("String", ci.getNameFormatted(SHORT, false, '$', BRACKETS));
1335 assertEquals("String", ci.getNameFormatted(SHORT, true, '$', BRACKETS));
1336
1337
1338 assertEquals("java.lang.String", ci.getNameFormatted(FULL, false, '$', BRACKETS));
1339 assertEquals("java.lang.String", ci.getNameFormatted(FULL, true, '$', BRACKETS));
1340
1341
1342 var ci2 = ClassInfo.of(Map.Entry.class);
1343 assertEquals("Entry", ci2.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1344 assertEquals("Map$Entry", ci2.getNameFormatted(SHORT, false, '$', BRACKETS));
1345 assertEquals("Map.Entry", ci2.getNameFormatted(SHORT, false, '.', BRACKETS));
1346 assertEquals("java.util.Map$Entry", ci2.getNameFormatted(FULL, false, '$', BRACKETS));
1347 assertEquals("java.util.Map.Entry", ci2.getNameFormatted(FULL, false, '.', BRACKETS));
1348
1349
1350 var ci3 = ClassInfo.of(String[].class);
1351 assertEquals("String[]", ci3.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1352 assertEquals("String[]", ci3.getNameFormatted(SHORT, false, '$', BRACKETS));
1353 assertEquals("java.lang.String[]", ci3.getNameFormatted(FULL, false, '$', BRACKETS));
1354 assertEquals("StringArray", ci3.getNameFormatted(SIMPLE, false, '$', WORD));
1355 assertEquals("StringArray", ci3.getNameFormatted(SHORT, false, '$', WORD));
1356 assertEquals("java.lang.StringArray", ci3.getNameFormatted(FULL, false, '$', WORD));
1357
1358
1359 var ci4 = ClassInfo.of(String[][].class);
1360 assertEquals("String[][]", ci4.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1361 assertEquals("java.lang.String[][]", ci4.getNameFormatted(FULL, false, '$', BRACKETS));
1362 assertEquals("StringArrayArray", ci4.getNameFormatted(SIMPLE, false, '$', WORD));
1363 assertEquals("java.lang.StringArrayArray", ci4.getNameFormatted(FULL, false, '$', WORD));
1364
1365
1366 var ci5 = ClassInfo.of(int[].class);
1367 assertEquals("int[]", ci5.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1368 assertEquals("int[]", ci5.getNameFormatted(FULL, false, '$', BRACKETS));
1369 assertEquals("intArray", ci5.getNameFormatted(SIMPLE, false, '$', WORD));
1370 assertEquals("intArray", ci5.getNameFormatted(FULL, false, '$', WORD));
1371
1372
1373 var f = GenericsTestClass.class.getDeclaredField("hashMap");
1374 var t = f.getGenericType();
1375 var ci6 = ClassInfo.of(t);
1376 assertEquals("HashMap", ci6.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1377 assertEquals("java.util.HashMap", ci6.getNameFormatted(FULL, false, '$', BRACKETS));
1378 assertEquals("HashMap<String,Integer>", ci6.getNameFormatted(SIMPLE, true, '$', BRACKETS));
1379 assertEquals("HashMap<String,Integer>", ci6.getNameFormatted(SHORT, true, '$', BRACKETS));
1380 assertEquals("java.util.HashMap<java.lang.String,java.lang.Integer>", ci6.getNameFormatted(FULL, true, '$', BRACKETS));
1381
1382
1383 f = GenericsTestClass.class.getDeclaredField("nestedMap");
1384 t = f.getGenericType();
1385 var ci7 = ClassInfo.of(t);
1386 assertEquals("HashMap<String,ArrayList<Integer>>", ci7.getNameFormatted(SIMPLE, true, '$', BRACKETS));
1387 assertEquals("java.util.HashMap<java.lang.String,java.util.ArrayList<java.lang.Integer>>", ci7.getNameFormatted(FULL, true, '$', BRACKETS));
1388
1389
1390 f = GenericsTestClass.class.getDeclaredField("listArray");
1391 t = f.getGenericType();
1392 var ci8 = ClassInfo.of(t);
1393 assertEquals("ArrayList<String>[]", ci8.getNameFormatted(SIMPLE, true, '$', BRACKETS));
1394 assertEquals("java.util.ArrayList<java.lang.String>[]", ci8.getNameFormatted(FULL, true, '$', BRACKETS));
1395 assertEquals("ArrayList<String>Array", ci8.getNameFormatted(SIMPLE, true, '$', WORD));
1396
1397
1398 var ci9 = ClassInfo.of(Map.Entry[].class);
1399 assertEquals("Entry[]", ci9.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1400 assertEquals("EntryArray", ci9.getNameFormatted(SIMPLE, false, '$', WORD));
1401 assertEquals("Map$Entry[]", ci9.getNameFormatted(SHORT, false, '$', BRACKETS));
1402 assertEquals("Map.Entry[]", ci9.getNameFormatted(SHORT, false, '.', BRACKETS));
1403 assertEquals("Map$EntryArray", ci9.getNameFormatted(SHORT, false, '$', WORD));
1404 assertEquals("java.util.Map$Entry[]", ci9.getNameFormatted(FULL, false, '$', BRACKETS));
1405 assertEquals("java.util.Map.Entry[]", ci9.getNameFormatted(FULL, false, '.', BRACKETS));
1406 assertEquals("java.util.Map$EntryArray", ci9.getNameFormatted(FULL, false, '$', WORD));
1407
1408
1409 assertEquals(ci.getName(), ci.getNameFormatted(FULL, false, '$', BRACKETS));
1410 assertEquals(ci.getNameSimple(), ci.getNameFormatted(SIMPLE, false, '$', BRACKETS));
1411
1412
1413 var ci10 = pTypeInfo;
1414 var formatted = ci10.getNameFormatted(SIMPLE, false, '$', BRACKETS);
1415 assertNotNull(formatted);
1416 assertTrue(formatted.contains("Map"));
1417
1418
1419 var ci11 = ClassInfo.of((Class<?>)null, pType);
1420 var formatted2 = ci11.getNameFormatted(SIMPLE, false, '$', BRACKETS);
1421 assertNotNull(formatted2);
1422
1423 assertEquals("Map", formatted2);
1424
1425
1426
1427 var ci12 = ClassInfo.of(Map.Entry.class);
1428 assertEquals("java.util.Map.Entry", ci12.getNameFormatted(FULL, false, '.', BRACKETS));
1429
1430
1431 var ci13 = ClassInfo.of(String.class);
1432 assertEquals("java.lang.String", ci13.getNameFormatted(FULL, false, '.', BRACKETS));
1433
1434
1435 assertEquals("java.util.Map$Entry", ci12.getNameFormatted(FULL, false, '$', BRACKETS));
1436
1437
1438 assertEquals("java.lang.String", ci13.getNameFormatted(FULL, false, '$', BRACKETS));
1439
1440
1441
1442 var typeVar = MC.class.getTypeParameters()[0];
1443 var ci14 = ClassInfo.of((Class<?>)null, typeVar);
1444 var formatted3 = ci14.getNameFormatted(SIMPLE, false, '$', BRACKETS);
1445 assertNotNull(formatted3);
1446
1447 assertEquals(typeVar.getName(), formatted3);
1448 }
1449
1450
1451
1452
1453 @Test
1454 void a037_getNameFull() {
1455 assertEquals("org.apache.juneau.commons.reflect.AClass", aClass.getNameFull());
1456
1457 assertEquals("org.apache.juneau.commons.reflect.AClass", aClass.getNameFull());
1458
1459
1460 assertEquals("org.apache.juneau.commons.reflect.AClass[][]", of(AClass[][].class).getNameFull());
1461
1462
1463 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test$J1", j1.getNameFull());
1464 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test$J2", j2.getNameFull());
1465
1466
1467 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test$J1[][]", j1_3d.getNameFull());
1468 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test$J2[][]", j2_3d.getNameFull());
1469
1470
1471 assertEquals("int", of(int.class).getNameFull());
1472
1473
1474 assertEquals("int[][]", of(int[][].class).getNameFull());
1475
1476
1477 assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test$A1", aTypeInfo.getNameFull());
1478 assertEquals("java.util.Map<java.lang.String,java.util.List<java.lang.String>>", pTypeInfo.getNameFull());
1479 assertEquals("java.util.Map<java.lang.String,java.lang.String[][]>", pTypeDimensionalInfo.getNameFull());
1480 assertEquals("java.util.AbstractMap<K,V>", pTypeGenericInfo.getNameFull());
1481 assertEquals("V", pTypeGenericArgInfo.getNameFull());
1482
1483
1484 @SuppressWarnings("serial")
1485 class LocalClass implements Serializable {}
1486 var localClassName = of(LocalClass.class).getNameFull();
1487 assertTrue(localClassName.startsWith("org.apache.juneau.commons.reflect.ClassInfo_Test$"), "Should start with package and class name");
1488 assertTrue(localClassName.endsWith("LocalClass"), "Should end with LocalClass");
1489 }
1490
1491
1492
1493
1494 @Test
1495 void a038_getNameReadable() {
1496 assertEquals("AClass", aClass.getNameReadable());
1497 assertEquals("A1", aTypeInfo.getNameReadable());
1498 assertEquals("StringArray", ClassInfo.of(String[].class).getNameReadable());
1499 assertEquals("StringArrayArray", ClassInfo.of(String[][].class).getNameReadable());
1500 }
1501
1502
1503
1504
1505 @Test
1506 void a039_getNameShort() {
1507 assertEquals("AClass", aClass.getNameShort());
1508
1509 assertEquals("AClass", aClass.getNameShort());
1510
1511
1512 assertEquals("AClass[][]", of(AClass[][].class).getNameShort());
1513
1514
1515 assertEquals("ClassInfo_Test$J1", j1.getNameShort());
1516 assertEquals("ClassInfo_Test$J2", j2.getNameShort());
1517
1518
1519 assertEquals("ClassInfo_Test$J1[][]", j1_3d.getNameShort());
1520 assertEquals("ClassInfo_Test$J2[][]", j2_3d.getNameShort());
1521
1522
1523 assertEquals("int", of(int.class).getNameShort());
1524
1525
1526 assertEquals("int[][]", of(int[][].class).getNameShort());
1527
1528
1529 assertEquals("ClassInfo_Test$A1", aTypeInfo.getNameShort());
1530 assertEquals("Map<String,List<String>>", pTypeInfo.getNameShort());
1531 assertEquals("Map<String,String[][]>", pTypeDimensionalInfo.getNameShort());
1532 assertEquals("AbstractMap<K,V>", pTypeGenericInfo.getNameShort());
1533 assertEquals("V", pTypeGenericArgInfo.getNameShort());
1534
1535
1536 @SuppressWarnings("serial")
1537 class LocalClass implements Serializable {}
1538 assertEquals("ClassInfo_Test$LocalClass", of(LocalClass.class).getNameShort());
1539 }
1540
1541
1542
1543
1544 @Test
1545 void a040_getNameSimple() {
1546 assertEquals("AClass", aClass.getNameSimple());
1547
1548 assertEquals("AClass", aClass.getNameSimple());
1549
1550
1551 assertEquals("AClass[][]", of(AClass[][].class).getNameSimple());
1552
1553
1554 assertEquals("J1", j1.getNameSimple());
1555 assertEquals("J2", j2.getNameSimple());
1556
1557
1558 assertEquals("J1[][]", j1_3d.getNameSimple());
1559 assertEquals("J2[][]", j2_3d.getNameSimple());
1560
1561
1562 assertEquals("int", of(int.class).getNameSimple());
1563
1564
1565 assertEquals("int[][]", of(int[][].class).getNameSimple());
1566
1567
1568 assertEquals("A1", aTypeInfo.getNameSimple());
1569 assertEquals("Map", pTypeInfo.getNameSimple());
1570 assertEquals("Map", pTypeDimensionalInfo.getNameSimple());
1571 assertEquals("AbstractMap", pTypeGenericInfo.getNameSimple());
1572 assertEquals("V", pTypeGenericArgInfo.getNameSimple());
1573
1574
1575 @SuppressWarnings("serial")
1576 class LocalClass implements Serializable {}
1577 assertEquals("LocalClass", of(LocalClass.class).getNameSimple());
1578 }
1579
1580
1581
1582
1583 @Test
1584 void a041_getNames() {
1585 var names = aClass.getNames();
1586 assertNotNull(names);
1587 assertEquals(4, names.length);
1588 assertTrue(names[0].contains("AClass"));
1589 assertTrue(names[1].contains("AClass"));
1590 assertTrue(names[2].contains("AClass"));
1591 assertTrue(names[3].contains("AClass"));
1592 }
1593
1594
1595
1596
1597 @Test
1598 void a042_getNestHost() {
1599 var nestHost = aClass.getNestHost();
1600 assertNotNull(nestHost);
1601 assertEquals(aClass, nestHost);
1602
1603
1604 var nestHost2 = aTypeInfo.getNestHost();
1605 assertNotNull(nestHost2);
1606 assertEquals(ClassInfo_Test.class.getName(), nestHost2.inner().getName());
1607
1608
1609 assertNull(pTypeGenericArgInfo.getNestHost());
1610 }
1611
1612
1613
1614
1615 @Test
1616 void a043_getNestMembers() {
1617 var nestMembers = aClass.getNestMembers();
1618 assertNotNull(nestMembers);
1619
1620 assertFalse(nestMembers.isEmpty());
1621
1622
1623 var empty = pTypeGenericArgInfo.getNestMembers();
1624 assertTrue(empty.isEmpty());
1625 }
1626
1627
1628
1629
1630 @Test
1631 void a044_getNoArgConstructor() {
1632 check("E2()", e2.getNoArgConstructor(Visibility.PRIVATE).orElse(null));
1633 check("E2()", e2.getNoArgConstructor(Visibility.PROTECTED).orElse(null));
1634 check("E2()", e2.getNoArgConstructor(Visibility.DEFAULT).orElse(null));
1635 check(null, e2.getNoArgConstructor(Visibility.PUBLIC).orElse(null));
1636
1637
1638 check(null, e3.getNoArgConstructor(Visibility.PUBLIC).orElse(null));
1639
1640
1641 check("E4(ClassInfo_Test)", e4.getNoArgConstructor(Visibility.PUBLIC).orElse(null));
1642
1643
1644 check(null, e6.getNoArgConstructor(Visibility.PUBLIC).orElse(null));
1645 }
1646
1647
1648
1649
1650 @Test
1651 void a045_getPackage() {
1652 check("org.apache.juneau.commons.reflect", ka.getPackage().getName());
1653
1654 check("org.apache.juneau.commons.reflect", aTypeInfo.getPackage());
1655 check("java.util", pTypeInfo.getPackage());
1656 check("java.util", pTypeDimensionalInfo.getPackage());
1657 check("java.util", pTypeGenericInfo.getPackage());
1658 check(null, pTypeGenericArgInfo.getPackage());
1659
1660
1661
1662 var ci = ClassInfo.of((Class<?>)null, pType);
1663 assertNull(ci.getPackage());
1664
1665
1666 var intCi = ClassInfo.of(int.class);
1667 assertNull(intCi.getPackage());
1668
1669
1670 var intArrayCi = ClassInfo.of(int[].class);
1671 assertNull(intArrayCi.getPackage());
1672 }
1673
1674
1675
1676
1677 @Test
1678 void a046_getPackageAnnotation() {
1679 check("@PA(10)", g3.getPackageAnnotation(PA.class));
1680
1681 check("@PA(10)", aTypeInfo.getPackageAnnotation(PA.class));
1682 check(null, pTypeInfo.getPackageAnnotation(PA.class));
1683 check(null, pTypeDimensionalInfo.getPackageAnnotation(PA.class));
1684 check(null, pTypeGenericInfo.getPackageAnnotation(PA.class));
1685 check(null, pTypeGenericArgInfo.getPackageAnnotation(PA.class));
1686 }
1687
1688
1689
1690
1691 @Test
1692 void a047_getParameterType() {
1693
1694
1695
1696
1697
1698 check("String", ma.getParameterType(0, HashMap.class));
1699 check("Integer", ma.getParameterType(1, HashMap.class));
1700 check("String", mb.getParameterType(0, HashMap.class));
1701 check("Integer", mb.getParameterType(1, HashMap.class));
1702
1703
1704 assertThrowsWithMessage(IllegalArgumentException.class, "Invalid type index. index=2, argsLength=2", () -> ma.getParameterType(2, HashMap.class));
1705
1706
1707 assertThrowsWithMessage(IllegalArgumentException.class, "Class 'AClass' is not a subclass of parameterized type 'HashMap'", () -> aClass.getParameterType(2, HashMap.class));
1708
1709
1710 assertThrowsWithMessage(IllegalArgumentException.class, "Argument 'pt' cannot be null.", () -> aClass.getParameterType(2, null));
1711
1712
1713 assertThrowsWithMessage(IllegalArgumentException.class, "Class 'MA' is not a parameterized type", () -> mb.getParameterType(2, MA.class));
1714
1715
1716 assertThrowsWithMessage(IllegalArgumentException.class, "Could not resolve variable 'E' to a type.", () -> mc.getParameterType(1, HashMap.class));
1717
1718
1719 check("Integer", md.getParameterType(1, HashMap.class));
1720
1721
1722 check("HashMap", me.getParameterType(1, HashMap.class));
1723
1724
1725 check("String[]", mf.getParameterType(1, HashMap.class));
1726
1727
1728 check("HashMap[]", mg.getParameterType(1, HashMap.class));
1729
1730
1731 check("LinkedList[]", mh.getParameterType(1, HashMap.class));
1732
1733
1734 assertThrowsWithMessage(IllegalArgumentException.class, "Could not resolve variable 'X[]' to a type.", () -> mi.getParameterType(1, HashMap.class));
1735
1736
1737 assertThrowsWithMessage(IllegalArgumentException.class, "Could not resolve variable 'X' to a type.", () -> mj.getParameterType(1, HashMap.class));
1738
1739
1740 check("MK", ml.getParameterType(1, HashMap.class));
1741
1742
1743 check("MM", mn.getParameterType(1, HashMap.class));
1744
1745
1746
1747
1748
1749
1750
1751 }
1752
1753
1754
1755
1756 @Test
1757 void a048_getParents() {
1758 check("BC3,BC2,BC1", bc3.getParents());
1759 check("", object.getParents());
1760 check("BI1", bi1.getParents());
1761 }
1762
1763
1764
1765
1766 @Test
1767 void a049_getParentsAndInterfaces() {
1768 var ci = ClassInfo.of(Child.class);
1769 var parentsAndInterfaces = ci.getParentsAndInterfaces();
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781 var names = parentsAndInterfaces.stream().map(ClassInfo::getNameSimple).collect(Collectors.toList());
1782
1783
1784 assertTrue(names.contains("Child"), "Should include Child itself");
1785 assertTrue(names.contains("Parent"), "Should include Parent");
1786 assertTrue(names.contains("GrandParent"), "Should include GrandParent");
1787 assertTrue(names.contains("IChild"), "Should include IChild");
1788 assertTrue(names.contains("IParent"), "Should include IParent from Parent");
1789 assertTrue(names.contains("ISuperParent"), "Should include ISuperParent from IParent hierarchy");
1790 assertTrue(names.contains("IGrandParent"), "Should include IGrandParent from GrandParent");
1791 assertTrue(names.contains("ISuperGrandParent"), "Should include ISuperGrandParent from IGrandParent hierarchy");
1792 }
1793
1794
1795
1796 public static sealed class SealedTestClass permits SealedSubclass1, SealedSubclass2 {
1797 }
1798
1799 public static final class SealedSubclass1 extends SealedTestClass {
1800 }
1801
1802 public static final class SealedSubclass2 extends SealedTestClass {
1803 }
1804
1805
1806
1807 public static record TestRecord(String name, int value) {
1808 }
1809
1810
1811
1812
1813 @Test
1814 void a050_getPermittedSubclasses() {
1815
1816 var permitted = aClass.getPermittedSubclasses();
1817 assertNotNull(permitted);
1818 assertTrue(permitted.isEmpty());
1819
1820
1821 var ci = ClassInfo.of((Class<?>)null, pType);
1822 var empty = ci.getPermittedSubclasses();
1823 assertNotNull(empty);
1824 assertTrue(empty.isEmpty());
1825
1826
1827
1828 try {
1829 Class.forName("java.lang.constant.Constable");
1830
1831 var sealedInfo = ClassInfo.of(SealedTestClass.class);
1832 var permittedSubclasses = sealedInfo.getPermittedSubclasses();
1833 assertNotNull(permittedSubclasses);
1834 assertFalse(permittedSubclasses.isEmpty());
1835
1836 var subclassNames = permittedSubclasses.stream()
1837 .map(ClassInfo::getNameSimple)
1838 .collect(Collectors.toSet());
1839 assertTrue(subclassNames.contains("SealedSubclass1"));
1840 assertTrue(subclassNames.contains("SealedSubclass2"));
1841 } catch (ClassNotFoundException e) {
1842
1843 }
1844 }
1845
1846
1847
1848
1849 @Test
1850 void a050b_getProtectionDomain() {
1851
1852
1853 assertDoesNotThrow(() -> aClass.getProtectionDomain());
1854
1855
1856 var ci = ClassInfo.of((Class<?>)null, pType);
1857 assertNull(ci.getProtectionDomain());
1858 }
1859
1860
1861
1862
1863 @Test
1864 void a051_getPrimitiveDefault() {
1865 for (var i = 0; i < primitives.size(); i++)
1866 assertEquals(of(primitives.get(i)).getPrimitiveDefault(), primitiveDefaults.get(i));
1867 assertNull(of(String.class).getPrimitiveDefault());
1868
1869 assertNull(aTypeInfo.getPrimitiveDefault());
1870 }
1871
1872
1873
1874
1875 @Test
1876 void a052_getPrimitiveForWrapper() {
1877 for (var i = 0; i < primitives.size(); i++)
1878 assertEquals(of(primitiveWrappers.get(i)).getPrimitiveForWrapper(), primitives.get(i));
1879 assertNull(of(String.class).getPrimitiveForWrapper());
1880
1881 assertNull(aTypeInfo.getPrimitiveForWrapper());
1882 }
1883
1884
1885
1886
1887 @Test
1888 void a053_getPrimitiveWrapper() {
1889 for (var i = 0; i < primitives.size(); i++)
1890 assertEquals(of(primitives.get(i)).getPrimitiveWrapper(), primitiveWrappers.get(i));
1891 assertNull(of(String.class).getPrimitiveWrapper());
1892
1893 assertNull(aTypeInfo.getPrimitiveWrapper());
1894 }
1895
1896
1897
1898
1899 @Test
1900 void a054_getPublicConstructor() {
1901 check("E1(String)", e1.getPublicConstructor(x -> x.hasParameterTypes(String.class)).orElse(null));
1902 check("E1(String)", e1.getPublicConstructor(x -> x.canAccept("foo")).orElse(null));
1903 check("E1()", e1.getPublicConstructor(cons -> cons.getParameterCount() == 0).orElse(null));
1904 }
1905
1906
1907
1908
1909 @Test
1910 void a055_getPublicConstructors() {
1911 check("E1(),E1(Writer),E1(String),E1(String,Writer)", e1.getPublicConstructors());
1912
1913 check("E1(),E1(Writer),E1(String),E1(String,Writer)", e1.getPublicConstructors());
1914
1915
1916 check("A1(ClassInfo_Test)", aTypeInfo.getPublicConstructors());
1917 check("", pTypeInfo.getPublicConstructors());
1918 check("", pTypeDimensionalInfo.getPublicConstructors());
1919 check("", pTypeGenericInfo.getPublicConstructors());
1920 check("", pTypeGenericArgInfo.getPublicConstructors());
1921 }
1922
1923
1924
1925
1926 @Test
1927 void a056_getPublicField() {
1928 check("F3.a1", f3.getPublicField(x -> x.hasName("a1")).orElse(null));
1929 check(null, f3.getPublicField(x -> x.hasName("a2")).orElse(null));
1930 check(null, f3.getPublicField(x -> x.hasName("a3")).orElse(null));
1931 }
1932
1933
1934
1935
1936 @Test
1937 void a057_getPublicFields() {
1938 check("F2.f1a,F1.f1b,F2.f2b", f2.getPublicFields());
1939
1940 check("F2.f1a,F1.f1b,F2.f2b", f2.getPublicFields());
1941
1942
1943 check("", aTypeInfo.getPublicFields());
1944 check("", pTypeGenericArgInfo.getPublicFields());
1945
1946
1947
1948
1949
1950
1951 var emptyFields = ClassInfo.of(Object.class).getPublicFields();
1952 assertNotNull(emptyFields);
1953
1954 }
1955
1956
1957
1958
1959 @Test
1960 void a057b_getResource() {
1961
1962
1963 assertDoesNotThrow(() -> aClass.getResource("/"));
1964
1965
1966 var ci = ClassInfo.of((Class<?>)null, pType);
1967 assertNull(ci.getResource("test"));
1968 }
1969
1970
1971
1972
1973 @Test
1974 void a057c_getResourceAsStream() {
1975
1976 var stream = aClass.getResourceAsStream("/");
1977
1978 if (stream != null) {
1979 assertDoesNotThrow(() -> stream.close());
1980 }
1981
1982
1983 var ci = ClassInfo.of((Class<?>)null, pType);
1984 assertNull(ci.getResourceAsStream("test"));
1985 }
1986
1987
1988
1989
1990 @Test
1991 void a058_getPublicMethod() {
1992 var method = cc3.getPublicMethod(x -> x.hasName("c3a"));
1993 assertTrue(method.isPresent());
1994 assertEquals("c3a", method.get().getName());
1995
1996
1997 var method2 = cc3.getPublicMethod(x -> x.hasName("nonexistent"));
1998 assertFalse(method2.isPresent());
1999 }
2000
2001
2002
2003
2004 @Test
2005 void a059_getPublicMethods() {
2006 check("CC3.c1a(),CC3.c2b(),CC3.c3a(),CC3.i1a(),CC3.i1b(),CC3.i2a(),CC3.i2b()", cc3.getPublicMethods());
2007 check("CI2.i1a(),CI2.i1b(),CI2.i2a(),CI2.i2b()", ci2.getPublicMethods());
2008
2009 check("CI2.i1a(),CI2.i1b(),CI2.i2a(),CI2.i2b()", ci2.getPublicMethods());
2010
2011
2012 check("", aTypeInfo.getPublicMethods());
2013 check("", pTypeGenericArgInfo.getPublicMethods());
2014 }
2015
2016
2017
2018
2019 @Test
2020 void a060_getRecordComponents() {
2021
2022 try {
2023 Class.forName("java.lang.Record");
2024
2025
2026 assertTrue(cc3.getRecordComponents().isEmpty());
2027 } catch (ClassNotFoundException e) {
2028
2029 assertTrue(cc3.getRecordComponents().isEmpty());
2030 }
2031
2032
2033
2034 var ci = ClassInfo.of((Class<?>)null, pType);
2035 assertTrue(ci.getRecordComponents().isEmpty());
2036
2037
2038 assertTrue(aClass.getRecordComponents().isEmpty());
2039 }
2040
2041
2042
2043
2044 @Test
2045 void a061_getRepeatedAnnotationMethod() {
2046
2047 var repeatable = ClassInfo.of(Repeatable.class);
2048 var method = repeatable.getRepeatedAnnotationMethod();
2049
2050 assertNull(method);
2051
2052
2053
2054 assertFalse(repeatable.isRepeatedAnnotation());
2055
2056
2057
2058
2059 var container = ClassInfo.of(TestRepeatableContainer.class);
2060 var containerMethod = container.getRepeatedAnnotationMethod();
2061 assertNotNull(containerMethod);
2062 assertTrue(container.isRepeatedAnnotation());
2063
2064
2065
2066
2067 var nonRepeatableContainer = ClassInfo.of(NonRepeatableArrayContainer.class);
2068 assertNull(nonRepeatableContainer.getRepeatedAnnotationMethod());
2069
2070
2071
2072
2073
2074
2075
2076
2077 var wrongContainer = ClassInfo.of(WrongContainer.class);
2078 assertNull(wrongContainer.getRepeatedAnnotationMethod());
2079
2080
2081 assertFalse(aClass.isRepeatedAnnotation());
2082 }
2083
2084
2085
2086
2087 @Test
2088 void a062_getSigners() {
2089 var signers = aClass.getSigners();
2090 assertNotNull(signers);
2091
2092 assertTrue(signers.isEmpty() || !signers.isEmpty());
2093
2094
2095
2096 var ci = ClassInfo.of((Class<?>)null, pType);
2097 assertTrue(ci.getSigners().isEmpty());
2098
2099
2100
2101
2102 }
2103
2104
2105
2106
2107 @Test
2108 void a063_getSuperclass() {
2109 check("BC2", bc3.getSuperclass());
2110 check("BC1", bc2.getSuperclass());
2111 check("Object", bc1.getSuperclass());
2112 check(null, object.getSuperclass());
2113 check(null, bi2.getSuperclass());
2114 check(null, bi1.getSuperclass());
2115
2116 check("Object", aTypeInfo.getSuperclass());
2117 check(null, pTypeInfo.getSuperclass());
2118 check(null, pTypeDimensionalInfo.getSuperclass());
2119 check("Object", pTypeGenericInfo.getSuperclass());
2120 check(null, pTypeGenericArgInfo.getSuperclass());
2121 }
2122
2123
2124
2125
2126 @Test
2127 void a064_getTypeParameters() {
2128 var params = mc.getTypeParameters();
2129 assertNotNull(params);
2130
2131 assertEquals(2, params.size());
2132 }
2133
2134
2135
2136
2137 @Test
2138 void a065_getWrapperIfPrimitive() {
2139 for (var i = 0; i < primitives.size(); i++)
2140 assertEquals(of(primitives.get(i)).getWrapperIfPrimitive().inner(), primitiveWrappers.get(i));
2141 assertEquals(of(String.class).getWrapperIfPrimitive().inner(), String.class);
2142
2143 assertEquals("class org.apache.juneau.commons.reflect.ClassInfo_Test$A1", aTypeInfo.getWrapperIfPrimitive().inner().toString());
2144 assertEquals("interface java.util.Map", pTypeInfo.getWrapperIfPrimitive().inner().toString());
2145 assertEquals("interface java.util.Map", pTypeDimensionalInfo.getWrapperIfPrimitive().inner().toString());
2146 assertEquals("class java.util.AbstractMap", pTypeGenericInfo.getWrapperIfPrimitive().inner().toString());
2147 assertEquals(null, pTypeGenericArgInfo.getWrapperIfPrimitive().inner());
2148 assertEquals(aTypeInfo.getWrapperIfPrimitive().innerType(), aType);
2149 check("V", pTypeGenericArgInfo.getWrapperIfPrimitive());
2150 }
2151
2152
2153
2154
2155 @Test
2156 void a066_hasAnnotation() {
2157 assertTrue(g3.hasAnnotation(A.class));
2158 assertFalse(g3.hasAnnotation(B.class));
2159 assertThrows(IllegalArgumentException.class, () -> g3.hasAnnotation(null));
2160 }
2161
2162
2163
2164
2165 @Test
2166 void a067_hasPackage() {
2167 assertTrue(ka.hasPackage());
2168
2169 assertTrue(aTypeInfo.hasPackage());
2170 assertTrue(pTypeInfo.hasPackage());
2171 assertTrue(pTypeDimensionalInfo.hasPackage());
2172 assertTrue(pTypeGenericInfo.hasPackage());
2173 assertFalse(pTypeGenericArgInfo.hasPackage());
2174 }
2175
2176
2177
2178
2179 @Test
2180 void a068_hasPrimitiveWrapper() {
2181 for (var c : primitives)
2182 assertTrue(of(c).hasPrimitiveWrapper());
2183 for (var c : primitiveWrappers)
2184 assertFalse(of(c).hasPrimitiveWrapper());
2185
2186 assertFalse(aTypeInfo.hasPrimitiveWrapper());
2187 }
2188
2189
2190
2191
2192 @Test
2193 void a069_inner() {
2194 assertNotNull(of(A1.class).inner());
2195 assertTrue(of(A1.class).innerType() instanceof Class);
2196 }
2197
2198
2199
2200
2201 @Test
2202 void a070_innerType() {
2203 assertTrue(of(A1.class).innerType() instanceof Class);
2204 assertNotNull(aTypeInfo.innerType());
2205 assertNotNull(pTypeInfo.innerType());
2206 }
2207
2208
2209
2210
2211 @Test
2212 void a071_is() {
2213 assertTrue(ka.is(KA.class));
2214 assertFalse(ka.is(KB.class));
2215 assertFalse(ka.is(KC.class));
2216 assertFalse(kb.is(KA.class));
2217 assertTrue(kb.is(KB.class));
2218 assertFalse(kb.is(KC.class));
2219 assertFalse(kc.is(KA.class));
2220 assertFalse(kc.is(KB.class));
2221 assertTrue(kc.is(KC.class));
2222
2223
2224 assertTrue(ka.is(of(KA.class)));
2225 assertFalse(ka.is(of(KB.class)));
2226 assertFalse(ka.is(of(KC.class)));
2227 assertFalse(kb.is(of(KA.class)));
2228 assertTrue(kb.is(of(KB.class)));
2229 assertFalse(kb.is(of(KC.class)));
2230 assertFalse(kc.is(of(KA.class)));
2231 assertFalse(kc.is(of(KB.class)));
2232 assertTrue(kc.is(of(KC.class)));
2233
2234
2235 assertFalse(aTypeInfo.is(KA.class));
2236 assertFalse(pTypeInfo.is(KA.class));
2237 assertFalse(pTypeDimensionalInfo.is(KA.class));
2238 assertFalse(pTypeGenericInfo.is(KA.class));
2239 assertFalse(pTypeGenericArgInfo.is(KA.class));
2240 assertFalse(pTypeGenericArgInfo.is(of(KA.class)));
2241
2242
2243 assertTrue(aClass.is(ElementFlag.CLASS));
2244 assertTrue(aClass.is(NOT_ANNOTATION));
2245 assertTrue(aClass.is(NOT_ARRAY));
2246 assertTrue(aClass.is(NOT_ENUM));
2247 assertTrue(aClass.is(NOT_LOCAL));
2248 assertTrue(aClass.is(NOT_MEMBER));
2249 assertTrue(aClass.is(NOT_NON_STATIC_MEMBER));
2250 assertTrue(aClass.is(NOT_PRIMITIVE));
2251 assertTrue(aClass.is(NOT_RECORD));
2252 assertTrue(aClass.is(NOT_SEALED));
2253 assertTrue(aClass.is(NOT_SYNTHETIC));
2254
2255
2256
2257 assertTrue(ClassInfo.of(A.class).is(ANNOTATION));
2258 assertFalse(aClass.is(ANNOTATION));
2259
2260
2261
2262 assertTrue(aClass.is(NOT_ANNOTATION));
2263
2264 assertFalse(ClassInfo.of(A.class).is(NOT_ANNOTATION));
2265
2266
2267
2268 assertTrue(aClass.is(NOT_ANONYMOUS));
2269
2270 var anonymous = new Object() {}.getClass();
2271 var anonymousInfo = ClassInfo.of(anonymous);
2272 if (anonymousInfo.isAnonymousClass()) {
2273 assertTrue(anonymousInfo.is(ANONYMOUS));
2274 assertFalse(anonymousInfo.is(NOT_ANONYMOUS));
2275 }
2276
2277
2278 assertTrue(ClassInfo.of(String[].class).is(ARRAY));
2279 assertFalse(aClass.is(ARRAY));
2280
2281
2282
2283 assertTrue(aClass.is(NOT_ARRAY));
2284
2285 assertFalse(ClassInfo.of(String[].class).is(NOT_ARRAY));
2286
2287
2288 assertTrue(ClassInfo.of(ClassArrayFormat.class).is(ENUM));
2289 assertFalse(aClass.is(ENUM));
2290
2291
2292
2293 assertTrue(aClass.is(NOT_ENUM));
2294
2295 assertFalse(ClassInfo.of(ClassArrayFormat.class).is(NOT_ENUM));
2296
2297
2298
2299 class LocalTestClass {}
2300 var localInfo = ClassInfo.of(LocalTestClass.class);
2301 assertTrue(localInfo.is(LOCAL));
2302 assertFalse(localInfo.is(NOT_LOCAL));
2303 assertTrue(aClass.is(NOT_LOCAL));
2304 assertFalse(aClass.is(LOCAL));
2305
2306
2307
2308 var nonStaticMember = ClassInfo.of(H_PublicMember.class);
2309 assertTrue(nonStaticMember.is(NON_STATIC_MEMBER));
2310 assertFalse(nonStaticMember.is(NOT_NON_STATIC_MEMBER));
2311 assertTrue(aClass.is(NOT_NON_STATIC_MEMBER));
2312 assertFalse(aClass.is(NON_STATIC_MEMBER));
2313
2314
2315 assertTrue(ClassInfo.of(int.class).is(PRIMITIVE));
2316 assertFalse(aClass.is(PRIMITIVE));
2317
2318
2319 assertTrue(aClass.is(NOT_PRIMITIVE));
2320 assertFalse(ClassInfo.of(int.class).is(NOT_PRIMITIVE));
2321
2322
2323 try {
2324 Class.forName("java.lang.Record");
2325
2326
2327 assertFalse(aClass.is(RECORD));
2328 } catch (ClassNotFoundException e) {
2329
2330 }
2331
2332
2333
2334 assertTrue(aClass.is(NOT_RECORD));
2335
2336 try {
2337 Class.forName("java.lang.Record");
2338
2339 var recordInfo = ClassInfo.of(TestRecord.class);
2340 assertTrue(recordInfo.is(RECORD));
2341 assertFalse(recordInfo.is(NOT_RECORD));
2342 } catch (ClassNotFoundException e) {
2343
2344 }
2345
2346
2347 try {
2348 Class.forName("java.lang.constant.Constable");
2349
2350
2351 assertFalse(aClass.is(SEALED));
2352
2353 var sealedInfo = ClassInfo.of(SealedTestClass.class);
2354 assertTrue(sealedInfo.is(SEALED));
2355 } catch (ClassNotFoundException e) {
2356
2357 }
2358
2359
2360
2361 assertTrue(aClass.is(NOT_SEALED));
2362
2363 try {
2364 Class.forName("java.lang.constant.Constable");
2365
2366 var sealedInfo = ClassInfo.of(SealedTestClass.class);
2367 assertFalse(sealedInfo.is(NOT_SEALED));
2368 } catch (ClassNotFoundException e) {
2369
2370 }
2371
2372
2373
2374 assertFalse(aClass.is(SYNTHETIC));
2375
2376
2377 if (anonymousInfo.isAnonymousClass()) {
2378
2379
2380 anonymousInfo.is(SYNTHETIC);
2381 }
2382
2383
2384 assertTrue(aClass.is(NOT_SYNTHETIC));
2385 }
2386
2387
2388
2389
2390 @Test
2391 void a072_isAbstract() {
2392 assertTrue(hAbstractPublic.isAbstract());
2393 assertFalse(pTypeGenericArgInfo.isAbstract());
2394
2395 assertFalse(aTypeInfo.isAbstract());
2396 }
2397
2398
2399
2400
2401 @Test
2402 void a073_isAll() {
2403 assertTrue(h2a.isAll(DEPRECATED, PUBLIC, STATIC, MEMBER, ABSTRACT, ElementFlag.CLASS));
2404 assertTrue(h2b.isAll(NOT_DEPRECATED, NOT_PUBLIC, STATIC, ABSTRACT, INTERFACE));
2405
2406 assertTrue(aTypeInfo.isAll(PUBLIC, MEMBER, ElementFlag.CLASS));
2407 assertFalse(pTypeInfo.isAll(PUBLIC, MEMBER, ElementFlag.CLASS));
2408 assertFalse(pTypeDimensionalInfo.isAll(PUBLIC, MEMBER, ElementFlag.CLASS));
2409 assertFalse(pTypeGenericInfo.isAll(PUBLIC, MEMBER, ElementFlag.CLASS));
2410
2411
2412 assertTrue(h2Deprecated.is(DEPRECATED));
2413 assertFalse(h2NotDeprecated.is(DEPRECATED));
2414 assertFalse(h2Deprecated.is(NOT_DEPRECATED));
2415 assertTrue(h2NotDeprecated.is(NOT_DEPRECATED));
2416 assertTrue(of(H2_Public.class).is(PUBLIC));
2417 assertFalse(h2NotPublic.is(PUBLIC));
2418 assertFalse(of(H2_Public.class).is(NOT_PUBLIC));
2419 assertTrue(h2NotPublic.is(NOT_PUBLIC));
2420 assertTrue(of(H2_Static.class).is(STATIC));
2421 assertFalse(h2NotStatic.is(STATIC));
2422 assertFalse(of(H2_Static.class).is(NOT_STATIC));
2423 assertTrue(h2NotStatic.is(NOT_STATIC));
2424 assertTrue(h2Member.is(MEMBER));
2425 assertTrue(h2StaticMember.is(MEMBER));
2426 assertFalse(aClass.is(MEMBER));
2427 assertFalse(h2Member.is(NOT_MEMBER));
2428 assertFalse(h2StaticMember.is(NOT_MEMBER));
2429 assertTrue(aClass.is(NOT_MEMBER));
2430 assertTrue(of(H2_Abstract.class).is(ABSTRACT));
2431 assertFalse(h2NotAbstract.is(ABSTRACT));
2432 assertTrue(aInterface.is(ABSTRACT));
2433 assertFalse(of(H2_Abstract.class).is(NOT_ABSTRACT));
2434 assertTrue(h2NotAbstract.is(NOT_ABSTRACT));
2435 assertFalse(aInterface.is(NOT_ABSTRACT));
2436 assertTrue(aInterface.is(INTERFACE));
2437 assertFalse(aClass.is(INTERFACE));
2438 assertFalse(aInterface.is(ElementFlag.CLASS));
2439 assertTrue(aClass.is(ElementFlag.CLASS));
2440 }
2441
2442
2443
2444
2445 @Test
2446 void a074_isAnnotation() {
2447 assertTrue(ClassInfo.of(A.class).isAnnotation());
2448 assertTrue(ClassInfo.of(B.class).isAnnotation());
2449 assertFalse(aClass.isAnnotation());
2450
2451
2452 var ci = ClassInfo.of((Class<?>)null, pType);
2453 assertFalse(ci.isAnnotation());
2454 }
2455
2456
2457
2458
2459 @Test
2460 void a075_isAny() {
2461 assertTrue(ka.isAny(KA.class));
2462 assertTrue(ka.isAny(KA.class, KB.class));
2463 assertFalse(ka.isAny(KB.class));
2464 assertFalse(ka.isAny(KC.class));
2465 assertFalse(kb.isAny(KA.class));
2466 assertTrue(kb.isAny(KB.class));
2467 assertFalse(kb.isAny(KC.class));
2468 assertFalse(kc.isAny(KA.class));
2469 assertFalse(kc.isAny(KB.class));
2470 assertTrue(kc.isAny(KC.class));
2471 }
2472
2473
2474
2475
2476 @Test
2477 void a075a_isAny_twoParameters() {
2478
2479 assertTrue(ka.isAny(KA.class, KB.class));
2480
2481 assertTrue(kb.isAny(KA.class, KB.class));
2482
2483 assertFalse(ka.isAny(Integer.class, String.class));
2484 assertFalse(kb.isAny(Integer.class, String.class));
2485 assertFalse(kc.isAny(Integer.class, String.class));
2486
2487 assertTrue(ka.isAny(KA.class, KA.class));
2488
2489 assertFalse(ka.isAny(null, null));
2490
2491 assertTrue(ka.isAny(KA.class, String.class));
2492 assertTrue(ka.isAny(String.class, KA.class));
2493 }
2494
2495
2496
2497
2498 @Test
2499 void a075b_isAny_threeParameters() {
2500
2501 assertTrue(ka.isAny(KA.class, KB.class, KC.class));
2502
2503 assertTrue(kb.isAny(KA.class, KB.class, KC.class));
2504
2505 assertTrue(kc.isAny(KA.class, KB.class, KC.class));
2506
2507 assertFalse(ka.isAny(Integer.class, Double.class, String.class));
2508 assertFalse(kb.isAny(Integer.class, Double.class, String.class));
2509 assertFalse(kc.isAny(Integer.class, Double.class, String.class));
2510
2511 assertTrue(ka.isAny(KA.class, KA.class, KA.class));
2512
2513 assertFalse(ka.isAny(null, null, null));
2514
2515 assertTrue(ka.isAny(KA.class, String.class, Integer.class));
2516 assertTrue(kb.isAny(String.class, KB.class, Integer.class));
2517 assertTrue(kc.isAny(String.class, Integer.class, KC.class));
2518 }
2519
2520
2521
2522
2523 @Test
2524 void a075c_isAny_fourParameters() {
2525
2526 assertTrue(ka.isAny(KA.class, KB.class, KC.class, String.class));
2527
2528 assertTrue(kb.isAny(KA.class, KB.class, KC.class, String.class));
2529
2530 assertTrue(kc.isAny(KA.class, KB.class, KC.class, String.class));
2531
2532 assertTrue(ClassInfo.of(String.class).isAny(KA.class, KB.class, KC.class, String.class));
2533
2534 assertFalse(ka.isAny(Integer.class, Double.class, Float.class, Long.class));
2535 assertFalse(kb.isAny(Integer.class, Double.class, Float.class, Long.class));
2536 assertFalse(kc.isAny(Integer.class, Double.class, Float.class, Long.class));
2537
2538 assertTrue(ka.isAny(KA.class, KA.class, KA.class, KA.class));
2539
2540 assertFalse(ka.isAny(null, null, null, null));
2541 }
2542
2543
2544
2545
2546 @Test
2547 void a075d_isAny_fiveParameters() {
2548
2549 assertTrue(ka.isAny(KA.class, KB.class, KC.class, String.class, Integer.class));
2550
2551 assertTrue(kb.isAny(KA.class, KB.class, KC.class, String.class, Integer.class));
2552
2553 assertTrue(kc.isAny(KA.class, KB.class, KC.class, String.class, Integer.class));
2554
2555 assertTrue(ClassInfo.of(String.class).isAny(KA.class, KB.class, KC.class, String.class, Integer.class));
2556
2557 assertTrue(ClassInfo.of(Integer.class).isAny(KA.class, KB.class, KC.class, String.class, Integer.class));
2558
2559 assertFalse(ka.isAny(Double.class, Float.class, Long.class, Boolean.class, Character.class));
2560 assertFalse(kb.isAny(Double.class, Float.class, Long.class, Boolean.class, Character.class));
2561 assertFalse(kc.isAny(Double.class, Float.class, Long.class, Boolean.class, Character.class));
2562
2563 assertTrue(ka.isAny(KA.class, KA.class, KA.class, KA.class, KA.class));
2564
2565 assertFalse(ka.isAny(null, null, null, null, null));
2566 }
2567
2568
2569
2570
2571 @Test
2572 void a076_isArray() {
2573 assertTrue(ClassInfo.of(String[].class).isArray());
2574 assertTrue(ClassInfo.of(int[].class).isArray());
2575 assertFalse(aClass.isArray());
2576
2577
2578 var ci = ClassInfo.of((Class<?>)null, pType);
2579 assertFalse(ci.isArray());
2580 }
2581
2582
2583
2584
2585 @Test
2586 void a076b_isAnonymousClass() {
2587
2588 assertFalse(aClass.isAnonymousClass());
2589
2590
2591 var ci = ClassInfo.of((Class<?>)null, pType);
2592 assertFalse(ci.isAnonymousClass());
2593 }
2594
2595
2596
2597
2598 @Test
2599 void a076c_isCollectionOrArray() {
2600
2601 assertTrue(ClassInfo.of(String[].class).isCollectionOrArray());
2602 assertTrue(ClassInfo.of(int[].class).isCollectionOrArray());
2603
2604
2605 assertTrue(ClassInfo.of(java.util.List.class).isCollectionOrArray());
2606 assertTrue(ClassInfo.of(java.util.Set.class).isCollectionOrArray());
2607 assertTrue(ClassInfo.of(java.util.Collection.class).isCollectionOrArray());
2608
2609
2610 assertFalse(aClass.isCollectionOrArray());
2611 assertFalse(ClassInfo.of(String.class).isCollectionOrArray());
2612
2613
2614 var ci = ClassInfo.of((Class<?>)null, pType);
2615 assertFalse(ci.isCollectionOrArray());
2616 }
2617
2618
2619
2620
2621 @Test
2622 void a077_isChildOf() {
2623 assertTrue(ka.isChildOf(KA.class));
2624 assertFalse(ka.isChildOf(KB.class));
2625 assertFalse(ka.isChildOf(KC.class));
2626 assertTrue(kb.isChildOf(KA.class));
2627 assertTrue(kb.isChildOf(KB.class));
2628 assertFalse(kb.isChildOf(KC.class));
2629 assertTrue(kc.isChildOf(KA.class));
2630 assertTrue(kc.isChildOf(KB.class));
2631 assertTrue(kc.isChildOf(KC.class));
2632
2633 assertFalse(ka.isChildOf((Class<?>)null));
2634
2635 assertFalse(ka.isChildOf(aType));
2636 assertFalse(ka.isChildOf(pType));
2637 assertFalse(ka.isChildOf(pTypeDimensional));
2638 assertFalse(ka.isChildOf(pTypeGeneric));
2639 assertFalse(ka.isChildOf(pTypeGenericArg));
2640 assertFalse(aTypeInfo.isChildOf(KA.class));
2641 assertFalse(pTypeInfo.isChildOf(KA.class));
2642 assertFalse(pTypeDimensionalInfo.isChildOf(KA.class));
2643 assertFalse(pTypeGenericInfo.isChildOf(KA.class));
2644 assertFalse(pTypeGenericArgInfo.isChildOf(KA.class));
2645
2646
2647 assertTrue(kb.isChildOf(ka));
2648 assertTrue(kc.isChildOf(ka));
2649 assertTrue(kc.isChildOf(kb));
2650 assertFalse(ka.isChildOf(kb));
2651 }
2652
2653
2654
2655
2656 @Test
2657 void a078_isChildOfAny() {
2658 assertTrue(ka.isChildOfAny(KA.class));
2659 assertFalse(ka.isChildOfAny(KB.class));
2660 assertFalse(ka.isChildOfAny(KC.class));
2661 assertTrue(kb.isChildOfAny(KA.class));
2662 assertTrue(kb.isChildOfAny(KB.class));
2663 assertFalse(kb.isChildOfAny(KC.class));
2664 assertTrue(kc.isChildOfAny(KA.class));
2665 assertTrue(kc.isChildOfAny(KB.class));
2666 assertTrue(kc.isChildOfAny(KC.class));
2667
2668 assertFalse(aTypeInfo.isChildOfAny(KA.class));
2669 assertFalse(pTypeInfo.isChildOfAny(KA.class));
2670 assertFalse(pTypeDimensionalInfo.isChildOfAny(KA.class));
2671 assertFalse(pTypeGenericInfo.isChildOfAny(KA.class));
2672 assertFalse(pTypeGenericArgInfo.isChildOfAny(KA.class));
2673 }
2674
2675
2676
2677
2678 @Test
2679 void a079_isClass() {
2680 assertTrue(aClass.isClass());
2681 assertFalse(aInterface.isClass());
2682
2683 assertTrue(aTypeInfo.isClass());
2684 assertFalse(pTypeInfo.isClass());
2685 assertFalse(pTypeDimensionalInfo.isClass());
2686 assertTrue(pTypeGenericInfo.isClass());
2687 assertFalse(pTypeGenericArgInfo.isClass());
2688 }
2689
2690
2691
2692
2693 @Test
2694 void a080_isDeprecated() {
2695 assertFalse(hPublic.isDeprecated());
2696 assertTrue(hPublicDeprecated.isDeprecated());
2697
2698 assertFalse(aTypeInfo.isDeprecated());
2699 assertFalse(pTypeGenericArgInfo.isDeprecated());
2700 }
2701
2702
2703
2704
2705 @Test
2706 void a081_isEnum() {
2707 assertTrue(ClassInfo.of(ClassArrayFormat.class).isEnum());
2708 assertFalse(aClass.isEnum());
2709
2710
2711 var ci = ClassInfo.of((Class<?>)null, pType);
2712 assertFalse(ci.isEnum());
2713 }
2714
2715
2716
2717
2718 @Test
2719 void a081b_isInstance() {
2720
2721 assertTrue(ClassInfo.of(String.class).isInstance("test"));
2722 assertTrue(ClassInfo.of(Number.class).isInstance(42));
2723
2724
2725 assertFalse(ClassInfo.of(String.class).isInstance(42));
2726 assertFalse(ClassInfo.of(Number.class).isInstance("test"));
2727
2728
2729 assertFalse(ClassInfo.of(String.class).isInstance(null));
2730
2731
2732 var ci = ClassInfo.of((Class<?>)null, pType);
2733 assertFalse(ci.isInstance("test"));
2734 assertFalse(ci.isInstance(null));
2735 }
2736
2737
2738
2739
2740 @Test
2741 void a082_isInterface() {
2742 assertTrue(aInterface.isInterface());
2743 assertFalse(aClass.isInterface());
2744
2745 assertFalse(aTypeInfo.isInterface());
2746 assertFalse(pTypeGenericArgInfo.isInterface());
2747 }
2748
2749
2750
2751
2752 @Test
2753 void a083_isLocalClass() {
2754 class F implements Function<Object,String> {
2755 @Override
2756 public String apply(Object t) {
2757 return null;
2758 }
2759 }
2760 assertFalse(aClass.isLocalClass());
2761 assertTrue(of(F.class).isLocalClass());
2762
2763 assertFalse(aTypeInfo.isLocalClass());
2764 assertFalse(pTypeGenericArgInfo.isLocalClass());
2765 }
2766
2767
2768
2769
2770 @Test
2771 void a084_isMemberClass() {
2772 assertTrue(hPublic.isMemberClass());
2773 assertTrue(hPublicMember.isMemberClass());
2774 assertFalse(aClass.isMemberClass());
2775 assertFalse(aInterface.isMemberClass());
2776
2777 assertTrue(aTypeInfo.isMemberClass());
2778 assertFalse(pTypeInfo.isMemberClass());
2779 assertFalse(pTypeDimensionalInfo.isMemberClass());
2780 assertFalse(pTypeGenericInfo.isMemberClass());
2781 assertFalse(pTypeGenericArgInfo.isMemberClass());
2782 }
2783
2784
2785
2786
2787 @Test
2788 void a085_isNonStaticMemberClass() {
2789 assertFalse(hPublic.isNonStaticMemberClass());
2790 assertTrue(hPublicMember.isNonStaticMemberClass());
2791 assertFalse(aClass.isNonStaticMemberClass());
2792 assertFalse(aInterface.isNonStaticMemberClass());
2793
2794 assertTrue(aTypeInfo.isNonStaticMemberClass());
2795 assertFalse(pTypeInfo.isNonStaticMemberClass());
2796 assertFalse(pTypeDimensionalInfo.isNonStaticMemberClass());
2797 assertFalse(pTypeGenericInfo.isNonStaticMemberClass());
2798 assertFalse(pTypeGenericArgInfo.isNonStaticMemberClass());
2799 }
2800
2801
2802
2803
2804 @Test
2805 void a086_isNotAbstract() {
2806 assertFalse(hAbstractPublic.isNotAbstract());
2807 assertTrue(hPublic.isNotAbstract());
2808
2809 assertTrue(aTypeInfo.isNotAbstract());
2810 assertFalse(pTypeInfo.isNotAbstract());
2811 assertFalse(pTypeDimensionalInfo.isNotAbstract());
2812 assertFalse(pTypeGenericInfo.isNotAbstract());
2813 assertTrue(pTypeGenericArgInfo.isNotAbstract());
2814 }
2815
2816
2817
2818
2819 @Test
2820 void a087_isNotDeprecated() {
2821 assertTrue(hPublic.isNotDeprecated());
2822 assertFalse(hPublicDeprecated.isNotDeprecated());
2823
2824 assertTrue(aTypeInfo.isNotDeprecated());
2825 assertTrue(pTypeInfo.isNotDeprecated());
2826 assertTrue(pTypeDimensionalInfo.isNotDeprecated());
2827 assertTrue(pTypeGenericInfo.isNotDeprecated());
2828 assertTrue(pTypeGenericArgInfo.isNotDeprecated());
2829 }
2830
2831
2832
2833
2834 @Test
2835 void a088_isNotLocalClass() {
2836 class F implements Function<Object,String> {
2837 @Override
2838 public String apply(Object t) {
2839 return null;
2840 }
2841 }
2842 assertTrue(aClass.isNotLocalClass());
2843 assertFalse(of(F.class).isNotLocalClass());
2844
2845 assertTrue(aTypeInfo.isNotLocalClass());
2846 assertTrue(pTypeGenericArgInfo.isNotLocalClass());
2847 }
2848
2849
2850
2851
2852 @Test
2853 void a088b_isNestmateOf() {
2854
2855 assertTrue(aClass.isNestmateOf(AClass.class));
2856
2857
2858
2859 assertFalse(aClass.isNestmateOf(String.class));
2860 assertFalse(ClassInfo.of(String.class).isNestmateOf(AClass.class));
2861
2862
2863 var ci = ClassInfo.of((Class<?>)null, pType);
2864 assertFalse(ci.isNestmateOf(AClass.class));
2865 assertFalse(ci.isNestmateOf(null));
2866
2867
2868 assertFalse(aClass.isNestmateOf(null));
2869 }
2870
2871
2872
2873
2874 @Test
2875 void a089_isNotMemberClass() {
2876 assertFalse(hPublic.isNotMemberClass());
2877 assertFalse(hPublicMember.isNotMemberClass());
2878 assertTrue(aClass.isNotMemberClass());
2879 assertTrue(aInterface.isNotMemberClass());
2880
2881 assertFalse(aTypeInfo.isNotMemberClass());
2882 assertTrue(pTypeGenericArgInfo.isNotMemberClass());
2883 }
2884
2885
2886
2887
2888 @Test
2889 void a089b_isNotNonStaticMemberClass() {
2890
2891 assertTrue(aClass.isNotNonStaticMemberClass());
2892
2893
2894 assertFalse(aTypeInfo.isNotNonStaticMemberClass());
2895
2896
2897 assertTrue(ClassInfo.of(String.class).isNotNonStaticMemberClass());
2898 }
2899
2900
2901
2902
2903 @Test
2904 void a090_isNotPrimitive() {
2905 assertFalse(of(int.class).isNotPrimitive());
2906 assertTrue(of(Integer.class).isNotPrimitive());
2907
2908 assertTrue(aTypeInfo.isNotPrimitive());
2909 assertTrue(pTypeInfo.isNotPrimitive());
2910 assertTrue(pTypeDimensionalInfo.isNotPrimitive());
2911 assertTrue(pTypeGenericInfo.isNotPrimitive());
2912 assertTrue(pTypeGenericArgInfo.isNotPrimitive());
2913 }
2914
2915
2916
2917
2918 @Test
2919 void a091_isNotPublic() {
2920 assertFalse(hPublic.isNotPublic());
2921 assertTrue(hProtected.isNotPublic());
2922 assertTrue(hPackage.isNotPublic());
2923 assertTrue(hPrivate.isNotPublic());
2924
2925 assertFalse(aTypeInfo.isNotPublic());
2926 assertTrue(pTypeGenericArgInfo.isNotPublic());
2927 }
2928
2929
2930
2931
2932 @Test
2933 void a092_isNotStatic() {
2934 assertFalse(hPublic.isNotStatic());
2935 assertTrue(hPublicMember.isNotStatic());
2936
2937 assertTrue(aTypeInfo.isNotStatic());
2938 assertTrue(pTypeInfo.isNotStatic());
2939 assertTrue(pTypeDimensionalInfo.isNotStatic());
2940 assertTrue(pTypeGenericInfo.isNotStatic());
2941 assertTrue(pTypeGenericArgInfo.isNotStatic());
2942 }
2943
2944
2945
2946
2947 @Test
2948 void a093_isParentOf() {
2949 assertTrue(ka.isParentOf(KA.class));
2950 assertTrue(ka.isParentOf(KB.class));
2951 assertTrue(ka.isParentOf(KC.class));
2952 assertFalse(kb.isParentOf(KA.class));
2953 assertTrue(kb.isParentOf(KB.class));
2954 assertTrue(kb.isParentOf(KC.class));
2955 assertFalse(kc.isParentOf(KA.class));
2956 assertFalse(kc.isParentOf(KB.class));
2957 assertTrue(kc.isParentOf(KC.class));
2958
2959 assertFalse(ka.isParentOf((Class<?>)null));
2960
2961 assertFalse(ka.isParentOf(aType));
2962 assertFalse(ka.isParentOf(pType));
2963 assertFalse(ka.isParentOf(pTypeDimensional));
2964 assertFalse(ka.isParentOf(pTypeGeneric));
2965 assertFalse(ka.isParentOf(pTypeGenericArg));
2966 assertFalse(aTypeInfo.isParentOf(KA.class));
2967 assertFalse(pTypeInfo.isParentOf(KA.class));
2968 assertFalse(pTypeDimensionalInfo.isParentOf(KA.class));
2969 assertFalse(pTypeGenericInfo.isParentOf(KA.class));
2970 assertFalse(pTypeGenericArgInfo.isParentOf(KA.class));
2971 }
2972
2973
2974
2975
2976 @Test
2977 void a093b_isParentOf_ClassInfo() {
2978
2979 assertTrue(ka.isParentOf(ka));
2980 assertTrue(ka.isParentOf(kb));
2981 assertTrue(ka.isParentOf(kc));
2982 assertFalse(kb.isParentOf(ka));
2983 assertTrue(kb.isParentOf(kb));
2984 assertTrue(kb.isParentOf(kc));
2985 assertFalse(kc.isParentOf(ka));
2986 assertFalse(kc.isParentOf(kb));
2987 assertTrue(kc.isParentOf(kc));
2988
2989
2990 assertFalse(ka.isParentOf((ClassInfo)null));
2991
2992
2993 var nullInnerCi = ClassInfo.of((Class<?>)null, pType);
2994 assertFalse(nullInnerCi.isParentOf(ka));
2995 assertFalse(nullInnerCi.isParentOf((ClassInfo)null));
2996 }
2997
2998
2999
3000
3001 @Test
3002 void a094_isParentOfLenient() {
3003 assertTrue(ClassInfo.of(String.class).isParentOfLenient(String.class));
3004 assertTrue(ClassInfo.of(CharSequence.class).isParentOfLenient(String.class));
3005 assertFalse(ClassInfo.of(String.class).isParentOfLenient(CharSequence.class));
3006 assertTrue(ClassInfo.of(int.class).isParentOfLenient(Integer.class));
3007 assertTrue(ClassInfo.of(Integer.class).isParentOfLenient(int.class));
3008 assertTrue(ClassInfo.of(Number.class).isParentOfLenient(int.class));
3009 assertFalse(ClassInfo.of(int.class).isParentOfLenient(Number.class));
3010 assertFalse(ClassInfo.of(int.class).isParentOfLenient(long.class));
3011
3012
3013 var ci = ClassInfo.of((Class<?>)null, pType);
3014 assertFalse(ci.isParentOfLenient(String.class));
3015 assertFalse(ClassInfo.of(String.class).isParentOfLenient((Class<?>)null));
3016
3017
3018 assertTrue(ClassInfo.of(CharSequence.class).isParentOfLenient((Type)String.class));
3019 assertFalse(ClassInfo.of(String.class).isParentOfLenient((Type)CharSequence.class));
3020
3021 assertFalse(ClassInfo.of(String.class).isParentOfLenient(pType));
3022
3023
3024 assertFalse(ClassInfo.of(String.class).isParentOfLenient((ClassInfo)null));
3025 var nullInnerCi = ClassInfo.of((Class<?>)null, pType);
3026 assertFalse(nullInnerCi.isParentOfLenient(ClassInfo.of(String.class)));
3027
3028
3029
3030
3031
3032
3033
3034 assertFalse(ClassInfo.of(int.class).isParentOfLenient(ClassInfo.of(long.class)));
3035
3036 assertTrue(ClassInfo.of(int.class).isParentOfLenient(int.class));
3037 assertTrue(ClassInfo.of(int.class).isParentOfLenient(ClassInfo.of(int.class)));
3038
3039 }
3040
3041
3042
3043
3044 @Test
3045 void a095_isPrimitive() {
3046 assertTrue(of(int.class).isPrimitive());
3047 assertFalse(of(Integer.class).isPrimitive());
3048
3049 assertFalse(aTypeInfo.isPrimitive());
3050 assertFalse(pTypeGenericArgInfo.isPrimitive());
3051 }
3052
3053
3054
3055
3056 @Test
3057 void a096_isVoid() {
3058 assertTrue(of(void.class).isVoid());
3059 assertTrue(of(Void.class).isVoid());
3060 assertFalse(of(int.class).isVoid());
3061 assertFalse(of(String.class).isVoid());
3062 assertFalse(of(Integer.class).isVoid());
3063
3064 assertFalse(aTypeInfo.isVoid());
3065 assertFalse(pTypeGenericArgInfo.isVoid());
3066 }
3067
3068
3069
3070
3071 @Test
3072 void a097_isNotVoid() {
3073 assertFalse(of(void.class).isNotVoid());
3074 assertFalse(of(Void.class).isNotVoid());
3075 assertTrue(of(int.class).isNotVoid());
3076 assertTrue(of(String.class).isNotVoid());
3077 assertTrue(of(Integer.class).isNotVoid());
3078
3079 assertTrue(aTypeInfo.isNotVoid());
3080 assertTrue(pTypeInfo.isNotVoid());
3081 assertTrue(pTypeDimensionalInfo.isNotVoid());
3082 assertTrue(pTypeGenericInfo.isNotVoid());
3083 assertTrue(pTypeGenericArgInfo.isNotVoid());
3084 }
3085
3086
3087
3088
3089 @Test
3090 void a098_isPublic() {
3091 assertTrue(hPublic.isPublic());
3092 assertFalse(hProtected.isPublic());
3093 assertFalse(hPackage.isPublic());
3094 assertFalse(hPrivate.isPublic());
3095
3096 assertTrue(aTypeInfo.isPublic());
3097 assertTrue(pTypeInfo.isPublic());
3098 assertTrue(pTypeDimensionalInfo.isPublic());
3099 assertTrue(pTypeGenericInfo.isPublic());
3100 assertFalse(pTypeGenericArgInfo.isPublic());
3101 }
3102
3103
3104
3105
3106 @Test
3107 void a097_isRecord() {
3108
3109 try {
3110 Class.forName("java.lang.Record");
3111
3112
3113 assertFalse(cc3.isRecord());
3114 } catch (ClassNotFoundException e) {
3115
3116 assertFalse(cc3.isRecord());
3117 }
3118
3119
3120 var ci = ClassInfo.of((Class<?>)null, pType);
3121 assertFalse(ci.isRecord());
3122 }
3123
3124
3125
3126
3127 @Test
3128 void a098_isStatic() {
3129 assertTrue(hPublic.isStatic());
3130 assertFalse(hPublicMember.isStatic());
3131
3132 assertFalse(aTypeInfo.isStatic());
3133 assertFalse(pTypeGenericArgInfo.isStatic());
3134 }
3135
3136
3137
3138
3139 @Test
3140 void a099_isStrictChildOf() {
3141 assertFalse(ka.isStrictChildOf(KA.class));
3142 assertFalse(ka.isStrictChildOf(KB.class));
3143 assertFalse(ka.isStrictChildOf(KC.class));
3144 assertTrue(kb.isStrictChildOf(KA.class));
3145 assertFalse(kb.isStrictChildOf(KB.class));
3146 assertFalse(kb.isStrictChildOf(KC.class));
3147 assertTrue(kc.isStrictChildOf(KA.class));
3148 assertTrue(kc.isStrictChildOf(KB.class));
3149 assertFalse(kc.isStrictChildOf(KC.class));
3150
3151 assertFalse(ka.isStrictChildOf(null));
3152
3153 assertFalse(aTypeInfo.isStrictChildOf(KA.class));
3154 assertFalse(pTypeInfo.isStrictChildOf(KA.class));
3155 assertFalse(pTypeDimensionalInfo.isStrictChildOf(KA.class));
3156 assertFalse(pTypeGenericInfo.isStrictChildOf(KA.class));
3157 assertFalse(pTypeGenericArgInfo.isStrictChildOf(KA.class));
3158 }
3159
3160
3161
3162
3163 @Test
3164 void a099b_isRuntimeException() {
3165
3166
3167 assertTrue(ClassInfo.of(RuntimeException.class).isRuntimeException());
3168
3169 assertTrue(ClassInfo.of(IllegalArgumentException.class).isRuntimeException());
3170 assertTrue(ClassInfo.of(NullPointerException.class).isRuntimeException());
3171 assertTrue(ClassInfo.of(IllegalStateException.class).isRuntimeException());
3172
3173 assertFalse(ClassInfo.of(Exception.class).isRuntimeException());
3174
3175 assertFalse(ClassInfo.of(String.class).isRuntimeException());
3176 assertFalse(aClass.isRuntimeException());
3177 }
3178
3179
3180
3181
3182 @Test
3183 void a100_isSynthetic() {
3184
3185 assertFalse(aClass.isSynthetic());
3186
3187 var anonymous = new Object() {}.getClass();
3188 var anonymousInfo = ClassInfo.of(anonymous);
3189
3190 assertTrue(anonymousInfo.isSynthetic() || !anonymousInfo.isSynthetic());
3191
3192
3193 var ci = ClassInfo.of((Class<?>)null, pType);
3194 assertFalse(ci.isSynthetic());
3195 }
3196
3197
3198
3199
3200 @Test
3201 void a097b_isSealed() {
3202
3203 var ci = ClassInfo.of((Class<?>)null, pType);
3204 assertFalse(ci.isSealed());
3205
3206
3207 assertFalse(aClass.isSealed());
3208 }
3209
3210
3211
3212
3213 @Test
3214 void a101_isVisible() {
3215
3216 assertTrue(hPublic.isVisible(Visibility.PUBLIC));
3217 assertFalse(hProtected.isVisible(Visibility.PUBLIC));
3218 assertFalse(hPackage.isVisible(Visibility.PUBLIC));
3219 assertFalse(hPrivate.isVisible(Visibility.PUBLIC));
3220
3221
3222 assertTrue(hPublic.isVisible(Visibility.PROTECTED));
3223 assertTrue(hProtected.isVisible(Visibility.PROTECTED));
3224 assertFalse(hPackage.isVisible(Visibility.PROTECTED));
3225 assertFalse(hPrivate.isVisible(Visibility.PROTECTED));
3226
3227
3228 assertTrue(hPublic.isVisible(Visibility.DEFAULT));
3229 assertTrue(hProtected.isVisible(Visibility.DEFAULT));
3230 assertTrue(hPackage.isVisible(Visibility.DEFAULT));
3231 assertFalse(hPrivate.isVisible(Visibility.DEFAULT));
3232
3233
3234 assertTrue(hPublic.isVisible(Visibility.PRIVATE));
3235 assertTrue(hProtected.isVisible(Visibility.PRIVATE));
3236 assertTrue(hPackage.isVisible(Visibility.PRIVATE));
3237 assertTrue(hPrivate.isVisible(Visibility.PRIVATE));
3238
3239
3240 assertTrue(aTypeInfo.isVisible(Visibility.PRIVATE));
3241 assertTrue(pTypeInfo.isVisible(Visibility.PRIVATE));
3242 assertTrue(pTypeDimensionalInfo.isVisible(Visibility.PRIVATE));
3243 assertTrue(pTypeGenericInfo.isVisible(Visibility.PRIVATE));
3244 assertFalse(pTypeGenericArgInfo.isVisible(Visibility.PRIVATE));
3245 }
3246
3247
3248
3249
3250 @Test
3251 void a102_newInstance() {
3252 assertNotNull(la.newInstance());
3253
3254 assertThrows(ExecutableException.class, () -> aTypeInfo.newInstance());
3255 assertThrows(ExecutableException.class, () -> pTypeInfo.newInstance());
3256 assertThrows(ExecutableException.class, () -> pTypeDimensionalInfo.newInstance());
3257 assertThrows(Exception.class, () -> pTypeGenericInfo.newInstance());
3258 assertThrows(ExecutableException.class, () -> pTypeGenericArgInfo.newInstance());
3259 }
3260
3261
3262
3263
3264 @Test
3265 void a103_of() {
3266
3267 check("A1", of(A1.class));
3268 check("A1", of(aType));
3269 check("Map", pTypeInfo);
3270 check("Map", pTypeDimensionalInfo);
3271 check("AbstractMap", pTypeGenericInfo);
3272 check("V", pTypeGenericArgInfo);
3273
3274
3275 check("A1", of(new A1()));
3276
3277
3278 assertThrows(IllegalArgumentException.class, () -> of((Class<?>)null));
3279 assertThrows(IllegalArgumentException.class, () -> of((Type)null));
3280 assertThrows(NullPointerException.class, () -> of((Object)null));
3281
3282
3283 var info = ClassInfo.of(String.class, String.class);
3284 assertNotNull(info);
3285 assertEquals(String.class, info.inner());
3286
3287
3288 info = ClassInfo.of(String.class, String.class);
3289 assertNotNull(info);
3290 assertEquals(String.class, info.inner());
3291
3292
3293 info = ClassInfo.of((Class<?>)null, pType);
3294 assertNotNull(info);
3295 assertNull(info.inner());
3296 assertNotNull(info.innerType());
3297
3298
3299
3300
3301
3302 ClassInfo.of(String.class);
3303
3304
3305
3306
3307 assertNotNull(pTypeInfo);
3308 assertNotNull(pTypeInfo.innerType());
3309 }
3310
3311
3312
3313
3314 @Test
3315 void a104_ofProxy() {
3316 var obj = new A1();
3317 var info = ClassInfo.ofProxy(obj);
3318 assertNotNull(info);
3319 assertEquals(A1.class, info.inner());
3320
3321
3322
3323
3324 var obj2 = new A1();
3325 var info2 = ClassInfo.ofProxy(obj2);
3326 assertNotNull(info2);
3327 assertEquals(A1.class, info2.inner());
3328
3329 assertEquals(ClassInfo.of(A1.class), info2);
3330 }
3331
3332
3333
3334
3335 @Test
3336 void a105_toString() {
3337 assertEquals("class org.apache.juneau.commons.reflect.AClass", aClass.toString());
3338 assertEquals("interface org.apache.juneau.commons.reflect.AInterface", aInterface.toString());
3339 assertEquals("class org.apache.juneau.commons.reflect.ClassInfo_Test$A1", aType.toString());
3340 assertEquals("java.util.Map<java.lang.String, java.util.List<java.lang.String>>", pType.toString());
3341 assertEquals("java.util.Map<java.lang.String, java.lang.String[][]>", pTypeDimensional.toString());
3342 assertEquals("java.util.AbstractMap<K, V>", pTypeGeneric.toString());
3343 assertEquals("V", pTypeGenericArg.toString());
3344 }
3345
3346
3347
3348
3349 @Test
3350 void a106_unwrap() {
3351 check("A1", of(A1.class).unwrap(Value.class));
3352 check("A1", of(A2.class).unwrap(Value.class));
3353
3354
3355 var mi2 = ClassInfo.of(A6.class).getPublicMethod(x -> x.hasName("m1")).get();
3356 check("A1", mi2.getParameter(0).getParameterType().unwrap(Optional.class));
3357 check("A1", mi2.getReturnType().unwrap(Optional.class));
3358 mi2 = ClassInfo.of(A6.class).getPublicMethod(x -> x.hasName("m2")).get();
3359 check("A1", mi2.getParameter(0).getParameterType().unwrap(Value.class));
3360 check("A1", mi2.getReturnType().unwrap(Value.class));
3361
3362
3363
3364 var pTypeOptional = new java.lang.reflect.ParameterizedType() {
3365 @Override
3366 public Type[] getActualTypeArguments() {
3367 return new Type[]{A1.class};
3368 }
3369 @Override
3370 public Type getRawType() {
3371 return Optional.class;
3372 }
3373 @Override
3374 public Type getOwnerType() {
3375 return null;
3376 }
3377 };
3378 var ciOptional = ClassInfo.of((Class<?>)null, pTypeOptional);
3379 check("A1", ciOptional.unwrap(Optional.class));
3380
3381
3382 var pTypeEmpty = new java.lang.reflect.ParameterizedType() {
3383 @Override
3384 public Type[] getActualTypeArguments() {
3385 return new Type[0];
3386 }
3387 @Override
3388 public Type getRawType() {
3389 return Optional.class;
3390 }
3391 @Override
3392 public Type getOwnerType() {
3393 return null;
3394 }
3395 };
3396 var ciEmpty = ClassInfo.of((Class<?>)null, pTypeEmpty);
3397
3398 assertSame(ciEmpty, ciEmpty.unwrap(Optional.class));
3399
3400
3401
3402
3403 check("A1", of(A2.class).unwrap(Value.class));
3404
3405
3406
3407
3408 assertSame(of(A1.class), of(A1.class).unwrap(Value.class));
3409
3410
3411
3412
3413 assertSame(of(Value.class), of(Value.class).unwrap(Value.class));
3414
3415
3416
3417
3418
3419 }
3420 }
3421