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 ae983bc076 Utility class modernization
ae983bc076 is described below
commit ae983bc076ae5fa74ab5920fdad135554ec043e5
Author: James Bognar <[email protected]>
AuthorDate: Fri Nov 7 10:11:19 2025 -0500
Utility class modernization
---
.../juneau/common/reflect/ConstructorInfo.java | 16 -----
.../juneau/common/reflect/ExecutableInfo.java | 57 +++++++++++++++---
.../apache/juneau/common/reflect/MethodInfo.java | 68 +++-------------------
.../java/org/apache/juneau/swap/AutoListSwap.java | 6 +-
.../java/org/apache/juneau/swap/AutoMapSwap.java | 6 +-
.../org/apache/juneau/swap/AutoNumberSwap.java | 2 +-
.../org/apache/juneau/swap/AutoObjectSwap.java | 6 +-
.../java/org/apache/juneau/rest/RestContext.java | 4 +-
.../juneau/common/reflect/ExecutableInfo_Test.java | 12 ++--
.../juneau/common/reflect/MethodInfo_Test.java | 8 +--
.../java/org/apache/juneau/cp/BeanStore_Test.java | 16 ++---
11 files changed, 87 insertions(+), 114 deletions(-)
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
index c132c62c55..bba7e8a9ed 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ConstructorInfo.java
@@ -88,22 +88,6 @@ public class ConstructorInfo extends ExecutableInfo
implements Comparable<Constr
return this;
}
- /**
- * Returns <jk>true</jk> if this constructor can accept the specified
arguments in the specified order.
- *
- * @param args The arguments to check.
- * @return <jk>true</jk> if this constructor can accept the specified
arguments in the specified order.
- */
- public boolean canAccept(Object...args) {
- Class<?>[] pt = c.getParameterTypes();
- if (pt.length != args.length)
- return false;
- for (int i = 0; i < pt.length; i++)
- if (! pt[i].isInstance(args[i]))
- return false;
- return true;
- }
-
@Override
public int compareTo(ConstructorInfo o) {
int i = getSimpleName().compareTo(o.getSimpleName());
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
index 62426a5384..9e6a38413c 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/ExecutableInfo.java
@@ -89,7 +89,7 @@ public abstract class ExecutableInfo extends AccessibleInfo {
* @param argTypes The arg types to check against.
* @return How many parameters match or <c>-1</c> if method cannot
handle one or more of the arguments.
*/
- public final int getLenientParameterMatch(Class<?>...argTypes) {
+ public final int parameterMatchesLenientCount(Class<?>...argTypes) {
int matches = 0;
outer: for (var param : getParameters()) {
for (var a : argTypes) {
@@ -117,7 +117,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @param argTypes The arg types to check against.
* @return How many parameters match or <c>-1</c> if method cannot
handle one or more of the arguments.
*/
- public final int getLenientParameterMatch(ClassInfo...argTypes) {
+ public final int parameterMatchesLenientCount(ClassInfo...argTypes) {
int matches = 0;
outer: for (var param : getParameters()) {
for (var a : argTypes) {
@@ -145,7 +145,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @param argTypes The arg types to check against.
* @return How many parameters match or <c>-1</c> if method cannot
handle one or more of the arguments.
*/
- public final int getLenientParameterMatch(Object...argTypes) {
+ public final int parameterMatchesLenientCount(Object...argTypes) {
int matches = 0;
outer: for (var param : getParameters()) {
for (var a : argTypes) {
@@ -296,6 +296,49 @@ public abstract class ExecutableInfo extends
AccessibleInfo {
*/
public final String getSimpleName() { return isConstructor ?
scn(e.getDeclaringClass()) : e.getName(); }
+ /**
+ * Returns <jk>true</jk> if this executable can accept the specified
arguments in the specified order.
+ *
+ * <p>
+ * This method checks if the provided arguments are compatible with the
executable's parameter types
+ * in exact order, using {@link Class#isInstance(Object)} for type
checking.
+ *
+ * <p>
+ * <strong>Important:</strong> For non-static inner class constructors,
the first parameter is the
+ * implicit outer class instance (e.g., {@code Outer.this}). This
method checks against the
+ * <em>actual</em> parameters including this implicit parameter.
+ *
+ * <h5 class='section'>Examples:</h5>
+ * <p class='bjava'>
+ * <jc>// Regular method</jc>
+ * <jk>public void</jk> foo(String <jv>s</jv>, Integer <jv>i</jv>);
+ * <jv>methodInfo</jv>.canAccept(<js>"hello"</js>, 42); <jc>//
true</jc>
+ *
+ * <jc>// Non-static inner class constructor</jc>
+ * <jk>class</jk> Outer {
+ * <jk>class</jk> Inner {
+ * Inner(String <jv>s</jv>) {}
+ * }
+ * }
+ * <jc>// Constructor actually has signature: Inner(Outer this$0,
String s)</jc>
+ * Outer <jv>outer</jv> = <jk>new</jk> Outer();
+ * <jv>constructorInfo</jv>.canAccept(<js>"hello"</js>); <jc>//
false - missing outer instance</jc>
+ * <jv>constructorInfo</jv>.canAccept(<jv>outer</jv>,
<js>"hello"</js>); <jc>// true</jc>
+ * </p>
+ *
+ * @param args The arguments to check.
+ * @return <jk>true</jk> if this executable can accept the specified
arguments in the specified order.
+ */
+ public final boolean canAccept(Object...args) {
+ Class<?>[] pt = e.getParameterTypes();
+ if (pt.length != args.length)
+ return false;
+ for (int i = 0; i < pt.length; i++)
+ if (! pt[i].isInstance(args[i]))
+ return false;
+ return true;
+ }
+
/**
* Returns <jk>true</jk> if this method has at most only these
arguments using lenient matching.
*
@@ -307,7 +350,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @return <jk>true</jk> if this method has at most only these
arguments in any order.
*/
public final boolean hasParameterTypesLenient(Class<?>...args) {
- return getLenientParameterMatch(args) != -1;
+ return parameterMatchesLenientCount(args) != -1;
}
/**
@@ -321,7 +364,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @return <jk>true</jk> if this method has at most only these
arguments in any order.
*/
public final boolean hasParameterTypesLenient(ClassInfo...args) {
- return getLenientParameterMatch(args) != -1;
+ return parameterMatchesLenientCount(args) != -1;
}
/**
@@ -330,7 +373,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @param args The arguments to test for.
* @return <jk>true</jk> if this method has this arguments in the exact
order.
*/
- public final boolean hasMatchingParameterTypes(Class<?>...args) {
+ public final boolean hasParameterTypeParents(Class<?>...args) {
var params = getParameters();
return params.size() == args.length
&& params.stream().allMatch(p ->
stream(args).anyMatch(a -> p.getParameterType().isParentOfLenient(a)));
@@ -342,7 +385,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
* @param args The arguments to test for.
* @return <jk>true</jk> if this method has this arguments in the exact
order.
*/
- public final boolean hasMatchingParameterTypes(ClassInfo...args) {
+ public final boolean hasParameterTypeParents(ClassInfo...args) {
var params = getParameters();
return params.size() == args.length
&& params.stream().allMatch(p ->
stream(args).anyMatch(a -> p.getParameterType().isParentOfLenient(a)));
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
index d714e72dff..e2090177ce 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/reflect/MethodInfo.java
@@ -321,15 +321,15 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* <jc>// Example method:</jc>
* <jk>public void</jk> foo(String <jv>bar</jv>, Integer
<jv>baz</jv>);
*
- * argsOnlyOfType(<jv>fooMethod</jv>, String.<jk>class</jk>,
Integer.<jk>class</jk>); <jc>// True.</jc>
- * argsOnlyOfType(<jv>fooMethod</jv>, String.<jk>class</jk>,
Integer.<jk>class</jk>, Map.<jk>class</jk>); <jc>// True.</jc>
- * argsOnlyOfType(<jv>fooMethod</jv>, String.<jk>class</jk>);
<jc>// False.</jc>
+ * <jv>fooMethod</jv>.hasOnlyParameterTypes(String.<jk>class</jk>,
Integer.<jk>class</jk>); <jc>// True.</jc>
+ * <jv>fooMethod</jv>.hasOnlyParameterTypes(String.<jk>class</jk>,
Integer.<jk>class</jk>, Map.<jk>class</jk>); <jc>// True.</jc>
+ *
<jv>fooMethod</jv>.hasOnlyParameterTypes(String.<jk>class</jk>); <jc>//
False.</jc>
* </p>
*
* @param args The valid class types (exact) for the arguments.
* @return <jk>true</jk> if the method parameters only consist of the
types specified in the list.
*/
- public boolean argsOnlyOfType(Class<?>...args) {
+ public boolean hasOnlyParameterTypes(Class<?>...args) {
for (var param : getParameters()) {
var c1 = param.getParameterType().inner();
boolean foundMatch = false;
@@ -342,60 +342,6 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
return true;
}
- /**
- * Returns <jk>true</jk> if this constructor can accept the specified
arguments in the specified order.
- *
- * @param args The arguments to check.
- * @return <jk>true</jk> if this constructor can accept the specified
arguments in the specified order.
- */
- public boolean canAccept(Object...args) {
- Class<?>[] pt = m.getParameterTypes();
- if (pt.length != args.length)
- return false;
- for (int i = 0; i < pt.length; i++)
- if (! pt[i].isInstance(args[i]))
- return false;
- return true;
- }
-
- /**
- * Returns <jk>true</jk> if this method has at most only these
parameter types using lenient matching.
- *
- * <p>
- * Lenient matching allows arguments to be matched to parameters based
on type compatibility,
- * where arguments can be in any order.
- *
- * @param args The parameter types to test for.
- * @return <jk>true</jk> if this method has at most only these
parameter types in any order.
- */
- public boolean hasFuzzyParameterTypes(Class<?>...args) {
- return hasParameterTypesLenient(args);
- }
-
- /**
- * Returns the number of matching arguments for this method using
lenient matching.
- *
- * <p>
- * Lenient matching allows arguments to be matched to parameters based
on type compatibility,
- * where arguments can be in any order, extra arguments are ignored,
and missing arguments return -1.
- *
- * @param args The arguments to check.
- * @return The number of matching arguments for this method, or -1 if
not all parameters can be matched.
- */
- public int canAcceptLenient(Object...args) {
- int matches = 0;
- outer: for (var param : getParameters()) {
- for (var a : args) {
- if (param.getParameterType().canAcceptArg(a)) {
- matches++;
- continue outer;
- }
- }
- return -1;
- }
- return matches;
- }
-
@Override
public int compareTo(MethodInfo o) {
int i = getSimpleName().compareTo(o.getSimpleName());
@@ -545,7 +491,7 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @param requiredParams The parameter types to check for.
* @return <jk>true</jk> if this method has at least the specified
parameters.
*/
- public boolean hasAllArgs(Class<?>...requiredParams) {
+ public boolean hasAllParameters(Class<?>...requiredParams) {
var paramTypes = getParameters().stream()
.map(p -> p.getParameterType().inner())
.toList();
@@ -617,8 +563,8 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
* @param requiredParam The parameter type to check for.
* @return <jk>true</jk> if this method has at least the specified
parameter.
*/
- public boolean hasArg(Class<?> requiredParam) {
- return hasAllArgs(requiredParam);
+ public boolean hasParameter(Class<?> requiredParam) {
+ return hasAllParameters(requiredParam);
}
/**
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoListSwap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoListSwap.java
index 43602ff5d4..5542d3e43e 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoListSwap.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoListSwap.java
@@ -141,9 +141,9 @@ public class AutoListSwap<T> extends ObjectSwap<T,List<?>> {
// @formatter:off
return
cs.isNotDeprecated()
- && cs.isVisible(bc.getBeanConstructorVisibility())
- && cs.hasMatchingParameterTypes(rt)
- && bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
+ &&
cs.isVisible(bc.getBeanConstructorVisibility())
+ && cs.hasParameterTypeParents(rt)
+ &&
bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
// @formatter:on
}
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoMapSwap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoMapSwap.java
index 054bac6407..84903260a9 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoMapSwap.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoMapSwap.java
@@ -141,9 +141,9 @@ public class AutoMapSwap<T> extends ObjectSwap<T,Map<?,?>> {
// @formatter:off
return
cs.isNotDeprecated()
- && cs.isVisible(bc.getBeanConstructorVisibility())
- && cs.hasMatchingParameterTypes(rt)
- && bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
+ &&
cs.isVisible(bc.getBeanConstructorVisibility())
+ && cs.hasParameterTypeParents(rt)
+ &&
bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
// @formatter:on
}
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoNumberSwap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoNumberSwap.java
index 26befab376..ea4eba6af8 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoNumberSwap.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoNumberSwap.java
@@ -167,7 +167,7 @@ public class AutoNumberSwap<T> extends ObjectSwap<T,Number>
{
return
cs.isNotDeprecated()
&& cs.isVisible(bc.getBeanConstructorVisibility())
- && cs.hasMatchingParameterTypes(rt)
+ && cs.hasParameterTypeParents(rt)
&& bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
// @formatter:on
}
diff --git
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoObjectSwap.java
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoObjectSwap.java
index 60ae9938a7..ccb8001196 100644
---
a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoObjectSwap.java
+++
b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/swap/AutoObjectSwap.java
@@ -142,9 +142,9 @@ public class AutoObjectSwap<T> extends ObjectSwap<T,Object>
{
// @formatter:off
return
cs.isNotDeprecated()
- && cs.isVisible(bc.getBeanConstructorVisibility())
- && cs.hasMatchingParameterTypes(rt)
- && bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
+ &&
cs.isVisible(bc.getBeanConstructorVisibility())
+ && cs.hasParameterTypeParents(rt)
+ &&
bc.getAnnotationProvider().find(BeanIgnore.class,
cs.inner()).findAny().isEmpty();
// @formatter:on
}
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
index 4b811a0158..65c58d7b08 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestContext.java
@@ -3782,7 +3782,7 @@ public class RestContext extends Context {
var map = CollectionUtils.<String,MethodInfo>map();
// @formatter:off
ClassInfo.ofProxy(r).getAllMethodsParentFirst().stream()
- .filter(y -> y.hasAnnotation(RestInit.class) &&
! y.hasArg(RestOpContext.Builder.class))
+ .filter(y -> y.hasAnnotation(RestInit.class) &&
! y.hasParameter(RestOpContext.Builder.class))
.forEach(y -> {
var sig = y.getSignature();
if (! map.containsKey(sig))
@@ -4572,7 +4572,7 @@ public class RestContext extends Context {
var initMap = CollectionUtils.<String,MethodInfo>map();
// @formatter:off
ClassInfo.ofProxy(resource.get()).getAllMethodsParentFirst().stream()
- .filter(y -> y.hasAnnotation(RestInit.class) &&
y.hasArg(RestOpContext.Builder.class))
+ .filter(y -> y.hasAnnotation(RestInit.class) &&
y.hasParameter(RestOpContext.Builder.class))
.forEach(y -> {
String sig = y.getSignature();
if (! initMap.containsKey(sig))
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
index dee8dff8b6..4cb1454522 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/ExecutableInfo_Test.java
@@ -381,12 +381,12 @@ class ExecutableInfo_Test extends TestBase {
}
@Test void hasArgParents() {
-
assertTrue(e_hasStringParam.hasMatchingParameterTypes(String.class));
-
assertFalse(e_hasStringParam.hasMatchingParameterTypes(CharSequence.class));
-
assertFalse(e_hasStringParam.hasMatchingParameterTypes(StringBuilder.class));
- assertFalse(e_hasStringParam.hasMatchingParameterTypes(new
Class[0]));
-
assertFalse(e_hasStringParam.hasMatchingParameterTypes(String.class,
String.class));
-
assertFalse(e_hasStringParam.hasMatchingParameterTypes(long.class));
+
assertTrue(e_hasStringParam.hasParameterTypeParents(String.class));
+
assertFalse(e_hasStringParam.hasParameterTypeParents(CharSequence.class));
+
assertFalse(e_hasStringParam.hasParameterTypeParents(StringBuilder.class));
+ assertFalse(e_hasStringParam.hasParameterTypeParents(new
Class[0]));
+
assertFalse(e_hasStringParam.hasParameterTypeParents(String.class,
String.class));
+
assertFalse(e_hasStringParam.hasParameterTypeParents(long.class));
}
@Test void hasFuzzyArgs() {
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/MethodInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/MethodInfo_Test.java
index 9043dd04a7..a10c26a74d 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/common/reflect/MethodInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/common/reflect/MethodInfo_Test.java
@@ -487,10 +487,10 @@ class MethodInfo_Test extends TestBase {
assertEquals("a3", e_a3.getSignature());
}
- @Test void argsOnlyOfType() {
- assertTrue(e_a1.argsOnlyOfType(CharSequence.class));
- assertTrue(e_a1.argsOnlyOfType(CharSequence.class, Map.class));
- assertFalse(e_a1.argsOnlyOfType());
+ @Test void hasOnlyParameterTypes() {
+ assertTrue(e_a1.hasOnlyParameterTypes(CharSequence.class));
+ assertTrue(e_a1.hasOnlyParameterTypes(CharSequence.class,
Map.class));
+ assertFalse(e_a1.hasOnlyParameterTypes());
}
public static class F {
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/cp/BeanStore_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/cp/BeanStore_Test.java
index 98c32e3e23..04a1593aee 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/cp/BeanStore_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/cp/BeanStore_Test.java
@@ -728,14 +728,14 @@ class BeanStore_Test extends TestBase {
b1p.add(A1.class, null);
assertString("createC1",
b1c.createMethodFinder(String.class).find("createC1").thenFind("createC2").run());
assertString("createC2",
b1c.createMethodFinder(String.class).find("createC2").thenFind("createC1").run());
- assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).run());
- assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).run());
b1p.clear();
assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find("createC1").thenFind("createC2").run());
assertString("createC2",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find("createC2").thenFind("createC1").run());
- assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).run());
- assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).run());
assertString("X",
b1c.createMethodFinder(String.class).withDefault("X").run());
assertString("X",
b1c.createMethodFinder(String.class).withDefault(()->"X").run());
@@ -760,14 +760,14 @@ class BeanStore_Test extends TestBase {
b1p.add(A1.class, null);
assertString("createC1",
b1c.createMethodFinder(String.class).find("createC1").thenFind("createC2").run());
assertString("createC2",
b1c.createMethodFinder(String.class).find("createC2").thenFind("createC1").run());
- assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).run());
- assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).find(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).run());
b1p.clear();
assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find("createC1").thenFind("createC2").run());
assertString("createC2",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find("createC2").thenFind("createC1").run());
- assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).run());
- assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC2") &&
x2.hasAllArgs(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllArgs(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).run());
+ assertString("createC1",
b1c.createMethodFinder(String.class).addBean(A1.class,
null).find(x2->x2.hasName("createC2") &&
x2.hasAllParameters(A1.class)).thenFind(x2->x2.hasName("createC1") &&
x2.hasAllParameters(A1.class)).run());
assertString("X",
b1c.createMethodFinder(String.class).withDefault("X").run());
assertString("X",
b1c.createMethodFinder(String.class).withDefault(()->"X").run());
