This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new 2c32527f32 org.apache.juneau.common.reflect API improvements
2c32527f32 is described below
commit 2c32527f323b445d8411acfa5c8a30f4173cd1fe
Author: James Bognar <[email protected]>
AuthorDate: Tue Nov 18 08:42:22 2025 -0500
org.apache.juneau.common.reflect API improvements
---
.../juneau/common/reflect/ReflectionMapTest.java | 362 +++++++++++++++++++++
1 file changed, 362 insertions(+)
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ReflectionMapTest.java
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ReflectionMapTest.java
new file mode 100644
index 0000000000..48dda822be
--- /dev/null
+++
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ReflectionMapTest.java
@@ -0,0 +1,362 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.juneau.common.reflect;
+
+import static org.apache.juneau.TestUtils.*;
+import static org.apache.juneau.junit.bct.BctAssertions.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.lang.reflect.*;
+
+import org.apache.juneau.*;
+import org.junit.jupiter.api.*;
+
+class ReflectionMapTest extends TestBase {
+
+ private static ReflectionMap.Builder<Number> create() {
+ return ReflectionMap.create(Number.class);
+ }
+
+ private static void checkEntries(ReflectionMap<?> m, boolean hasClass,
boolean hasMethods, boolean hasFields, boolean hasConstructors) {
+ assertEquals(m.classEntries.size() == 0, ! hasClass);
+ assertEquals(m.methodEntries.size() == 0, ! hasMethods);
+ assertEquals(m.fieldEntries.size() == 0, ! hasFields);
+ assertEquals(m.constructorEntries.size() == 0, !
hasConstructors);
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Class names
+
//------------------------------------------------------------------------------------------------------------------
+
+ static class A1 {}
+ static class A2 {}
+
+ static ReflectionMap<Number>
+ A1_SIMPLE = create().append("A1", 1).build(),
+ A1b_SIMPLE = create().append("ReflectionMapTest$A1", 1).build(),
+ A1_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$A1",
1).build(); // Note this could be a static field.
+
+ @Test void a01_classNames_checkEntries() {
+ checkEntries(A1_SIMPLE, true, false, false, false);
+ checkEntries(A1_FULL, true, false, true, false);
+ }
+
+ private static void checkA(Class<?> c, boolean match_A1_SIMPLE, boolean
match_A1b_SIMPLE, boolean match_A1_FULL) {
+ assertEquals(match_A1_SIMPLE,
A1_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_A1b_SIMPLE,
A1b_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_A1_FULL,
A1_FULL.find(c).findAny().isPresent());
+
+ assertEquals(match_A1_SIMPLE, A1_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_A1b_SIMPLE, A1b_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_A1_FULL, A1_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+
+ assertFalse(A1_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(A1b_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(A1_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+
+ assertEquals(match_A1_SIMPLE, A1_SIMPLE.find(c).count() > 0);
+ assertEquals(match_A1b_SIMPLE, A1b_SIMPLE.find(c).count() > 0);
+ assertEquals(match_A1_FULL, A1_FULL.find(c).count() > 0);
+
+ assertEquals(match_A1_SIMPLE, A1_SIMPLE.find(c).filter(v -> v
instanceof Integer).count() > 0);
+ assertEquals(match_A1b_SIMPLE, A1b_SIMPLE.find(c).filter(v -> v
instanceof Integer).count() > 0);
+ assertEquals(match_A1_FULL, A1_FULL.find(c).filter(v -> v
instanceof Integer).count() > 0);
+
+ assertFalse(A1_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(A1b_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(A1_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ }
+
+ @Test void a02_classNames_find() {
+ checkA(A1.class, true, true, true);
+ checkA(A2.class, false, false, false);
+ checkA(null, false, false, false);
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Method names
+
//------------------------------------------------------------------------------------------------------------------
+
+ static class B1 {
+ public void m1() { /* no-op */ }
+ public void m1(int x) { /* no-op */ }
+ public void m1(String x) { /* no-op */ }
+ public void m1(String x, int y) { /* no-op */ }
+ public void m2(int x) { /* no-op */ }
+ }
+ static class B2 {
+ public void m1() { /* no-op */ }
+ }
+
+ static ReflectionMap<Number>
+ B1m1_SIMPLE = create().append("B1.m1", 1).build(),
+ B1m1i_SIMPLE = create().append("B1.m1(int)", 1).build(),
+ B1m1s_SIMPLE = create().append("B1.m1(String)", 1).build(),
+ B1m1ss_SIMPLE = create().append("B1.m1(java.lang.String)",
1).build(),
+ B1m1si_SIMPLE = create().append("B1.m1(String,int)", 1).build(),
+ B1m1ssi_SIMPLE = create().append("B1.m1(java.lang.String ,
int)", 1).build(),
+ B1m1_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1",
1).build(),
+ B1m1i_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1(int)",
1).build(),
+ B1m1s_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1(String)",
1).build(),
+ B1m1ss_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1(java.lang.String)",
1).build(),
+ B1m1si_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1(String,int)",
1).build(),
+ B1m1ssi_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$B1.m1(java.lang.String
, int)", 1).build();
+
+ @Test void b01_methodNames_checkEntries() {
+ checkEntries(B1m1_SIMPLE, false, true, true, false);
+ checkEntries(B1m1i_SIMPLE, false, true, false, false);
+ checkEntries(B1m1s_SIMPLE, false, true, false, false);
+ checkEntries(B1m1ss_SIMPLE, false, true, false, false);
+ checkEntries(B1m1si_SIMPLE, false, true, false, false);
+ checkEntries(B1m1ssi_SIMPLE, false, true, false, false);
+ checkEntries(B1m1_FULL, false, true, true, false);
+ checkEntries(B1m1i_FULL, false, true, false, false);
+ checkEntries(B1m1s_FULL, false, true, false, false);
+ checkEntries(B1m1ss_FULL, false, true, false, false);
+ checkEntries(B1m1si_FULL, false, true, false, false);
+ checkEntries(B1m1ssi_FULL, false, true, false, false);
+ }
+
+ private static void checkB(Method m, boolean match_B1m1_SIMPLE, boolean
match_B1m1i_SIMPLE, boolean match_B1m1s_SIMPLE, boolean match_B1m1ss_SIMPLE,
+ boolean match_B1m1si_SIMPLE, boolean
match_B1m1ssi_SIMPLE, boolean match_B1m1_FULL, boolean match_B1m1i_FULL,
boolean match_B1m1s_FULL,
+ boolean match_B1m1ss_FULL, boolean match_B1m1si_FULL,
boolean match_B1m1ssi_FULL) {
+
+ assertEquals(match_B1m1_SIMPLE,
B1m1_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1i_SIMPLE,
B1m1i_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1s_SIMPLE,
B1m1s_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1ss_SIMPLE,
B1m1ss_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1si_SIMPLE,
B1m1si_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1ssi_SIMPLE,
B1m1ssi_SIMPLE.find(m).findAny().isPresent());
+ assertEquals(match_B1m1_FULL,
B1m1_FULL.find(m).findAny().isPresent());
+ assertEquals(match_B1m1i_FULL,
B1m1i_FULL.find(m).findAny().isPresent());
+ assertEquals(match_B1m1s_FULL,
B1m1s_FULL.find(m).findAny().isPresent());
+ assertEquals(match_B1m1ss_FULL,
B1m1ss_FULL.find(m).findAny().isPresent());
+ assertEquals(match_B1m1si_FULL,
B1m1si_FULL.find(m).findAny().isPresent());
+ assertEquals(match_B1m1ssi_FULL,
B1m1ssi_FULL.find(m).findAny().isPresent());
+
+ assertEquals(match_B1m1_SIMPLE, B1m1_SIMPLE.find(m).filter(v ->
v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1i_SIMPLE, B1m1i_SIMPLE.find(m).filter(v
-> v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1s_SIMPLE, B1m1s_SIMPLE.find(m).filter(v
-> v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1ss_SIMPLE,
B1m1ss_SIMPLE.find(m).filter(v -> v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1si_SIMPLE,
B1m1si_SIMPLE.find(m).filter(v -> v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1ssi_SIMPLE,
B1m1ssi_SIMPLE.find(m).filter(v -> v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1_FULL, B1m1_FULL.find(m).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1i_FULL, B1m1i_FULL.find(m).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1s_FULL, B1m1s_FULL.find(m).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1ss_FULL, B1m1ss_FULL.find(m).filter(v ->
v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1si_FULL, B1m1si_FULL.find(m).filter(v ->
v instanceof Integer).findAny().isPresent());
+ assertEquals(match_B1m1ssi_FULL, B1m1ssi_FULL.find(m).filter(v
-> v instanceof Integer).findAny().isPresent());
+
+ assertFalse(B1m1_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1i_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1s_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1ss_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1si_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1ssi_SIMPLE.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1i_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1s_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1ss_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1si_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(B1m1ssi_FULL.find(m).filter(v -> v instanceof
Long).findAny().isPresent());
+ }
+
+ @Test void b02_methodName_find() throws Exception {
+ checkB(B1.class.getMethod("m1"), true, false, false, false,
false, false, true, false, false, false, false, false);
+ checkB(B1.class.getMethod("m1", int.class), true, true, false,
false, false, false, true, true, false, false, false, false);
+ checkB(B1.class.getMethod("m1", String.class), true, false,
true, true, false, false, true, false, true, true, false, false);
+ checkB(B1.class.getMethod("m1", String.class, int.class), true,
false, false, false, true, true, true, false, false, false, true, true);
+ checkB(B1.class.getMethod("m2", int.class), false, false,
false, false, false, false, false, false, false, false, false, false);
+ checkB(B2.class.getMethod("m1"), false, false, false, false,
false, false, false, false, false, false, false, false);
+ checkB(null, false, false, false, false, false, false, false,
false, false, false, false, false);
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Field names
+
//------------------------------------------------------------------------------------------------------------------
+
+ static class C1 {
+ public int f1;
+ public int f2;
+ }
+ static class C2 {
+ public int f1;
+ }
+
+ static ReflectionMap<Number>
+ C1f1_SIMPLE = create().append("C1.f1", 1).build(),
+ C1f1_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$C1.f1",
1).build();
+
+ @Test void c01_fieldNames_checkEntries() {
+ checkEntries(C1f1_SIMPLE, false, true, true, false);
+ checkEntries(C1f1_FULL, false, true, true, false);
+ }
+
+ private static void checkC(Field f, boolean match_C1f1_SIMPLE, boolean
match_C1f1_FULL) {
+ assertEquals(match_C1f1_SIMPLE,
C1f1_SIMPLE.find(f).findAny().isPresent());
+ assertEquals(match_C1f1_FULL,
C1f1_FULL.find(f).findAny().isPresent());
+
+ assertEquals(match_C1f1_SIMPLE, C1f1_SIMPLE.find(f).filter(v ->
v instanceof Integer).findAny().isPresent());
+ assertEquals(match_C1f1_FULL, C1f1_FULL.find(f).filter(v -> v
instanceof Integer).findAny().isPresent());
+
+ assertFalse(C1f1_SIMPLE.find(f).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(C1f1_FULL.find(f).filter(v -> v instanceof
Long).findAny().isPresent());
+ }
+
+ @Test void c02_fieldName_find() throws Exception {
+ checkC(C1.class.getField("f1"), true, true);
+ checkC(C1.class.getField("f2"), false, false);
+ checkC(C2.class.getField("f1"), false, false);
+ checkC(null, false, false);
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Constructor names
+
//------------------------------------------------------------------------------------------------------------------
+
+ static class D1 {
+ public D1() { /* no-op */ }
+ public D1(int x) { /* no-op */ }
+ public D1(String x) { /* no-op */ }
+ public D1(String x, int y) { /* no-op */ }
+ }
+ static class D2 {
+ public D2() { /* no-op */ }
+ }
+
+ static ReflectionMap<Number>
+ D_SIMPLE = create().append("D1()", 1).build(),
+ Di_SIMPLE = create().append("D1(int)", 1).build(),
+ Ds_SIMPLE = create().append("D1(String)", 1).build(),
+ Dss_SIMPLE = create().append("D1(java.lang.String)", 1).build(),
+ Dsi_SIMPLE = create().append("D1(String, int)", 1).build(),
+ Dssi_SIMPLE = create().append("D1(java.lang.String, int)",
1).build(),
+ D_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1()",
1).build(),
+ Di_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1(int)",
1).build(),
+ Ds_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1(String)",
1).build(),
+ Dss_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1(java.lang.String)",
1).build(),
+ Dsi_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1(String,
int)", 1).build(),
+ Dssi_FULL =
create().append("org.apache.juneau.common.reflect.ReflectionMapTest$D1(java.lang.String,
int)", 1).build();
+
+ @Test void d01_constructorNames_checkEntries() {
+ checkEntries(D_SIMPLE, false, false, false, true);
+ checkEntries(Di_SIMPLE, false, false, false, true);
+ checkEntries(Ds_SIMPLE, false, false, false, true);
+ checkEntries(Dss_SIMPLE, false, false, false, true);
+ checkEntries(Dsi_SIMPLE, false, false, false, true);
+ checkEntries(Dssi_SIMPLE, false, false, false, true);
+ checkEntries(D_FULL, false, false, false, true);
+ checkEntries(Di_FULL, false, false, false, true);
+ checkEntries(Ds_FULL, false, false, false, true);
+ checkEntries(Dss_FULL, false, false, false, true);
+ checkEntries(Dsi_FULL, false, false, false, true);
+ checkEntries(Dssi_FULL, false, false, false, true);
+ }
+
+ private static void checkD(Constructor<?> c, boolean match_D_SIMPLE,
boolean match_Di_SIMPLE, boolean match_Ds_SIMPLE, boolean match_Dss_SIMPLE,
+ boolean match_Dsi_SIMPLE, boolean match_Dssi_SIMPLE,
boolean match_D_FULL, boolean match_Di_FULL, boolean match_Ds_FULL,
+ boolean match_Dss_FULL, boolean match_Dsi_FULL, boolean
match_Dssi_FULL) {
+
+ assertEquals(match_D_SIMPLE,
D_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_Di_SIMPLE,
Di_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_Ds_SIMPLE,
Ds_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_Dss_SIMPLE,
Dss_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_Dsi_SIMPLE,
Dsi_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_Dssi_SIMPLE,
Dssi_SIMPLE.find(c).findAny().isPresent());
+ assertEquals(match_D_FULL,
D_FULL.find(c).findAny().isPresent());
+ assertEquals(match_Di_FULL,
Di_FULL.find(c).findAny().isPresent());
+ assertEquals(match_Ds_FULL,
Ds_FULL.find(c).findAny().isPresent());
+ assertEquals(match_Dss_FULL,
Dss_FULL.find(c).findAny().isPresent());
+ assertEquals(match_Dsi_FULL,
Dsi_FULL.find(c).findAny().isPresent());
+ assertEquals(match_Dssi_FULL,
Dssi_FULL.find(c).findAny().isPresent());
+
+ assertEquals(match_D_SIMPLE, D_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Di_SIMPLE, Di_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Ds_SIMPLE, Ds_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dss_SIMPLE, Dss_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dsi_SIMPLE, Dsi_SIMPLE.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dssi_SIMPLE, Dssi_SIMPLE.find(c).filter(v ->
v instanceof Integer).findAny().isPresent());
+ assertEquals(match_D_FULL, D_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Di_FULL, Di_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Ds_FULL, Ds_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dss_FULL, Dss_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dsi_FULL, Dsi_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+ assertEquals(match_Dssi_FULL, Dssi_FULL.find(c).filter(v -> v
instanceof Integer).findAny().isPresent());
+
+ assertFalse(D_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Di_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Ds_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dss_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dsi_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dssi_SIMPLE.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(D_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Di_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Ds_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dss_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dsi_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ assertFalse(Dssi_FULL.find(c).filter(v -> v instanceof
Long).findAny().isPresent());
+ }
+
+ @Test void d02_constructorName_find() throws Exception {
+ checkD(D1.class.getConstructor(), true, false, false, false,
false, false, true, false, false, false, false, false);
+ checkD(D1.class.getConstructor(int.class), false, true, false,
false, false, false, false, true, false, false, false, false);
+ checkD(D1.class.getConstructor(String.class), false, false,
true, true, false, false, false, false, true, true, false, false);
+ checkD(D1.class.getConstructor(String.class, int.class), false,
false, false, false, true, true, false, false, false, false, true, true);
+ checkD(D2.class.getConstructor(), false, false, false, false,
false, false, false, false, false, false, false, false);
+ checkD(null, false, false, false, false, false, false, false,
false, false, false, false, false);
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Invalid input
+
//------------------------------------------------------------------------------------------------------------------
+
+ @Test void e01_blankInput() {
+ assertThrowsWithMessage(RuntimeException.class, "Invalid
reflection signature: []", ()->create().append("", 1));
+ }
+
+ @Test void e02_nullInput() {
+ assertThrowsWithMessage(RuntimeException.class, "Invalid
reflection signature: [null]", ()->create().append(null, 1));
+ }
+
+ @Test void e03_badInput() {
+ assertThrowsWithMessage(RuntimeException.class, "Invalid
reflection signature: [foo)]", ()->create().append("foo)", 1));
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Comma-delimited list.
+
//------------------------------------------------------------------------------------------------------------------
+ static class F1 {}
+
+ static ReflectionMap<Number> RM_F = create().append("F2, F1",
1).build();
+
+ @Test void f01_cdl() {
+ assertString("1", RM_F.find(F1.class).findFirst().get());
+ }
+
+
//------------------------------------------------------------------------------------------------------------------
+ // Empty reflection map.
+
//------------------------------------------------------------------------------------------------------------------
+
+ static ReflectionMap<Number> RM_G = create().build();
+
+ @Test void g01_emptyReflectionMap() throws Exception {
+ assertFalse(RM_G.find(A1.class).findAny().isPresent());
+
assertFalse(RM_G.find(B1.class.getMethod("m1")).findAny().isPresent());
+
assertFalse(RM_G.find(C1.class.getField("f1")).findAny().isPresent());
+
assertFalse(RM_G.find(D1.class.getConstructor()).findAny().isPresent());
+ }
+}
\ No newline at end of file
