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 3ce71b229f Unit tests
3ce71b229f is described below
commit 3ce71b229fb9c3a0a5055b5e2bef373f23d9e078
Author: James Bognar <[email protected]>
AuthorDate: Tue Dec 2 19:12:34 2025 -0800
Unit tests
---
TODO.md | 4 +-
.../apache/juneau/commons/reflect/ClassInfo.java | 6 +-
.../juneau/commons/reflect/ConstructorInfo.java | 15 +-
.../apache/juneau/commons/reflect/ElementFlag.java | 8 +-
.../apache/juneau/commons/reflect/ElementInfo.java | 16 -
.../juneau/commons/reflect/ExecutableInfo.java | 3 +-
.../apache/juneau/commons/reflect/FieldInfo.java | 13 +-
.../apache/juneau/commons/reflect/MethodInfo.java | 7 -
.../apache/juneau/commons/reflect/Visibility.java | 19 +-
.../juneau/commons/utils/AssertionUtils.java | 46 +-
.../org/apache/juneau/commons/utils/Utils.java | 96 ++++
.../juneau/commons/collections/Cache2_Test.java | 3 +-
.../juneau/commons/collections/Cache_Test.java | 7 +-
.../commons/reflect/AnnotationProvider_Test.java | 174 +++----
.../commons/reflect/AnnotationTraversal_Test.java | 50 ++
.../commons/reflect/BeanRuntimeException_Test.java | 2 +-
.../juneau/commons/reflect/ClassInfo_Test.java | 522 ++++++++++++++++++++-
.../juneau/commons/reflect/ElementInfo_Test.java | 93 +---
.../commons/reflect/ExecutableInfo_Test.java | 24 +
.../juneau/commons/reflect/FieldInfo_Test.java | 6 +
.../juneau/commons/reflect/PackageInfo_Test.java | 13 +-
.../commons/reflect/ReflectionUtils_Test.java | 9 +
.../juneau/commons/reflect/Visibility_Test.java | 251 ++++++++++
.../apache/juneau/commons/utils/Utils_Test.java | 134 ++++++
24 files changed, 1257 insertions(+), 264 deletions(-)
diff --git a/TODO.md b/TODO.md
index 8e40c274fa..547b30d4d7 100644
--- a/TODO.md
+++ b/TODO.md
@@ -1,6 +1,6 @@
# TODO List
-**Last generated TODO number: TODO-91**
+**Last generated TODO number: TODO-93**
This file tracks pending tasks for the Apache Juneau project. For completed
items, see [TODO-completed.md](TODO-completed.md).
@@ -19,6 +19,8 @@ This file tracks pending tasks for the Apache Juneau project.
For completed item
- [ ] TODO-29 Finish setting up SonarQube analysis in git workflow.
- [ ] TODO-54 Search for places in code where Calendar should be replaced with
ZonedDateTime.
- [ ] TODO-90 Investigate replacing `StringUtils.parseIsoCalendar()` with
java.time APIs and removing the helper if possible.
+- [ ] TODO-92 Investigate if `ClassInfo.asSubclass(Class<U>)` can return a
`ClassInfoTyped<U>` object instead of `ClassInfo` for better type safety.
+- [ ] TODO-93 Investigate if `ReflectionUtils.info(Class<?>)` should return a
`ClassInfoTyped` object instead of `ClassInfo` for better type safety.
## Framework Improvements
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ClassInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ClassInfo.java
index 50f6344fe7..7cfa631cb2 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ClassInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ClassInfo.java
@@ -1462,11 +1462,7 @@ public class ClassInfo extends ElementInfo implements
Annotatable {
public List<ClassInfo> getPermittedSubclasses() {
if (inner == null || ! inner.isSealed())
return u(l());
- Class<?>[] permitted = inner.getPermittedSubclasses();
- List<ClassInfo> l = listOfSize(permitted.length);
- for (Class<?> cc : permitted)
- l.add(of(cc));
- return u(l);
+ return
u(stream(inner.getPermittedSubclasses()).map(ClassInfo::of).toList());
}
/**
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
index 5adce5fcf9..3edfa135b4 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ConstructorInfo.java
@@ -17,6 +17,7 @@
package org.apache.juneau.commons.reflect;
import static org.apache.juneau.commons.utils.AssertionUtils.*;
+import static org.apache.juneau.commons.utils.Utils.*;
import java.lang.reflect.*;
@@ -184,13 +185,13 @@ public class ConstructorInfo extends ExecutableInfo
implements Comparable<Constr
*/
@SuppressWarnings("unchecked")
public <T> T newInstance(Object...args) throws ExecutableException {
- try {
- return (T)inner.newInstance(args);
- } catch (InvocationTargetException e) {
- throw new ExecutableException(e.getTargetException());
- } catch (Exception e) {
- throw new ExecutableException(e);
- }
+ return safe(() -> {
+ try {
+ return (T)inner.newInstance(args);
+ } catch (InvocationTargetException e) {
+ throw new
ExecutableException(e.getTargetException());
+ }
+ }, e -> new ExecutableException(e));
}
/**
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementFlag.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementFlag.java
index 62dda272ad..a7f7e70fdc 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementFlag.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementFlag.java
@@ -59,7 +59,7 @@ package org.apache.juneau.commons.reflect;
* <h5 class='section'>Modifier Flags:</h5>
* <p>
* Standard Java modifiers: <c>PUBLIC</c>, <c>PRIVATE</c>, <c>PROTECTED</c>,
<c>STATIC</c>, <c>FINAL</c>,
- * <c>SYNCHRONIZED</c>, <c>VOLATILE</c>, <c>TRANSIENT</c>, <c>NATIVE</c>,
<c>ABSTRACT</c>, <c>STRICT</c>.
+ * <c>SYNCHRONIZED</c>, <c>VOLATILE</c>, <c>TRANSIENT</c>, <c>NATIVE</c>,
<c>ABSTRACT</c>.
* Each has a corresponding <c>NOT_*</c> flag.
*
* <h5 class='section'>Attribute Flags:</h5>
@@ -141,12 +141,6 @@ public enum ElementFlag {
/** NOT_ABSTRACT (negated) */
NOT_ABSTRACT,
- /** STRICT modifier */
- STRICT,
-
- /** NOT_STRICT (negated) */
- NOT_STRICT,
-
// Non-modifier attributes
/** ANNOTATION (is an annotation type) */
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementInfo.java
index 221f5fc48f..2228602119 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ElementInfo.java
@@ -118,8 +118,6 @@ public abstract class ElementInfo {
case INTERFACE -> isInterface();
case ABSTRACT -> isAbstract();
case NOT_ABSTRACT -> isNotAbstract();
- case STRICT -> isStrict();
- case NOT_STRICT -> isNotStrict();
default -> throw rex("Invalid flag for element: {0}",
flag);
};
}
@@ -236,13 +234,6 @@ public abstract class ElementInfo {
*/
public boolean isNotStatic() { return ! Modifier.isStatic(modifiers); }
- /**
- * Returns <jk>true</jk> if this element is not strict.
- *
- * @return <jk>true</jk> if this element is not strict.
- */
- public boolean isNotStrict() { return ! Modifier.isStrict(modifiers); }
-
/**
* Returns <jk>true</jk> if this element is not synchronized.
*
@@ -292,13 +283,6 @@ public abstract class ElementInfo {
*/
public boolean isStatic() { return Modifier.isStatic(modifiers); }
- /**
- * Returns <jk>true</jk> if this element is strict.
- *
- * @return <jk>true</jk> if this element is strict.
- */
- public boolean isStrict() { return Modifier.isStrict(modifiers); }
-
/**
* Returns <jk>true</jk> if this element is synchronized.
*
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
index dc32bd735b..e36204fa39 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/ExecutableInfo.java
@@ -711,8 +711,7 @@ public abstract class ExecutableInfo extends AccessibleInfo
{
*/
@Override
public final boolean setAccessible() {
- if (!nn(inner))
- return false;
+ // inner can never be null - constructor asserts non-null via
assertArgNotNull
return safeOpt(() -> {
inner.setAccessible(true);
return true;
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
index 4c4639225d..7c375fe85b 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/FieldInfo.java
@@ -29,6 +29,7 @@ import java.util.*;
import java.util.function.*;
import java.util.stream.*;
+import org.apache.juneau.commons.function.*;
import org.apache.juneau.commons.utils.*;
/**
@@ -176,12 +177,10 @@ public class FieldInfo extends AccessibleInfo implements
Comparable<FieldInfo>,
*/
@SuppressWarnings("unchecked")
public <T> T get(Object o) throws BeanRuntimeException {
- try {
+ return safe(() -> {
inner.setAccessible(true);
return (T)inner.get(o);
- } catch (Exception e) {
- throw bex(e);
- }
+ }, e -> bex(e));
}
@Override /* Annotatable */
@@ -400,12 +399,10 @@ public class FieldInfo extends AccessibleInfo implements
Comparable<FieldInfo>,
* @throws BeanRuntimeException Field was not accessible or field does
not belong to object.
*/
public void set(Object o, Object value) throws BeanRuntimeException {
- try {
+ safe((Snippet)() -> {
inner.setAccessible(true);
inner.set(o, value);
- } catch (Exception e) {
- throw bex(e);
- }
+ }, e -> bex(e));
}
//-----------------------------------------------------------------------------------------------------------------
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
index 6401bc2e01..c58978958b 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/MethodInfo.java
@@ -688,11 +688,4 @@ public class MethodInfo extends ExecutableInfo implements
Comparable<MethodInfo>
return result;
}
-
- MethodInfo findMatchingOnClass(ClassInfo c) {
- for (var m2 : c.getDeclaredMethods())
- if (hasName(m2.getName()) &&
hasParameterTypes(m2.getParameters().stream().map(ParameterInfo::getParameterType).toArray(ClassInfo[]::new)))
- return m2;
- return null;
- }
}
\ No newline at end of file
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/Visibility.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/Visibility.java
index 324974f054..150afd6063 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/Visibility.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/reflect/Visibility.java
@@ -16,6 +16,7 @@
*/
package org.apache.juneau.commons.reflect;
+import static org.apache.juneau.commons.utils.AssertionUtils.*;
import static org.apache.juneau.commons.utils.ClassUtils.*;
import java.beans.beancontext.*;
@@ -115,14 +116,14 @@ public enum Visibility {
* Security exceptions thrown on the call to {@link
Constructor#setAccessible(boolean)} are quietly ignored.
*
* @param <T> The class type.
- * @param x The constructor.
+ * @param x The constructor. Must not be <jk>null</jk>.
* @return
* The same constructor if visibility requirements met, or
<jk>null</jk> if visibility requirement not
* met or call to {@link Constructor#setAccessible(boolean)}
throws a security exception.
+ * @throws IllegalArgumentException If <c>x</c> is <jk>null</jk>.
*/
public <T> Constructor<T> transform(Constructor<T> x) {
- if (x == null)
- return null;
+ assertArgNotNull("x", x);
if (isVisible(x))
if (! setAccessible(x))
return null;
@@ -135,14 +136,14 @@ public enum Visibility {
* <p>
* Security exceptions thrown on the call to {@link
Field#setAccessible(boolean)} are quietly ignored.
*
- * @param x The field.
+ * @param x The field. Must not be <jk>null</jk>.
* @return
* The same field if visibility requirements met, or <jk>null</jk>
if visibility requirement not
* met or call to {@link Field#setAccessible(boolean)} throws a
security exception.
+ * @throws IllegalArgumentException If <c>x</c> is <jk>null</jk>.
*/
public Field transform(Field x) {
- if (x == null)
- return null;
+ assertArgNotNull("x", x);
if (isVisible(x))
if (! setAccessible(x))
return null;
@@ -155,14 +156,14 @@ public enum Visibility {
* <p>
* Security exceptions thrown on the call to {@link
Method#setAccessible(boolean)} are quietly ignored.
*
- * @param x The method.
+ * @param x The method. Must not be <jk>null</jk>.
* @return
* The same method if visibility requirements met, or
<jk>null</jk> if visibility requirement not
* met or call to {@link Method#setAccessible(boolean)} throws a
security exception.
+ * @throws IllegalArgumentException If <c>x</c> is <jk>null</jk>.
*/
public Method transform(Method x) {
- if (x == null)
- return null;
+ assertArgNotNull("x", x);
if (isVisible(x))
if (! setAccessible(x))
return null;
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/AssertionUtils.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/AssertionUtils.java
index 9d2e9012bf..b8e22005c8 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/AssertionUtils.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/AssertionUtils.java
@@ -110,9 +110,8 @@ public class AssertionUtils {
* @return The same object.
* @throws IllegalArgumentException Thrown if the specified string is
<jk>null</jk> or blank.
*/
- @SuppressWarnings("null")
public static final String assertArgNotNullOrBlank(String name, String
o) throws IllegalArgumentException {
- assertArg(o != null, "Argument ''{0}'' cannot be null.", name);
+ assertArgNotNull(name, o);
assertArg(! o.isBlank(), "Argument ''{0}'' cannot be blank.",
name);
return o;
}
@@ -137,8 +136,8 @@ public class AssertionUtils {
* @throws IllegalArgumentException Constructed exception.
*/
public static final void assertArgsNotNull(String name1, Object o1,
String name2, Object o2) throws IllegalArgumentException {
- assertArg(o1 != null, "Argument ''{0}'' cannot be null.",
name1);
- assertArg(o2 != null, "Argument ''{0}'' cannot be null.",
name2);
+ assertArgNotNull(name1, o1);
+ assertArgNotNull(name2, o2);
}
/**
@@ -163,9 +162,9 @@ public class AssertionUtils {
* @throws IllegalArgumentException Constructed exception.
*/
public static final void assertArgsNotNull(String name1, Object o1,
String name2, Object o2, String name3, Object o3) throws
IllegalArgumentException {
- assertArg(o1 != null, "Argument ''{0}'' cannot be null.",
name1);
- assertArg(o2 != null, "Argument ''{0}'' cannot be null.",
name2);
- assertArg(o3 != null, "Argument ''{0}'' cannot be null.",
name3);
+ assertArgNotNull(name1, o1);
+ assertArgNotNull(name2, o2);
+ assertArgNotNull(name3, o3);
}
/**
@@ -182,10 +181,10 @@ public class AssertionUtils {
* @throws IllegalArgumentException Constructed exception.
*/
public static final void assertArgsNotNull(String name1, Object o1,
String name2, Object o2, String name3, Object o3, String name4, Object o4)
throws IllegalArgumentException {
- assertArg(o1 != null, "Argument ''{0}'' cannot be null.",
name1);
- assertArg(o2 != null, "Argument ''{0}'' cannot be null.",
name2);
- assertArg(o3 != null, "Argument ''{0}'' cannot be null.",
name3);
- assertArg(o4 != null, "Argument ''{0}'' cannot be null.",
name4);
+ assertArgNotNull(name1, o1);
+ assertArgNotNull(name2, o2);
+ assertArgNotNull(name3, o3);
+ assertArgNotNull(name4, o4);
}
/**
@@ -205,11 +204,11 @@ public class AssertionUtils {
*/
public static final void assertArgsNotNull(String name1, Object o1,
String name2, Object o2, String name3, Object o3, String name4, Object o4,
String name5, Object o5)
throws IllegalArgumentException {
- assertArg(o1 != null, "Argument ''{0}'' cannot be null.",
name1);
- assertArg(o2 != null, "Argument ''{0}'' cannot be null.",
name2);
- assertArg(o3 != null, "Argument ''{0}'' cannot be null.",
name3);
- assertArg(o4 != null, "Argument ''{0}'' cannot be null.",
name4);
- assertArg(o5 != null, "Argument ''{0}'' cannot be null.",
name5);
+ assertArgNotNull(name1, o1);
+ assertArgNotNull(name2, o2);
+ assertArgNotNull(name3, o3);
+ assertArgNotNull(name4, o4);
+ assertArgNotNull(name5, o5);
}
/**
@@ -232,10 +231,10 @@ public class AssertionUtils {
* @return The object cast to the specified type.
* @throws IllegalArgumentException Thrown if the object is not an
instance of the specified type.
*/
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({ "unchecked" })
public static final <T> T assertType(Class<T> type, Object o) throws
IllegalArgumentException {
- assertArg(type != null, "Type cannot be null.");
- assertArg(o != null, "Object cannot be null.");
+ assertArgNotNull("type", type);
+ assertArgNotNull("o", o);
if (! type.isInstance(o))
throw illegalArg("Object is not an instance of {0}:
{1}", cn(type), cn(o));
return (T)o;
@@ -262,10 +261,10 @@ public class AssertionUtils {
* @return The object cast to the specified type.
* @throws RuntimeException Thrown if the object is not an instance of
the specified type (the exception is provided by the supplier).
*/
- @SuppressWarnings("unchecked")
+ @SuppressWarnings({ "unchecked" })
public static final <T> T assertType(Class<T> type, Object o,
java.util.function.Supplier<? extends RuntimeException> exceptionSupplier)
throws RuntimeException {
- assertArg(type != null, "Type cannot be null.");
- assertArg(o != null, "Object cannot be null.");
+ assertArgNotNull("type", type);
+ assertArgNotNull("o", o);
if (! type.isInstance(o))
throw exceptionSupplier.get();
return (T)o;
@@ -316,9 +315,8 @@ public class AssertionUtils {
* @return The same object.
* @throws IllegalArgumentException Thrown if the specified varargs
array or any of its elements are <jk>null</jk>.
*/
- @SuppressWarnings("null")
public static final <T> T[] assertVarargsNotNull(String name, T[] o)
throws IllegalArgumentException {
- assertArg(o != null, "Argument ''{0}'' cannot be null.", name);
+ assertArgNotNull(name, o);
for (var i = 0; i < o.length; i++)
assertArg(nn(o[i]), "Argument ''{0}'' parameter {1}
cannot be null.", name, i);
return o;
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/Utils.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/Utils.java
index b43b7ced47..be1109d3bb 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/Utils.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/Utils.java
@@ -1376,6 +1376,35 @@ public class Utils {
}
}
+ /**
+ * Runs a snippet of code with a custom exception mapper.
+ *
+ * <p>
+ * This method allows you to define a function that converts any thrown
throwable into a runtime exception.
+ * This is useful when you need to wrap exceptions in a specific
runtime exception type.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Wrap code execution with custom exception handling</jc>
+ * Utils.<jsm>safe</jsm>(() -> {
+ * <jc>// some code that may throw</jc>
+ * }, <jv>e</jv> -> <jk>new</jk>
CustomRuntimeException(<jv>e</jv>));
+ * </p>
+ *
+ * @param snippet The snippet of code to run.
+ * @param exceptionMapper A function that converts the thrown throwable
into a runtime exception.
+ * @throws RuntimeException The exception returned by the exception
mapper if the snippet throws a throwable.
+ */
+ public static void safe(Snippet snippet, Function<Throwable,
RuntimeException> exceptionMapper) {
+ try {
+ snippet.run();
+ } catch (RuntimeException t) {
+ throw t;
+ } catch (Throwable t) {
+ throw exceptionMapper.apply(t);
+ }
+ }
+
/**
* Used to wrap code that returns a value but throws an exception.
* Useful in cases where you're trying to execute code in a fluent
method call
@@ -1395,6 +1424,41 @@ public class Utils {
}
}
+ /**
+ * Used to wrap code that returns a value but throws an exception, with
a custom exception mapper.
+ *
+ * <p>
+ * This method allows you to define a function that converts any thrown
exception into a runtime exception.
+ * This is useful when you need to wrap exceptions in a specific
runtime exception type (e.g., {@link ExecutableException}).
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Wrap a constructor invocation with custom exception
handling</jc>
+ * <jk>return</jk> Utils.<jsm>safe</jsm>(() -> {
+ * <jk>try</jk> {
+ * <jk>return</jk>
(<jk>T</jk>)inner.newInstance(args);
+ * } <jk>catch</jk> (InvocationTargetException <jv>e</jv>)
{
+ * <jk>throw new</jk>
ExecutableException(<jv>e</jv>.getTargetException());
+ * }
+ * }, <jv>e</jv> -> <jk>new</jk>
ExecutableException(<jv>e</jv>));
+ * </p>
+ *
+ * @param <T> The return type.
+ * @param s The supplier that may throw an exception.
+ * @param exceptionMapper A function that converts the thrown exception
into a runtime exception.
+ * @return The result of the supplier execution.
+ * @throws RuntimeException The exception returned by the exception
mapper if the supplier throws an exception.
+ */
+ public static <T> T safe(ThrowingSupplier<T> s, Function<Exception,
RuntimeException> exceptionMapper) {
+ try {
+ return s.get();
+ } catch (RuntimeException e) {
+ throw e;
+ } catch (Exception e) {
+ throw exceptionMapper.apply(e);
+ }
+ }
+
/**
* Executes a supplier that may throw an exception and returns an
Optional.
*
@@ -1446,6 +1510,38 @@ public class Utils {
}
}
+ /**
+ * Allows you to wrap a supplier that throws an exception with a custom
exception mapper.
+ *
+ * <p>
+ * This method allows you to define a function that converts any thrown
throwable into a runtime exception.
+ * This is useful when you need to wrap exceptions in a specific
runtime exception type.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Wrap a supplier with custom exception handling</jc>
+ * <jk>return</jk> Utils.<jsm>safeSupplier</jsm>(() -> {
+ * <jc>// some code that may throw</jc>
+ * <jk>return</jk> <jv>result</jv>;
+ * }, <jv>e</jv> -> <jk>new</jk>
CustomRuntimeException(<jv>e</jv>));
+ * </p>
+ *
+ * @param <T> The supplier type.
+ * @param supplier The supplier throwing an exception.
+ * @param exceptionMapper A function that converts the thrown throwable
into a runtime exception.
+ * @return The supplied result.
+ * @throws RuntimeException The exception returned by the exception
mapper if the supplier threw a throwable.
+ */
+ public static <T> T
safeSupplier(ThrowableUtils.SupplierWithThrowable<T> supplier,
Function<Throwable, RuntimeException> exceptionMapper) {
+ try {
+ return supplier.get();
+ } catch (RuntimeException t) {
+ throw t;
+ } catch (Throwable t) {
+ throw exceptionMapper.apply(t);
+ }
+ }
+
/**
* Helper method for creating StringBuilder objects.
*
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache2_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache2_Test.java
index ee9cd12df3..b34c199f52 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache2_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache2_Test.java
@@ -20,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.*;
import static org.apache.juneau.commons.collections.CacheMode.*;
import static org.apache.juneau.junit.bct.BctAssertions.*;
+import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
@@ -726,7 +727,7 @@ class Cache2_Test extends TestBase {
// Verify each thread's cache is independent - same thread
should get same cached value
var threadValues2 = new ConcurrentHashMap<Thread, String>();
- var threads = new
java.util.ArrayList<Thread>(threadValues.keySet());
+ var threads = new ArrayList<>(threadValues.keySet());
future1 = java.util.concurrent.CompletableFuture.runAsync(() ->
{
var value = x.get("user", 123, () ->
"should-not-be-called");
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache_Test.java
index 04d7a155b3..21b145350b 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/collections/Cache_Test.java
@@ -20,6 +20,7 @@ import static
org.apache.juneau.commons.collections.CacheMode.*;
import static org.apache.juneau.junit.bct.BctAssertions.*;
import static org.junit.jupiter.api.Assertions.*;
+import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
@@ -106,11 +107,11 @@ class Cache_Test extends TestBase {
// Null keys are now allowed
assertEquals("value-null", cache.get(null, () -> "value-null"));
-
+
// Verify caching works with null keys
assertEquals("value-null", cache.get(null)); // Cached (hit #1)
assertEquals(1, cache.getCacheHits());
-
+
assertEquals("value-null", cache.get(null)); // Cached (hit #2)
assertEquals(2, cache.getCacheHits());
}
@@ -1023,7 +1024,7 @@ class Cache_Test extends TestBase {
// Verify each thread's cache is independent - same thread
should get same cached value
var threadValues2 = new ConcurrentHashMap<Thread, String>();
- var threads = new
java.util.ArrayList<Thread>(threadValues.keySet());
+ var threads = new ArrayList<>(threadValues.keySet());
future1 = CompletableFuture.runAsync(() -> {
var value = cache.get("key1", () ->
"should-not-be-called");
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationProvider_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationProvider_Test.java
index 33b320a588..f15f41e068 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationProvider_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationProvider_Test.java
@@ -19,7 +19,6 @@ package org.apache.juneau.commons.reflect;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import static org.apache.juneau.commons.reflect.AnnotationTraversal.*;
-import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.junit.jupiter.api.Assertions.*;
import java.lang.annotation.*;
@@ -128,7 +127,7 @@ class AnnotationProvider_Test extends TestBase {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(TestClass.class);
var annotations = provider.find(TestAnnotation.class, ci, SELF);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
assertEquals("class",
annotations.get(0).getValue().orElse(null));
@@ -139,7 +138,7 @@ class AnnotationProvider_Test extends TestBase {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(ChildClass.class);
var annotations = provider.find(TestAnnotation.class, ci, SELF,
PARENTS);
-
+
assertNotNull(annotations);
// Should find annotation on child class
assertTrue(annotations.size() >= 1);
@@ -154,7 +153,7 @@ class AnnotationProvider_Test extends TestBase {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(TestClass.class);
var annotations = provider.find(ParentAnnotation.class, ci,
SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.isEmpty());
}
@@ -182,7 +181,7 @@ class AnnotationProvider_Test extends TestBase {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(TestClass.class);
var annotations = provider.find(ci, SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
assertTrue(annotations.stream().anyMatch(a ->
a.isType(TestAnnotation.class)));
@@ -204,9 +203,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
var annotations = provider.find(MultiTargetAnnotation.class,
field, SELF);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
assertEquals(1, annotations.get(0).getInt("value").orElse(0));
@@ -222,14 +221,14 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
// Call with SELF traversal - should include both runtime
annotations (line 1040) and declared annotations (line 1041)
var annotations = provider.find(TestAnnotation.class, field,
SELF);
-
+
assertNotNull(annotations);
// Should find both the runtime annotation and the declared
annotation (if any)
assertTrue(annotations.size() >= 1, "Should find at least the
runtime annotation");
-
+
// Verify runtime annotation is found
var runtimeAnnotationFound = annotations.stream()
.filter(a ->
a.getValue().orElse("").equals("runtimeField"))
@@ -243,9 +242,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
var annotations = provider.find(TestAnnotation.class, field,
SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.isEmpty());
}
@@ -260,9 +259,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
var annotations = provider.find(field, SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
assertTrue(annotations.stream().anyMatch(a ->
a.isType(MultiTargetAnnotation.class)));
@@ -278,9 +277,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
var annotations = provider.find(MultiTargetAnnotation.class,
constructor, SELF);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
assertEquals(2, annotations.get(0).getInt("value").orElse(0));
@@ -296,9 +295,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
var annotations = provider.find(constructor, SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
assertTrue(annotations.stream().anyMatch(a ->
a.isType(MultiTargetAnnotation.class)));
@@ -314,9 +313,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
var annotations = provider.find(MultiTargetAnnotation.class,
method, SELF);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
assertEquals(3, annotations.get(0).getInt("value").orElse(0));
@@ -332,9 +331,9 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
var method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
var annotations = provider.find(method, SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
assertTrue(annotations.stream().anyMatch(a ->
a.isType(MultiTargetAnnotation.class)));
@@ -352,9 +351,9 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
ParameterInfo param = method.getParameter(0);
assertNotNull(param);
-
+
var annotations = provider.find(MultiTargetAnnotation.class,
param, SELF);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
assertEquals(4, annotations.get(0).getInt("value").orElse(0));
@@ -372,9 +371,9 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
var param = method.getParameter(0);
assertNotNull(param);
-
+
var annotations = provider.find(param, SELF);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
assertTrue(annotations.stream().anyMatch(a ->
a.isType(MultiTargetAnnotation.class)));
@@ -388,7 +387,7 @@ class AnnotationProvider_Test extends TestBase {
void l01_has_typedClass_exists_returnsTrue() {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(TestClass.class);
-
+
assertTrue(provider.has(TestAnnotation.class, ci, SELF));
}
@@ -396,7 +395,7 @@ class AnnotationProvider_Test extends TestBase {
void l02_has_typedClass_notExists_returnsFalse() {
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(TestClass.class);
-
+
assertFalse(provider.has(ParentAnnotation.class, ci, SELF));
}
@@ -410,7 +409,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
ConstructorInfo constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
assertTrue(provider.has(MultiTargetAnnotation.class,
constructor, SELF));
}
@@ -420,7 +419,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
ConstructorInfo constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
assertFalse(provider.has(TestAnnotation.class, constructor,
SELF));
}
@@ -434,7 +433,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
FieldInfo field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
assertTrue(provider.has(MultiTargetAnnotation.class, field,
SELF));
}
@@ -444,7 +443,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
FieldInfo field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
assertFalse(provider.has(TestAnnotation.class, field, SELF));
}
@@ -458,7 +457,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
assertTrue(provider.has(MultiTargetAnnotation.class, method,
SELF));
}
@@ -468,7 +467,7 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
assertFalse(provider.has(TestAnnotation.class, method, SELF));
}
@@ -484,7 +483,7 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
ParameterInfo param = method.getParameter(0);
assertNotNull(param);
-
+
assertTrue(provider.has(MultiTargetAnnotation.class, param,
SELF));
}
@@ -496,7 +495,7 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
ParameterInfo param = method.getParameter(0);
assertNotNull(param);
-
+
assertFalse(provider.has(TestAnnotation.class, param, SELF));
}
@@ -509,10 +508,10 @@ class AnnotationProvider_Test extends TestBase {
// This test covers line 991-992 - default traversals for
ClassInfo (PARENTS, PACKAGE)
var provider = AnnotationProvider.create().build();
var ci = ClassInfo.of(ChildClass.class);
-
+
// Call with no traversals - should use default (PARENTS,
PACKAGE)
var annotations = provider.find(TestAnnotation.class, ci);
-
+
assertNotNull(annotations);
// Should find annotation from child class
assertTrue(annotations.size() >= 1);
@@ -525,10 +524,10 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
// Call with no traversals - should use default (SELF,
MATCHING_METHODS, DECLARING_CLASS, RETURN_TYPE, PACKAGE)
var annotations = provider.find(MultiTargetAnnotation.class,
method);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
}
@@ -540,10 +539,10 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
FieldInfo field = ci.getPublicField(x ->
x.hasName("field1")).orElse(null);
assertNotNull(field);
-
+
// Call with no traversals - should use default (SELF)
var annotations = provider.find(MultiTargetAnnotation.class,
field);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
}
@@ -555,10 +554,10 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
ConstructorInfo constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
// Call with no traversals - should use default (SELF)
var annotations = provider.find(MultiTargetAnnotation.class,
constructor);
-
+
assertNotNull(annotations);
assertEquals(1, annotations.size());
}
@@ -572,10 +571,10 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
ParameterInfo param = method.getParameter(0);
assertNotNull(param);
-
+
// Call with no traversals - should use default (SELF,
MATCHING_PARAMETERS, PARAMETER_TYPE)
var annotations = provider.find(MultiTargetAnnotation.class,
param);
-
+
assertNotNull(annotations);
assertTrue(annotations.size() >= 1);
}
@@ -585,14 +584,14 @@ class AnnotationProvider_Test extends TestBase {
// This test covers line 1014 - when getPackage() returns null
// Primitive types and arrays of primitives have no package
var provider = AnnotationProvider.create().build();
-
+
// int.class has no package (getPackage() returns null)
var ci = ClassInfo.of(int.class);
assertNull(ci.getPackage(), "int.class should have no package");
-
+
// Call with PACKAGE traversal - should handle null package
gracefully
var annotations = provider.find(TestAnnotation.class, ci,
AnnotationTraversal.PACKAGE);
-
+
// Should not throw exception, just return empty list
assertNotNull(annotations);
assertEquals(0, annotations.size());
@@ -605,17 +604,17 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(MatchingMethodChild.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("matchingMethod")).orElse(null);
assertNotNull(method);
-
+
// Verify the matching methods order: [child, interface, parent]
var matchingMethods = method.getMatchingMethods();
assertTrue(matchingMethods.size() >= 3, "Should have at least
child, interface, and parent methods. Found: " + matchingMethods.size());
-
+
// Verify we can find the parent method in the matching methods
var parentMethod = matchingMethods.stream()
.filter(m ->
MatchingMethodParent.class.equals(m.getDeclaringClass().inner()))
.findFirst();
assertTrue(parentMethod.isPresent(), "Parent method should be
in matching methods");
-
+
// Verify the parent method has the annotation
var parentMethodAnnotations =
parentMethod.get().getDeclaredAnnotations(MultiTargetAnnotation.class).toList();
assertTrue(parentMethodAnnotations.size() > 0, "Parent method
should have annotation. Found " + parentMethodAnnotations.size() + "
annotations");
@@ -626,22 +625,22 @@ class AnnotationProvider_Test extends TestBase {
parentAnnotationValue =
parentMethodAnnotation.getValue(Integer.class, "value").orElse(null);
}
assertEquals(20, parentAnnotationValue, "Parent method
annotation should have value 20. Annotation: " + parentMethodAnnotation);
-
+
// Skip the first (child method) - should have interface and
parent
var methodsAfterSkip =
matchingMethods.stream().skip(1).toList();
assertTrue(methodsAfterSkip.size() >= 2, "Should have interface
and parent methods after skipping child");
-
+
// Call with MATCHING_METHODS traversal - should include
annotations from parent and interface methods
// Note: skip(1) skips the child method itself, so we get
interface and parent
var annotations = provider.find(MultiTargetAnnotation.class,
method, MATCHING_METHODS);
-
+
assertNotNull(annotations);
// Should find annotations from:
// 1. Interface method (value=10) - from declared interfaces of
child class
// 2. Parent class method (value=20) - from parent class
// Note: The child method itself is skipped by .skip(1)
assertTrue(annotations.size() >= 2, "Should find annotations
from parent and interface matching methods. Found: " + annotations.size());
-
+
// Debug: print what we found
var foundValues = annotations.stream()
.map(a -> {
@@ -653,7 +652,7 @@ class AnnotationProvider_Test extends TestBase {
})
.filter(v -> v != null)
.toList();
-
+
// Verify we have the interface annotation (value=10) - comes
first after skip(1)
var interfaceAnnotation = annotations.stream()
.filter(a -> {
@@ -665,7 +664,7 @@ class AnnotationProvider_Test extends TestBase {
})
.findFirst();
assertTrue(interfaceAnnotation.isPresent(), "Should find
annotation from interface method. Found values: " + foundValues);
-
+
// Verify we have the parent annotation (value=20) - comes
after interface
var parentAnnotation = annotations.stream()
.filter(a -> {
@@ -688,11 +687,11 @@ class AnnotationProvider_Test extends TestBase {
assertNotNull(method);
ParameterInfo param = method.getParameter(0);
assertNotNull(param);
-
+
// Verify the matching parameters order: [child, interface,
parent]
var matchingParameters = param.getMatchingParameters();
assertTrue(matchingParameters.size() >= 3, "Should have at
least child, interface, and parent parameters. Found: " +
matchingParameters.size());
-
+
// Verify we can find the parent parameter in the matching
parameters
var parentParameter = matchingParameters.stream()
.filter(p -> {
@@ -704,7 +703,7 @@ class AnnotationProvider_Test extends TestBase {
})
.findFirst();
assertTrue(parentParameter.isPresent(), "Parent parameter
should be in matching parameters");
-
+
// Verify the parent parameter has the annotation
var parentParameterAnnotations =
parentParameter.get().getAnnotations(MultiTargetAnnotation.class).toList();
assertTrue(parentParameterAnnotations.size() > 0, "Parent
parameter should have annotation. Found " + parentParameterAnnotations.size() +
" annotations");
@@ -714,22 +713,22 @@ class AnnotationProvider_Test extends TestBase {
parentParameterValue =
parentParameterAnnotation.getValue(Integer.class, "value").orElse(null);
}
assertEquals(200, parentParameterValue, "Parent parameter
annotation should have value 200. Annotation: " + parentParameterAnnotation);
-
+
// Skip the first (child parameter) - should have interface and
parent
var parametersAfterSkip =
matchingParameters.stream().skip(1).toList();
assertTrue(parametersAfterSkip.size() >= 2, "Should have
interface and parent parameters after skipping child");
-
+
// Call with MATCHING_PARAMETERS traversal - should include
annotations from parent and interface parameters
// Note: skip(1) skips the child parameter itself, so we get
interface and parent
var annotations = provider.find(MultiTargetAnnotation.class,
param, MATCHING_PARAMETERS);
-
+
assertNotNull(annotations);
// Should find annotations from:
// 1. Interface parameter (value=100) - from declared
interfaces of child class
// 2. Parent class parameter (value=200) - from parent class
// Note: The child parameter itself is skipped by .skip(1)
assertTrue(annotations.size() >= 2, "Should find annotations
from parent and interface matching parameters. Found: " + annotations.size());
-
+
// Debug: print what we found
var foundValues = annotations.stream()
.map(a -> {
@@ -741,7 +740,7 @@ class AnnotationProvider_Test extends TestBase {
})
.filter(v -> v != null)
.toList();
-
+
// Verify we have the interface parameter annotation
(value=100) - comes first after skip(1)
var interfaceAnnotation = annotations.stream()
.filter(a -> {
@@ -753,7 +752,7 @@ class AnnotationProvider_Test extends TestBase {
})
.findFirst();
assertTrue(interfaceAnnotation.isPresent(), "Should find
annotation from interface parameter. Found values: " + foundValues);
-
+
// Verify we have the parent parameter annotation (value=200) -
comes after interface
var parentAnnotation = annotations.stream()
.filter(a -> {
@@ -777,15 +776,15 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
MethodInfo method = ci.getPublicMethod(x ->
x.hasName("method1")).orElse(null);
assertNotNull(method);
-
+
// Call with SELF traversal - should trigger runtimeCache.get()
which calls load() for Method
// This covers line 1072: annotationMap.find(mi.inner())
var annotations = provider.find(TestAnnotation.class, method,
SELF);
-
+
assertNotNull(annotations);
// Should find the runtime annotation
assertTrue(annotations.size() >= 1, "Should find at least the
runtime annotation");
-
+
// Verify runtime annotation is found
var runtimeAnnotationFound = annotations.stream()
.filter(a ->
a.getValue().orElse("").equals("runtimeMethod"))
@@ -804,15 +803,15 @@ class AnnotationProvider_Test extends TestBase {
var ci = ClassInfo.of(TestClass.class);
ConstructorInfo constructor = ci.getPublicConstructor(x ->
x.getParameterCount() == 0).orElse(null);
assertNotNull(constructor);
-
+
// Call with SELF traversal - should trigger runtimeCache.get()
which calls load() for Constructor
// This covers line 1080: annotationMap.find(ci.inner())
var annotations = provider.find(TestAnnotation.class,
constructor, SELF);
-
+
assertNotNull(annotations);
// Should find the runtime annotation
assertTrue(annotations.size() >= 1, "Should find at least the
runtime annotation");
-
+
// Verify runtime annotation is found
var runtimeAnnotationFound = annotations.stream()
.filter(a ->
a.getValue().orElse("").equals("runtimeConstructor"))
@@ -847,7 +846,7 @@ class AnnotationProvider_Test extends TestBase {
.logOnExit(true)
.build();
assertNotNull(provider1);
-
+
var provider2 = AnnotationProvider.create()
.logOnExit(false)
.build();
@@ -887,6 +886,7 @@ class AnnotationProvider_Test extends TestBase {
return TestAnnotation.class;
}
+ @SuppressWarnings("unused")
public Class<?>[] onClass() {
return onClass;
}
@@ -930,6 +930,7 @@ class AnnotationProvider_Test extends TestBase {
return TestAnnotation.class;
}
+ @SuppressWarnings("unused")
public String[] on() {
return on;
}
@@ -958,17 +959,17 @@ class AnnotationProvider_Test extends TestBase {
// This test covers line 245 - the varargs version that
converts to list
var runtimeAnnotation1 = new RuntimeTestAnnotation(new
Class<?>[]{TestClass.class}, "runtime1");
var runtimeAnnotation2 = new RuntimeTestAnnotation(new
Class<?>[]{ParentClass.class}, "runtime2");
-
+
var provider = AnnotationProvider.create()
.addRuntimeAnnotations(runtimeAnnotation1,
runtimeAnnotation2) // Varargs - covers line 245
.build();
-
+
assertNotNull(provider);
-
+
// Verify the runtime annotations are applied
var ci = ClassInfo.of(TestClass.class);
var annotations = provider.find(TestAnnotation.class, ci, SELF);
-
+
// Should find the runtime annotation
assertTrue(annotations.size() >= 1);
var runtimeAnnotation = annotations.stream()
@@ -982,17 +983,17 @@ class AnnotationProvider_Test extends TestBase {
// This test covers line 343 - the on() method returning
String[] is processed
var className = TestClass.class.getName();
var runtimeAnnotation = new RuntimeOnAnnotation(new
String[]{className}, "runtimeOn");
-
+
var provider = AnnotationProvider.create()
.addRuntimeAnnotations(runtimeAnnotation)
.build();
-
+
assertNotNull(provider);
-
+
// Verify the runtime annotation is applied using on() method
var ci = ClassInfo.of(TestClass.class);
var annotations = provider.find(TestAnnotation.class, ci, SELF);
-
+
// Should find the runtime annotation
assertTrue(annotations.size() >= 1);
var runtimeAnnotationFound = annotations.stream()
@@ -1013,6 +1014,7 @@ class AnnotationProvider_Test extends TestBase {
return TestAnnotation.class;
}
+ @SuppressWarnings("unused")
public String onClass() { // Wrong return type - should be
Class[]
return "invalid";
}
@@ -1045,6 +1047,7 @@ class AnnotationProvider_Test extends TestBase {
return TestAnnotation.class;
}
+ @SuppressWarnings("unused")
public String on() { // Wrong return type - should be String[]
return "invalid";
}
@@ -1069,7 +1072,7 @@ class AnnotationProvider_Test extends TestBase {
void
n02_addRuntimeAnnotations_invalidOnClassReturnType_throwsException() {
// This test covers line 334 - onClass() method with wrong
return type
var invalidAnnotation = new InvalidOnClassAnnotation();
-
+
assertThrows(BeanRuntimeException.class, () -> {
AnnotationProvider.create()
.addRuntimeAnnotations(invalidAnnotation)
@@ -1081,7 +1084,7 @@ class AnnotationProvider_Test extends TestBase {
void n03_addRuntimeAnnotations_invalidOnReturnType_throwsException() {
// This test covers line 341 - on() method with wrong return
type
var invalidAnnotation = new InvalidOnAnnotation();
-
+
assertThrows(BeanRuntimeException.class, () -> {
AnnotationProvider.create()
.addRuntimeAnnotations(invalidAnnotation)
@@ -1101,6 +1104,7 @@ class AnnotationProvider_Test extends TestBase {
return TestAnnotation.class;
}
+ @SuppressWarnings("unused")
public Class<?>[] onClass() {
throw new RuntimeException("Test exception from
onClass()");
}
@@ -1125,7 +1129,7 @@ class AnnotationProvider_Test extends TestBase {
void n05_addRuntimeAnnotations_throwingOnClass_coversLine349() {
// This test covers line 349 - exception during method
invocation (not BeanRuntimeException)
var throwingAnnotation = new ThrowingOnClassAnnotation();
-
+
// The exception from onClass() will be caught and wrapped in
BeanRuntimeException
assertThrows(BeanRuntimeException.class, () -> {
AnnotationProvider.create()
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationTraversal_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationTraversal_Test.java
new file mode 100644
index 0000000000..32d0081b43
--- /dev/null
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/AnnotationTraversal_Test.java
@@ -0,0 +1,50 @@
+/*
+ * 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.commons.reflect;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.apache.juneau.*;
+import org.junit.jupiter.api.*;
+
+class AnnotationTraversal_Test extends TestBase {
+
+
//====================================================================================================
+ // getOrder()
+
//====================================================================================================
+ @Test
+ void a001_getOrder() {
+ // Test all enum values and their order values
+ assertEquals(10, AnnotationTraversal.SELF.getOrder());
+ assertEquals(20, AnnotationTraversal.PARENTS.getOrder());
+ assertEquals(20,
AnnotationTraversal.MATCHING_METHODS.getOrder());
+ assertEquals(20,
AnnotationTraversal.MATCHING_PARAMETERS.getOrder());
+ assertEquals(30, AnnotationTraversal.RETURN_TYPE.getOrder());
+ assertEquals(30, AnnotationTraversal.PARAMETER_TYPE.getOrder());
+ assertEquals(35,
AnnotationTraversal.DECLARING_CLASS.getOrder());
+ assertEquals(40, AnnotationTraversal.PACKAGE.getOrder());
+ assertEquals(999, AnnotationTraversal.REVERSE.getOrder());
+
+ // Verify order values are as expected (lower values = higher
precedence)
+ assertTrue(AnnotationTraversal.SELF.getOrder() <
AnnotationTraversal.PARENTS.getOrder());
+ assertTrue(AnnotationTraversal.PARENTS.getOrder() <
AnnotationTraversal.RETURN_TYPE.getOrder());
+ assertTrue(AnnotationTraversal.RETURN_TYPE.getOrder() <
AnnotationTraversal.DECLARING_CLASS.getOrder());
+ assertTrue(AnnotationTraversal.DECLARING_CLASS.getOrder() <
AnnotationTraversal.PACKAGE.getOrder());
+ assertTrue(AnnotationTraversal.PACKAGE.getOrder() <
AnnotationTraversal.REVERSE.getOrder());
+ }
+}
+
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/BeanRuntimeException_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/BeanRuntimeException_Test.java
index 6dc642a43e..e441da1477 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/BeanRuntimeException_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/BeanRuntimeException_Test.java
@@ -164,7 +164,7 @@ class BeanRuntimeException_Test extends TestBase {
@Test
void
d06_constructor_withNullCauseNullClassAndNullMessage_handlesNulls() {
- var ex = new BeanRuntimeException(null, null, null);
+ var ex = new BeanRuntimeException((Class<?>)null, null,
(Object)null);
assertNotNull(ex);
assertNull(ex.getCause());
assertNull(ex.getMessage());
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
index e70c683617..81bd3afad8 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ClassInfo_Test.java
@@ -18,7 +18,6 @@ package org.apache.juneau.commons.reflect;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
-import static org.apache.juneau.Context.*;
import static org.apache.juneau.TestUtils.*;
import static org.apache.juneau.commons.reflect.ClassArrayFormat.*;
import static org.apache.juneau.commons.reflect.ClassInfo.*;
@@ -36,15 +35,12 @@ import java.util.stream.*;
import org.apache.juneau.*;
import org.apache.juneau.annotation.*;
-import org.apache.juneau.commons.collections.*;
import org.apache.juneau.commons.collections.Value;
import org.apache.juneau.svl.*;
import org.junit.jupiter.api.*;
public class ClassInfo_Test extends TestBase {
- private static final
org.apache.juneau.commons.reflect.AnnotationProvider AP =
org.apache.juneau.commons.reflect.AnnotationProvider.INSTANCE;
-
@Documented
@Target(TYPE)
@Retention(RUNTIME)
@@ -511,6 +507,30 @@ public class ClassInfo_Test extends TestBase {
// For types without inner class, should return null
var ci3 = ClassInfo.of((Class<?>)null, pType);
assertNull(ci3.arrayType());
+
+ // Test when inner.arrayType() returns null (line 391)
+ // Note: Most classes' arrayType() returns a valid array class
+ // The null check at line 391 handles the case when
inner.arrayType() returns null
+ // This is a defensive check, but in practice most classes have
valid array types
+ // The line is covered by the null inner check above
+ }
+
+
//====================================================================================================
+ // asSubclass(Class<?>)
+
//====================================================================================================
+ @Test
+ void a002b_asSubclass() {
+ // Valid cast
+ var ci = ClassInfo.of(String.class);
+ var result = ci.asSubclass(CharSequence.class);
+ assertSame(ci, result);
+
+ // Invalid cast - should throw
+ assertThrows(ClassCastException.class, () ->
ci.asSubclass(Integer.class));
+
+ // For types without inner class, should return null
+ var ci2 = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci2.asSubclass(CharSequence.class));
}
//====================================================================================================
@@ -646,6 +666,66 @@ public class ClassInfo_Test extends TestBase {
assertNull(pTypeGenericArgInfo.getClassLoader());
}
+
//====================================================================================================
+ // canAcceptArg(Object)
+
//====================================================================================================
+ @Test
+ void a011b_canAcceptArg() {
+ // Valid argument
+ assertTrue(ClassInfo.of(String.class).canAcceptArg("test"));
+ assertTrue(ClassInfo.of(Integer.class).canAcceptArg(42));
+ assertTrue(ClassInfo.of(int.class).canAcceptArg(42));
+
+ // Null argument - non-primitive
+ assertTrue(ClassInfo.of(String.class).canAcceptArg(null));
+ assertTrue(ClassInfo.of(Integer.class).canAcceptArg(null));
+
+ // Null argument - primitive (should return false)
+ assertFalse(ClassInfo.of(int.class).canAcceptArg(null));
+ assertFalse(ClassInfo.of(boolean.class).canAcceptArg(null));
+
+ // Invalid argument
+ assertFalse(ClassInfo.of(String.class).canAcceptArg(42));
+
+ // For types without inner class, should return false
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.canAcceptArg("test"));
+ assertFalse(ci.canAcceptArg(null));
+
+ // Test primitive-to-wrapper and wrapper-to-primitive
conversions (line 435)
+ // Primitive can accept wrapper
+
assertTrue(ClassInfo.of(int.class).canAcceptArg(Integer.valueOf(42)));
+
assertTrue(ClassInfo.of(long.class).canAcceptArg(Long.valueOf(42L)));
+ // Wrapper can accept primitive (via autoboxing, but isInstance
won't work, so need wrapper check)
+ assertTrue(ClassInfo.of(Integer.class).canAcceptArg(42));
+ assertTrue(ClassInfo.of(Long.class).canAcceptArg(42L));
+ // Number can accept int (parent type)
+ assertTrue(ClassInfo.of(Number.class).canAcceptArg(42));
+
assertTrue(ClassInfo.of(Number.class).canAcceptArg(Integer.valueOf(42)));
+ }
+
+
//====================================================================================================
+ // cast(Object)
+
//====================================================================================================
+ @Test
+ void a011c_cast() {
+ // Valid cast
+ var ci = ClassInfo.of(String.class);
+ var result = ci.cast("test");
+ assertEquals("test", result);
+
+ // Null object - should return null
+ assertNull(ci.cast(null));
+
+ // Invalid cast - should throw
+ assertThrows(ClassCastException.class, () -> ci.cast(42));
+
+ // For types without inner class, should return null
+ var ci2 = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci2.cast("test"));
+ assertNull(ci2.cast(null));
+ }
+
//====================================================================================================
// getComponentType()
//====================================================================================================
@@ -665,6 +745,50 @@ public class ClassInfo_Test extends TestBase {
assertEquals(pTypeDimensionalInfo,
pTypeDimensionalInfo.getComponentType());
assertEquals(pTypeGenericInfo,
pTypeGenericInfo.getComponentType());
assertEquals(pTypeGenericArgInfo,
pTypeGenericArgInfo.getComponentType());
+
+ // For types without inner class, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.componentType());
+ }
+
+
//====================================================================================================
+ // descriptorString()
+
//====================================================================================================
+ @Test
+ void a012b_descriptorString() {
+ // Test descriptor string for various types
+ assertEquals("Ljava/lang/String;",
ClassInfo.of(String.class).descriptorString());
+ assertEquals("I", ClassInfo.of(int.class).descriptorString());
+ assertEquals("[Ljava/lang/String;",
ClassInfo.of(String[].class).descriptorString());
+
+ // For types without inner class, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.descriptorString());
+ }
+
+
//====================================================================================================
+ // equals(Object)
+
//====================================================================================================
+ @Test
+ void a012c_equals() {
+ // Same class
+ var ci1 = ClassInfo.of(String.class);
+ var ci2 = ClassInfo.of(String.class);
+ assertEquals(ci1, ci2);
+
+ // Different classes
+ var ci3 = ClassInfo.of(Integer.class);
+ assertNotEquals(ci1, ci3);
+
+ // Same type
+ assertEquals(pTypeInfo, ClassInfo.of(pType));
+
+ // Different types
+ assertNotEquals(pTypeInfo, pTypeDimensionalInfo);
+
+ // Not a ClassInfo
+ assertNotEquals(ci1, "not a ClassInfo");
+ assertNotEquals(ci1, null);
}
//====================================================================================================
@@ -764,14 +888,27 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a019_getDeclaredMemberClasses() {
+ // Test with class that has declared member classes (line 822)
var memberClasses = MM.class.getDeclaredClasses();
assertNotNull(memberClasses);
// MM has MN as a member class
assertTrue(memberClasses.length > 0);
+ // Test getDeclaredMemberClasses when inner is not null
+ var mmCi = ClassInfo.of(MM.class);
+ var declaredMemberClasses = mmCi.getDeclaredMemberClasses();
+ assertNotNull(declaredMemberClasses);
+ assertFalse(declaredMemberClasses.isEmpty());
+
// For types without inner class, should return empty list
var empty = pTypeGenericArgInfo.getDeclaredMemberClasses();
assertTrue(empty.isEmpty());
+
+ // For types with null inner, should return empty list
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ var empty2 = ci.getDeclaredMemberClasses();
+ assertNotNull(empty2);
+ assertTrue(empty2.isEmpty());
}
//====================================================================================================
@@ -816,6 +953,10 @@ public class ClassInfo_Test extends TestBase {
// For top-level classes, should return null
var declaring2 = aClass.getDeclaringClass();
assertNull(declaring2);
+
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getDeclaringClass());
}
//====================================================================================================
@@ -841,6 +982,10 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a024_getEnclosingClass() {
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getEnclosingClass());
+
// For member classes, should return enclosing class
var enclosing = aTypeInfo.getEnclosingClass();
assertNotNull(enclosing);
@@ -856,6 +1001,14 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a025_getEnclosingConstructor() {
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getEnclosingConstructor());
+
+ // For classes not declared in constructor, should return null
(line 954)
+ // Regular classes don't have enclosing constructors
+ assertNull(aClass.getEnclosingConstructor());
+
assertNull(ClassInfo.of(String.class).getEnclosingConstructor());
// Local class in method should not have enclosing constructor
class LocalClass {}
var local = ClassInfo.of(LocalClass.class);
@@ -868,6 +1021,14 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a026_getEnclosingMethod() {
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getEnclosingMethod());
+
+ // For classes not declared in method, should return null (line
970)
+ // Regular classes don't have enclosing methods
+ assertNull(aClass.getEnclosingMethod());
+ assertNull(ClassInfo.of(String.class).getEnclosingMethod());
// Local class should have an enclosing method
class LocalClass {}
var local = ClassInfo.of(LocalClass.class);
@@ -933,14 +1094,27 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a031_getMemberClasses() {
+ // Test with class that has member classes (line 1029)
var memberClasses = MM.class.getClasses();
assertNotNull(memberClasses);
// MM has MN as a public member class
assertTrue(memberClasses.length > 0);
+ // Test getMemberClasses when inner is not null
+ var mmCi = ClassInfo.of(MM.class);
+ var memberClassesList = mmCi.getMemberClasses();
+ assertNotNull(memberClassesList);
+ assertFalse(memberClassesList.isEmpty());
+
// For types without inner class, should return empty list
var empty = pTypeGenericArgInfo.getMemberClasses();
assertTrue(empty.isEmpty());
+
+ // For types with null inner, should return empty list
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ var empty2 = ci.getMemberClasses();
+ assertNotNull(empty2);
+ assertTrue(empty2.isEmpty());
}
//====================================================================================================
@@ -986,6 +1160,11 @@ public class ClassInfo_Test extends TestBase {
void a035_getNameCanonical() {
assertEquals("org.apache.juneau.commons.reflect.AClass",
aClass.getNameCanonical());
assertEquals("org.apache.juneau.commons.reflect.ClassInfo_Test.A1",
aTypeInfo.getNameCanonical());
+
+ // For ParameterizedType, should return null
+ assertNull(pTypeInfo.getNameCanonical());
+ assertNull(pTypeDimensionalInfo.getNameCanonical());
+ assertNull(pTypeGenericInfo.getNameCanonical());
}
//====================================================================================================
@@ -1078,6 +1257,19 @@ public class ClassInfo_Test extends TestBase {
// Equivalent methods
assertEquals(ci.getName(), ci.getNameFormatted(FULL, false,
'$', BRACKETS));
assertEquals(ci.getNameSimple(), ci.getNameFormatted(SIMPLE,
false, '$', BRACKETS));
+
+ // ParameterizedType case - should extract raw type
+ var ci10 = pTypeInfo;
+ var formatted = ci10.getNameFormatted(SIMPLE, false, '$',
BRACKETS);
+ assertNotNull(formatted);
+ assertTrue(formatted.contains("Map"));
+
+ // SIMPLE format with null class but ParameterizedType -
extracts raw type (line 314-316)
+ var ci11 = ClassInfo.of((Class<?>)null, pType);
+ var formatted2 = ci11.getNameFormatted(SIMPLE, false, '$',
BRACKETS);
+ assertNotNull(formatted2);
+ // When inner is null but isParameterizedType is true, code
extracts raw type and uses its simple name
+ assertEquals("Map", formatted2);
}
//====================================================================================================
@@ -1310,6 +1502,10 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
@Test
void a047_getParameterType() {
+ // Test complex type variable resolution with nested generics
(line 1372)
+ // This tests the type variable resolution in getParameterType
when dealing with nested inner classes
+ // Note: Testing nested generic type variable resolution
requires complex scenarios
+ // The code path at line 1372 is triggered when resolving type
variables in nested inner classes
// Simple map
check("String", ma.getParameterType(0, HashMap.class));
check("Integer", ma.getParameterType(1, HashMap.class));
@@ -1409,6 +1605,26 @@ public class ClassInfo_Test extends TestBase {
var permitted = aClass.getPermittedSubclasses();
assertNotNull(permitted);
assertTrue(permitted.isEmpty());
+
+ // For types with null inner, should return empty list
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ var empty = ci.getPermittedSubclasses();
+ assertNotNull(empty);
+ assertTrue(empty.isEmpty());
+ }
+
+
//====================================================================================================
+ // getProtectionDomain()
+
//====================================================================================================
+ @Test
+ void a050b_getProtectionDomain() {
+ // Should return protection domain for regular classes
+ // May be null depending on security manager, but should not
throw
+ assertDoesNotThrow(() -> aClass.getProtectionDomain());
+
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getProtectionDomain());
}
//====================================================================================================
@@ -1497,6 +1713,37 @@ public class ClassInfo_Test extends TestBase {
check("", aTypeInfo.getPublicFields());
}
+
//====================================================================================================
+ // getResource(String)
+
//====================================================================================================
+ @Test
+ void a057b_getResource() {
+ // Should return resource URL for existing resources
+ // May be null depending on classpath, but should not throw
+ assertDoesNotThrow(() -> aClass.getResource("/"));
+
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getResource("test"));
+ }
+
+
//====================================================================================================
+ // getResourceAsStream(String)
+
//====================================================================================================
+ @Test
+ void a057c_getResourceAsStream() {
+ // Should return resource stream for existing resources
+ var stream = aClass.getResourceAsStream("/");
+ // May be null depending on classpath, but should not throw
+ if (stream != null) {
+ assertDoesNotThrow(() -> stream.close());
+ }
+
+ // For types with null inner, should return null
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertNull(ci.getResourceAsStream("test"));
+ }
+
//====================================================================================================
// getPublicMethod(Predicate<MethodInfo>)
//====================================================================================================
@@ -1703,6 +1950,84 @@ public class ClassInfo_Test extends TestBase {
assertFalse(pTypeGenericInfo.is(KA.class));
assertFalse(pTypeGenericArgInfo.is(KA.class));
assertFalse(pTypeGenericArgInfo.is(of(KA.class)));
+
+ // Test ElementFlag cases
+ assertTrue(aClass.is(ElementFlag.CLASS));
+ assertTrue(aClass.is(NOT_ANNOTATION));
+ assertTrue(aClass.is(NOT_ARRAY));
+ assertTrue(aClass.is(NOT_ENUM));
+ assertTrue(aClass.is(NOT_LOCAL));
+ assertTrue(aClass.is(NOT_MEMBER));
+ assertTrue(aClass.is(NOT_NON_STATIC_MEMBER));
+ assertTrue(aClass.is(NOT_PRIMITIVE));
+ assertTrue(aClass.is(NOT_RECORD));
+ assertTrue(aClass.is(NOT_SEALED));
+ assertTrue(aClass.is(NOT_SYNTHETIC));
+
+ // Test positive ElementFlag cases (lines 1772, 1774, 1775,
1776, 1781, 1783, 1787, 1789, 1791, 1793)
+ // ANNOTATION (line 1772)
+ assertTrue(ClassInfo.of(A.class).is(ANNOTATION));
+ assertFalse(aClass.is(ANNOTATION));
+
+ // ANONYMOUS and NOT_ANONYMOUS (lines 1774, 1775)
+ // Anonymous classes are created dynamically, so we test
NOT_ANONYMOUS
+ assertTrue(aClass.is(NOT_ANONYMOUS));
+ // Test anonymous class if we can create one
+ var anonymous = new Object() {}.getClass();
+ var anonymousInfo = ClassInfo.of(anonymous);
+ if (anonymousInfo.isAnonymousClass()) {
+ assertTrue(anonymousInfo.is(ANONYMOUS));
+ assertFalse(anonymousInfo.is(NOT_ANONYMOUS));
+ }
+
+ // ARRAY (line 1776)
+ assertTrue(ClassInfo.of(String[].class).is(ARRAY));
+ assertFalse(aClass.is(ARRAY));
+
+ // ENUM (line 1781)
+ assertTrue(ClassInfo.of(ClassArrayFormat.class).is(ENUM));
+ assertFalse(aClass.is(ENUM));
+
+ // LOCAL and NOT_LOCAL (line 1783)
+ // Local class
+ class LocalTestClass {}
+ var localInfo = ClassInfo.of(LocalTestClass.class);
+ assertTrue(localInfo.is(LOCAL));
+ assertFalse(localInfo.is(NOT_LOCAL));
+ assertTrue(aClass.is(NOT_LOCAL));
+ assertFalse(aClass.is(LOCAL));
+
+ // NON_STATIC_MEMBER (line 1787)
+ // H_PublicMember is a non-static member class
+ var nonStaticMember = ClassInfo.of(H_PublicMember.class);
+ assertTrue(nonStaticMember.is(NON_STATIC_MEMBER));
+ assertFalse(nonStaticMember.is(NOT_NON_STATIC_MEMBER));
+ assertTrue(aClass.is(NOT_NON_STATIC_MEMBER));
+ assertFalse(aClass.is(NON_STATIC_MEMBER));
+
+ // PRIMITIVE (line 1789)
+ assertTrue(ClassInfo.of(int.class).is(PRIMITIVE));
+ assertFalse(aClass.is(PRIMITIVE));
+
+ // RECORD (line 1791) - test if records are available
+ try {
+ Class.forName("java.lang.Record");
+ // Records are available, but we don't have a test
record class
+ // Just verify non-records return false
+ assertFalse(aClass.is(RECORD));
+ } catch (ClassNotFoundException e) {
+ // Records not available, skip
+ }
+
+ // SEALED (line 1793) - test if sealed classes are available
+ try {
+ Class.forName("java.lang.constant.Constable");
+ // Sealed classes are available (Java 17+)
+ // Most classes are not sealed, so should return false
+ assertFalse(aClass.is(SEALED));
+ } catch (ClassNotFoundException e) {
+ // Sealed classes not available, skip
+ }
}
//====================================================================================================
@@ -1768,6 +2093,10 @@ public class ClassInfo_Test extends TestBase {
assertTrue(ClassInfo.of(A.class).isAnnotation());
assertTrue(ClassInfo.of(B.class).isAnnotation());
assertFalse(aClass.isAnnotation());
+
+ // Test with null inner (line 1811)
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isAnnotation());
}
//====================================================================================================
@@ -1795,6 +2124,46 @@ public class ClassInfo_Test extends TestBase {
assertTrue(ClassInfo.of(String[].class).isArray());
assertTrue(ClassInfo.of(int[].class).isArray());
assertFalse(aClass.isArray());
+
+ // For types with null inner, should return false
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isArray());
+ }
+
+
//====================================================================================================
+ // isAnonymousClass()
+
//====================================================================================================
+ @Test
+ void a076b_isAnonymousClass() {
+ // Regular classes are not anonymous
+ assertFalse(aClass.isAnonymousClass());
+
+ // For types with null inner, should return false (line 1821)
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isAnonymousClass());
+ }
+
+
//====================================================================================================
+ // isCollectionOrArray()
+
//====================================================================================================
+ @Test
+ void a076c_isCollectionOrArray() {
+ // Test with array
+ assertTrue(ClassInfo.of(String[].class).isCollectionOrArray());
+ assertTrue(ClassInfo.of(int[].class).isCollectionOrArray());
+
+ // Test with Collection
+
assertTrue(ClassInfo.of(java.util.List.class).isCollectionOrArray());
+
assertTrue(ClassInfo.of(java.util.Set.class).isCollectionOrArray());
+
assertTrue(ClassInfo.of(java.util.Collection.class).isCollectionOrArray());
+
+ // Test with non-collection, non-array
+ assertFalse(aClass.isCollectionOrArray());
+ assertFalse(ClassInfo.of(String.class).isCollectionOrArray());
+
+ // Test with null inner (line 1905)
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isCollectionOrArray());
}
//====================================================================================================
@@ -1824,6 +2193,12 @@ public class ClassInfo_Test extends TestBase {
assertFalse(pTypeDimensionalInfo.isChildOf(KA.class));
assertFalse(pTypeGenericInfo.isChildOf(KA.class));
assertFalse(pTypeGenericArgInfo.isChildOf(KA.class));
+
+ // Test isChildOf(ClassInfo)
+ assertTrue(kb.isChildOf(ka));
+ assertTrue(kc.isChildOf(ka));
+ assertTrue(kc.isChildOf(kb));
+ assertFalse(ka.isChildOf(kb));
}
//====================================================================================================
@@ -1882,6 +2257,32 @@ public class ClassInfo_Test extends TestBase {
void a081_isEnum() {
assertTrue(ClassInfo.of(ClassArrayFormat.class).isEnum());
assertFalse(aClass.isEnum());
+
+ // Test with null inner (line 1919)
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isEnum());
+ }
+
+
//====================================================================================================
+ // isInstance(Object)
+
//====================================================================================================
+ @Test
+ void a081b_isInstance() {
+ // Valid instance
+ assertTrue(ClassInfo.of(String.class).isInstance("test"));
+ assertTrue(ClassInfo.of(Number.class).isInstance(42));
+
+ // Invalid instance
+ assertFalse(ClassInfo.of(String.class).isInstance(42));
+ assertFalse(ClassInfo.of(Number.class).isInstance("test"));
+
+ // Null value
+ assertFalse(ClassInfo.of(String.class).isInstance(null));
+
+ // For types with null inner, should return false
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isInstance("test"));
+ assertFalse(ci.isInstance(null));
}
//====================================================================================================
@@ -1996,6 +2397,26 @@ public class ClassInfo_Test extends TestBase {
assertTrue(pTypeGenericArgInfo.isNotLocalClass());
}
+
//====================================================================================================
+ // isNestmateOf(Class<?>)
+
//====================================================================================================
+ @Test
+ void a088b_isNestmateOf() {
+ // Same class is nestmate of itself
+ assertTrue(aClass.isNestmateOf(AClass.class));
+
+ // Different classes in same package may or may not be nestmates
+ // (depends on whether they're in the same nest)
+
+ // For types with null inner, should return false
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isNestmateOf(AClass.class));
+ assertFalse(ci.isNestmateOf(null));
+
+ // With null argument, should return false
+ assertFalse(aClass.isNestmateOf(null));
+ }
+
//====================================================================================================
// isNotMemberClass()
//====================================================================================================
@@ -2010,6 +2431,21 @@ public class ClassInfo_Test extends TestBase {
assertTrue(pTypeGenericArgInfo.isNotMemberClass());
}
+
//====================================================================================================
+ // isNotNonStaticMemberClass()
+
//====================================================================================================
+ @Test
+ void a089b_isNotNonStaticMemberClass() {
+ // Regular classes are not non-static member classes
+ assertTrue(aClass.isNotNonStaticMemberClass());
+
+ // aTypeInfo represents A1, which is a non-static member class,
so isNotNonStaticMemberClass() returns false
+ assertFalse(aTypeInfo.isNotNonStaticMemberClass());
+
+ // Top-level classes are not non-static member classes
+
assertTrue(ClassInfo.of(String.class).isNotNonStaticMemberClass());
+ }
+
//====================================================================================================
// isNotPrimitive()
//====================================================================================================
@@ -2083,6 +2519,31 @@ public class ClassInfo_Test extends TestBase {
assertFalse(pTypeGenericArgInfo.isParentOf(KA.class));
}
+
//====================================================================================================
+ // isParentOf(ClassInfo)
+
//====================================================================================================
+ @Test
+ void a093b_isParentOf_ClassInfo() {
+ // Test isParentOf(ClassInfo) with valid classes
+ assertTrue(ka.isParentOf(ka));
+ assertTrue(ka.isParentOf(kb));
+ assertTrue(ka.isParentOf(kc));
+ assertFalse(kb.isParentOf(ka));
+ assertTrue(kb.isParentOf(kb));
+ assertTrue(kb.isParentOf(kc));
+ assertFalse(kc.isParentOf(ka));
+ assertFalse(kc.isParentOf(kb));
+ assertTrue(kc.isParentOf(kc));
+
+ // Test with null child (line 2029)
+ assertFalse(ka.isParentOf((ClassInfo)null));
+
+ // Test with null inner
+ var nullInnerCi = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(nullInnerCi.isParentOf(ka));
+ assertFalse(nullInnerCi.isParentOf((ClassInfo)null));
+ }
+
//====================================================================================================
// isParentOfLenient(Class<?>)
//====================================================================================================
@@ -2096,12 +2557,28 @@ public class ClassInfo_Test extends TestBase {
assertTrue(ClassInfo.of(Number.class).isParentOfLenient(int.class));
assertFalse(ClassInfo.of(int.class).isParentOfLenient(Number.class));
assertFalse(ClassInfo.of(int.class).isParentOfLenient(long.class));
+
+ // With null inner or null child, should return false
+ var ci = ClassInfo.of((Class<?>)null, pType);
+ assertFalse(ci.isParentOfLenient(String.class));
+
assertFalse(ClassInfo.of(String.class).isParentOfLenient((Class<?>)null));
+
+ // Test isParentOfLenient(Type)
+
assertTrue(ClassInfo.of(CharSequence.class).isParentOfLenient((Type)String.class));
+
assertFalse(ClassInfo.of(String.class).isParentOfLenient((Type)CharSequence.class));
+ // Non-Class Type should return false
+
assertFalse(ClassInfo.of(String.class).isParentOfLenient(pType));
+
+ // Test isParentOfLenient(ClassInfo) with null child (line 2088)
+
assertFalse(ClassInfo.of(String.class).isParentOfLenient((ClassInfo)null));
+ var nullInnerCi = ClassInfo.of((Class<?>)null, pType);
+
assertFalse(nullInnerCi.isParentOfLenient(ClassInfo.of(String.class)));
}
//====================================================================================================
// isPrimitive()
//====================================================================================================
- @Test
+ @Test
void a095_isPrimitive() {
assertTrue(of(int.class).isPrimitive());
assertFalse(of(Integer.class).isPrimitive());
@@ -2113,7 +2590,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// isPublic()
//====================================================================================================
- @Test
+ @Test
void a096_isPublic() {
assertTrue(hPublic.isPublic());
assertFalse(hProtected.isPublic());
@@ -2130,7 +2607,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// isRecord()
//====================================================================================================
- @Test
+ @Test
void a097_isRecord() {
// Test with a record class if available (Java 14+)
try {
@@ -2147,7 +2624,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// isStatic()
//====================================================================================================
- @Test
+ @Test
void a098_isStatic() {
assertTrue(hPublic.isStatic());
assertFalse(hPublicMember.isStatic());
@@ -2159,7 +2636,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// isStrictChildOf(Class<?>)
//====================================================================================================
- @Test
+ @Test
void a099_isStrictChildOf() {
assertFalse(ka.isStrictChildOf(KA.class));
assertFalse(ka.isStrictChildOf(KB.class));
@@ -2180,6 +2657,25 @@ public class ClassInfo_Test extends TestBase {
assertFalse(pTypeGenericArgInfo.isStrictChildOf(KA.class));
}
+
//====================================================================================================
+ // isRuntimeException()
+
//====================================================================================================
+ @Test
+ void a099b_isRuntimeException() {
+ // Test isRuntimeException() (line 2143)
+ // RuntimeException itself
+
assertTrue(ClassInfo.of(RuntimeException.class).isRuntimeException());
+ // Subclasses of RuntimeException
+
assertTrue(ClassInfo.of(IllegalArgumentException.class).isRuntimeException());
+
assertTrue(ClassInfo.of(NullPointerException.class).isRuntimeException());
+
assertTrue(ClassInfo.of(IllegalStateException.class).isRuntimeException());
+ // Exception but not RuntimeException
+ assertFalse(ClassInfo.of(Exception.class).isRuntimeException());
+ // Regular classes
+ assertFalse(ClassInfo.of(String.class).isRuntimeException());
+ assertFalse(aClass.isRuntimeException());
+ }
+
//====================================================================================================
// isSynthetic()
//====================================================================================================
@@ -2197,7 +2693,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// isVisible(Visibility)
//====================================================================================================
- @Test
+ @Test
void a101_isVisible() {
// Public visibility
assertTrue(hPublic.isVisible(Visibility.PUBLIC));
@@ -2234,7 +2730,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// newInstance()
//====================================================================================================
- @Test
+ @Test
void a102_newInstance() {
assertNotNull(la.newInstance());
// Test on types - should throw
@@ -2248,7 +2744,7 @@ public class ClassInfo_Test extends TestBase {
//====================================================================================================
// of(Class<?>)
//====================================================================================================
- @Test
+ @Test
void a103_of() {
// Test with Class
check("A1", of(A1.class));
@@ -2272,7 +2768,7 @@ public class ClassInfo_Test extends TestBase {
assertEquals(String.class, info.inner());
// When inner != innerType, should create ClassInfoTyped
- info = ClassInfo.of(String.class, (Type)String.class);
+ info = ClassInfo.of(String.class, String.class);
assertNotNull(info);
assertEquals(String.class, info.inner());
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ElementInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ElementInfo_Test.java
index d9906ebf06..864061cbf5 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ElementInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ElementInfo_Test.java
@@ -153,7 +153,6 @@ class ElementInfo_Test extends TestBase {
var interfaceClass = getClassInfo(InterfaceClass.class);
var synchronizedMethod = getMethod(SynchronizedClass.class,
"synchronizedMethod");
var nativeMethod = getMethod(NativeClass.class, "nativeMethod");
- var strictMethod = getMethod(StrictClass.class, "strictMethod");
var transientField = getField(TransientClass.class,
"transientField");
var volatileField = getField(VolatileClass.class,
"volatileField");
@@ -212,29 +211,6 @@ class ElementInfo_Test extends TestBase {
assertTrue(publicMethod.is(NOT_NATIVE));
assertFalse(nativeMethod.is(NOT_NATIVE));
- // Strict
- // Note: strictfp is deprecated in Java 17+, so
Modifier.isStrict() may not work as expected
- // In Java 17+, all floating-point expressions are evaluated
strictly by default
- // The strictfp modifier is ignored, so isStrict() may return
false even for strictfp methods
- boolean isStrictSupported;
- try {
- isStrictSupported =
Modifier.isStrict(StrictClass.class.getMethod("strictMethod").getModifiers());
- } catch (NoSuchMethodException e) {
- throw new RuntimeException(e);
- }
- if (isStrictSupported) {
- assertTrue(strictMethod.is(STRICT));
- assertFalse(publicMethod.is(STRICT));
- assertTrue(publicMethod.is(NOT_STRICT));
- assertFalse(strictMethod.is(NOT_STRICT));
- } else {
- // Java 17+ - strictfp is deprecated and ignored
- assertFalse(strictMethod.is(STRICT));
- assertFalse(publicMethod.is(STRICT));
- assertTrue(publicMethod.is(NOT_STRICT));
- assertTrue(strictMethod.is(NOT_STRICT));
- }
-
// Transient
assertTrue(transientField.is(TRANSIENT));
assertFalse(publicField.is(TRANSIENT));
@@ -281,6 +257,16 @@ class ElementInfo_Test extends TestBase {
assertFalse(publicClass.isAll(PUBLIC, PRIVATE));
assertFalse(staticMethod.isAll(PUBLIC, STATIC, FINAL));
assertFalse(finalMethod.isAll(PUBLIC, STATIC));
+
+ // Empty flags array - allMatch on empty stream returns true
(vacuous truth) (line 143)
+ assertTrue(publicClass.isAll());
+ assertTrue(staticMethod.isAll());
+
+ // Single flag - ensures stream(flags).allMatch(this::is) is
executed (line 143)
+ assertTrue(publicClass.isAll(PUBLIC));
+ assertFalse(publicClass.isAll(PRIVATE));
+ assertTrue(staticMethod.isAll(STATIC));
+ assertFalse(staticMethod.isAll(FINAL));
}
//====================================================================================================
@@ -300,6 +286,16 @@ class ElementInfo_Test extends TestBase {
// No flags match
assertFalse(publicClass.isAny(PRIVATE, PROTECTED));
assertFalse(staticMethod.isAny(PRIVATE, FINAL));
+
+ // Empty flags array - anyMatch on empty stream returns false
(line 157)
+ assertFalse(publicClass.isAny(new ElementFlag[0]));
+ assertFalse(staticMethod.isAny(new ElementFlag[0]));
+
+ // Single flag - ensures stream(flags).anyMatch(this::is) is
executed (line 157)
+ assertTrue(publicClass.isAny(PUBLIC));
+ assertFalse(publicClass.isAny(PRIVATE));
+ assertTrue(staticMethod.isAny(STATIC));
+ assertFalse(staticMethod.isAny(FINAL));
}
//====================================================================================================
@@ -458,31 +454,6 @@ class ElementInfo_Test extends TestBase {
assertTrue(publicField.isNotStatic());
}
-
//====================================================================================================
- // isNotStrict()
-
//====================================================================================================
- @Test
- void a017_isNotStrict() {
- var strictMethod = getMethod(StrictClass.class, "strictMethod");
- var publicMethod = getMethod(PublicClass.class, "publicMethod");
-
- // Note: strictfp is deprecated in Java 17+, so
Modifier.isStrict() may not work as expected
- boolean isStrictSupported;
- try {
- isStrictSupported =
Modifier.isStrict(StrictClass.class.getMethod("strictMethod").getModifiers());
- } catch (NoSuchMethodException e) {
- throw new RuntimeException(e);
- }
- if (isStrictSupported) {
- assertFalse(strictMethod.isNotStrict());
- assertTrue(publicMethod.isNotStrict());
- } else {
- // Java 17+ - strictfp is deprecated and ignored
- assertTrue(strictMethod.isNotStrict());
- assertTrue(publicMethod.isNotStrict());
- }
- }
-
//====================================================================================================
// isNotSynchronized()
//====================================================================================================
@@ -589,30 +560,6 @@ class ElementInfo_Test extends TestBase {
assertFalse(publicField.isStatic());
}
-
//====================================================================================================
- // isStrict()
-
//====================================================================================================
- @Test
- void a025_isStrict() {
- var strictMethod = getMethod(StrictClass.class, "strictMethod");
- var publicMethod = getMethod(PublicClass.class, "publicMethod");
-
- // Note: strictfp is deprecated in Java 17+, so
Modifier.isStrict() may not work as expected
- boolean isStrictSupported;
- try {
- isStrictSupported =
Modifier.isStrict(StrictClass.class.getMethod("strictMethod").getModifiers());
- } catch (NoSuchMethodException e) {
- throw new RuntimeException(e);
- }
- if (isStrictSupported) {
- assertTrue(strictMethod.isStrict());
- assertFalse(publicMethod.isStrict());
- } else {
- // Java 17+ - strictfp is deprecated and ignored
- assertFalse(strictMethod.isStrict());
- assertFalse(publicMethod.isStrict());
- }
- }
//====================================================================================================
// isSynchronized()
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
index d5a99aa02a..7b8117fc6b 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ExecutableInfo_Test.java
@@ -584,6 +584,30 @@ class ExecutableInfo_Test extends TestBase {
assertFalse(a.getPublicMethod(x ->
x.hasName("foo")).get().is(ElementFlag.CONSTRUCTOR));
assertTrue(a.getPublicMethod(x ->
x.hasName("foo")).get().is(NOT_CONSTRUCTOR));
+ // SYNTHETIC and NOT_SYNTHETIC (lines 531, 532)
+ // Regular executables are not synthetic
+ assertFalse(b_c1.isSynthetic());
+ assertFalse(b_c1.is(SYNTHETIC));
+ assertTrue(b_c1.is(NOT_SYNTHETIC));
+ assertFalse(b_m1.isSynthetic());
+ assertFalse(b_m1.is(SYNTHETIC));
+ assertTrue(b_m1.is(NOT_SYNTHETIC));
+
+ // VARARGS and NOT_VARARGS (lines 532, 533)
+ var varArgsCi = ClassInfo.of(VarArgsClass.class);
+ var varArgsCtor = varArgsCi.getPublicConstructor(cons ->
cons.isVarArgs()).get();
+ assertTrue(varArgsCtor.isVarArgs());
+ assertTrue(varArgsCtor.is(VARARGS));
+ assertFalse(varArgsCtor.is(NOT_VARARGS));
+
+ // Non-varargs executables
+ assertFalse(b_c1.isVarArgs());
+ assertFalse(b_c1.is(VARARGS));
+ assertTrue(b_c1.is(NOT_VARARGS));
+ assertFalse(b_m1.isVarArgs());
+ assertFalse(b_m1.is(VARARGS));
+ assertTrue(b_m1.is(NOT_VARARGS));
+
// TRANSIENT is a valid modifier flag but doesn't apply to
executables
assertFalse(e_deprecated.is(TRANSIENT));
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
index 16ced3cbf4..3f8c39eabb 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/FieldInfo_Test.java
@@ -436,6 +436,12 @@ class FieldInfo_Test extends TestBase {
assertFalse(a1_f1.is(ENUM_CONSTANT));
assertTrue(a1_f1.is(NOT_ENUM_CONSTANT));
+ // Synthetic (lines 314-315)
+ assertFalse(a1_f1.is(SYNTHETIC));
+ assertTrue(a1_f1.is(NOT_SYNTHETIC));
+ assertFalse(b_a1.is(SYNTHETIC));
+ assertTrue(b_a1.is(NOT_SYNTHETIC));
+
// HAS_PARAMS doesn't apply to fields, should throw exception
assertThrowsWithMessage(RuntimeException.class, "Invalid flag
for element: HAS_PARAMS", () -> c_deprecated.is(HAS_PARAMS));
}
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/PackageInfo_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/PackageInfo_Test.java
index 9c8ae4b922..01bf9b9cd0 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/PackageInfo_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/PackageInfo_Test.java
@@ -224,12 +224,21 @@ class PackageInfo_Test extends TestBase {
void a015_isCompatibleWith() {
var pi = PackageInfo.of(String.class);
- // Test with valid version strings
+ // Test with valid version strings - ensure line 309 is covered
+ // This calls inner.isCompatibleWith(desired) which may return
true or false
+ // depending on the package version, but the line should be
executed
+ // Note: Package.isCompatibleWith may throw
NumberFormatException if the package
+ // version is empty or invalid, so we need to handle that
try {
var compatible = pi.isCompatibleWith("1.0");
assertNotNull(Boolean.valueOf(compatible));
+
+ // Test with another valid version
+ var compatible2 = pi.isCompatibleWith("2.0");
+ assertNotNull(Boolean.valueOf(compatible2));
} catch (NumberFormatException e) {
- // May throw if version format is invalid
+ // Package version may be empty or invalid, which
causes isCompatibleWith to throw
+ // This is expected behavior - the line 309 is still
covered by the call
}
// Test with invalid version - should throw
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ReflectionUtils_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ReflectionUtils_Test.java
index d95c4dccff..c9ccbb491d 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ReflectionUtils_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/ReflectionUtils_Test.java
@@ -33,6 +33,15 @@ class ReflectionUtils_Test extends TestBase {
public void method(String param) {}
}
+
//====================================================================================================
+ // Constructor
+
//====================================================================================================
+ @Test
+ void a000_constructor() {
+ // Instantiate the class to cover the implicit constructor
+ new ReflectionUtils();
+ }
+
//====================================================================================================
// info(Class<?>)
//====================================================================================================
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/Visibility_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/Visibility_Test.java
new file mode 100644
index 0000000000..fdd583be2f
--- /dev/null
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/reflect/Visibility_Test.java
@@ -0,0 +1,251 @@
+/*
+ * 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.commons.reflect;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.lang.reflect.*;
+
+import org.apache.juneau.TestBase;
+import org.junit.jupiter.api.*;
+
+class Visibility_Test extends TestBase {
+
+
//-----------------------------------------------------------------------------------------------------------------
+ // Test classes with various visibility modifiers
+
//-----------------------------------------------------------------------------------------------------------------
+
+ public static class PublicClass {
+ public PublicClass() {}
+ public void publicMethod() {}
+ public int publicField;
+ }
+
+ private static class PrivateClass {
+ private PrivateClass() {}
+ @SuppressWarnings("unused")
+ private void privateMethod() {}
+ @SuppressWarnings("unused")
+ private int privateField;
+ }
+
+ protected static class ProtectedClass {
+ protected ProtectedClass() {}
+ protected void protectedMethod() {}
+ protected int protectedField;
+ }
+
+ static class PackagePrivateClass {
+ PackagePrivateClass() {}
+ void packagePrivateMethod() {}
+ int packagePrivateField;
+ }
+
+
//-----------------------------------------------------------------------------------------------------------------
+ // Helper methods
+
//-----------------------------------------------------------------------------------------------------------------
+
+ private static Constructor<?> getConstructor(Class<?> c, Class<?>...
paramTypes) {
+ try {
+ return c.getDeclaredConstructor(paramTypes);
+ } catch (NoSuchMethodException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static Method getMethod(Class<?> c, String name, Class<?>...
paramTypes) {
+ try {
+ return c.getDeclaredMethod(name, paramTypes);
+ } catch (NoSuchMethodException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private static Field getField(Class<?> c, String name) {
+ try {
+ return c.getDeclaredField(name);
+ } catch (NoSuchFieldException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
//====================================================================================================
+ // transform(Constructor<T>)
+
//====================================================================================================
+ @Test
+ void a001_transform_constructor_null() throws Exception {
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PUBLIC.transform((Constructor<?>)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PRIVATE.transform((Constructor<?>)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.NONE.transform((Constructor<?>)null));
+ }
+
+ @Test
+ void a002_transform_constructor_public() throws Exception {
+ Constructor<?> publicCtor = getConstructor(PublicClass.class);
+ Constructor<?> privateCtor = getConstructor(PrivateClass.class);
+ Constructor<?> protectedCtor =
getConstructor(ProtectedClass.class);
+ Constructor<?> packageCtor =
getConstructor(PackagePrivateClass.class);
+
+ // PUBLIC visibility - only makes public accessible, returns
others as-is
+ assertNotNull(Visibility.PUBLIC.transform(publicCtor));
+ assertSame(privateCtor,
Visibility.PUBLIC.transform(privateCtor));
+ assertSame(protectedCtor,
Visibility.PUBLIC.transform(protectedCtor));
+ assertSame(packageCtor,
Visibility.PUBLIC.transform(packageCtor));
+
+ // PROTECTED visibility - makes public and protected accessible
+ assertNotNull(Visibility.PROTECTED.transform(publicCtor));
+ assertSame(privateCtor,
Visibility.PROTECTED.transform(privateCtor));
+ assertNotNull(Visibility.PROTECTED.transform(protectedCtor));
+ assertSame(packageCtor,
Visibility.PROTECTED.transform(packageCtor));
+
+ // DEFAULT visibility - makes public, protected, and package
accessible
+ assertNotNull(Visibility.DEFAULT.transform(publicCtor));
+ assertSame(privateCtor,
Visibility.DEFAULT.transform(privateCtor));
+ assertNotNull(Visibility.DEFAULT.transform(protectedCtor));
+ assertNotNull(Visibility.DEFAULT.transform(packageCtor));
+
+ // PRIVATE visibility - makes all accessible
+ assertNotNull(Visibility.PRIVATE.transform(publicCtor));
+ assertNotNull(Visibility.PRIVATE.transform(privateCtor));
+ assertNotNull(Visibility.PRIVATE.transform(protectedCtor));
+ assertNotNull(Visibility.PRIVATE.transform(packageCtor));
+
+ // NONE visibility - doesn't make anything accessible, but
returns as-is
+ assertSame(publicCtor, Visibility.NONE.transform(publicCtor));
+ assertSame(privateCtor, Visibility.NONE.transform(privateCtor));
+ assertSame(protectedCtor,
Visibility.NONE.transform(protectedCtor));
+ assertSame(packageCtor, Visibility.NONE.transform(packageCtor));
+ }
+
+ @Test
+ void a003_transform_constructor_returnsSameInstance() throws Exception {
+ Constructor<?> publicCtor = getConstructor(PublicClass.class);
+ Constructor<?> result = Visibility.PUBLIC.transform(publicCtor);
+ assertSame(publicCtor, result);
+ }
+
+
//====================================================================================================
+ // transform(Field)
+
//====================================================================================================
+ @Test
+ void a004_transform_field_null() throws Exception {
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PUBLIC.transform((Field)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PRIVATE.transform((Field)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.NONE.transform((Field)null));
+ }
+
+ @Test
+ void a005_transform_field_public() throws Exception {
+ Field publicField = getField(PublicClass.class, "publicField");
+ Field privateField = getField(PrivateClass.class,
"privateField");
+ Field protectedField = getField(ProtectedClass.class,
"protectedField");
+ Field packageField = getField(PackagePrivateClass.class,
"packagePrivateField");
+
+ // PUBLIC visibility - only makes public accessible, returns
others as-is
+ assertNotNull(Visibility.PUBLIC.transform(publicField));
+ assertSame(privateField,
Visibility.PUBLIC.transform(privateField));
+ assertSame(protectedField,
Visibility.PUBLIC.transform(protectedField));
+ assertSame(packageField,
Visibility.PUBLIC.transform(packageField));
+
+ // PROTECTED visibility - makes public and protected accessible
+ assertNotNull(Visibility.PROTECTED.transform(publicField));
+ assertSame(privateField,
Visibility.PROTECTED.transform(privateField));
+ assertNotNull(Visibility.PROTECTED.transform(protectedField));
+ assertSame(packageField,
Visibility.PROTECTED.transform(packageField));
+
+ // DEFAULT visibility - makes public, protected, and package
accessible
+ assertNotNull(Visibility.DEFAULT.transform(publicField));
+ assertSame(privateField,
Visibility.DEFAULT.transform(privateField));
+ assertNotNull(Visibility.DEFAULT.transform(protectedField));
+ assertNotNull(Visibility.DEFAULT.transform(packageField));
+
+ // PRIVATE visibility - makes all accessible
+ assertNotNull(Visibility.PRIVATE.transform(publicField));
+ assertNotNull(Visibility.PRIVATE.transform(privateField));
+ assertNotNull(Visibility.PRIVATE.transform(protectedField));
+ assertNotNull(Visibility.PRIVATE.transform(packageField));
+
+ // NONE visibility - doesn't make anything accessible, but
returns as-is
+ assertSame(publicField, Visibility.NONE.transform(publicField));
+ assertSame(privateField,
Visibility.NONE.transform(privateField));
+ assertSame(protectedField,
Visibility.NONE.transform(protectedField));
+ assertSame(packageField,
Visibility.NONE.transform(packageField));
+ }
+
+ @Test
+ void a006_transform_field_returnsSameInstance() throws Exception {
+ Field publicField = getField(PublicClass.class, "publicField");
+ Field result = Visibility.PUBLIC.transform(publicField);
+ assertSame(publicField, result);
+ }
+
+
//====================================================================================================
+ // transform(Method)
+
//====================================================================================================
+ @Test
+ void a007_transform_method_null() throws Exception {
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PUBLIC.transform((Method)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.PRIVATE.transform((Method)null));
+ assertThrows(IllegalArgumentException.class, () ->
Visibility.NONE.transform((Method)null));
+ }
+
+ @Test
+ void a008_transform_method_public() throws Exception {
+ Method publicMethod = getMethod(PublicClass.class,
"publicMethod");
+ Method privateMethod = getMethod(PrivateClass.class,
"privateMethod");
+ Method protectedMethod = getMethod(ProtectedClass.class,
"protectedMethod");
+ Method packageMethod = getMethod(PackagePrivateClass.class,
"packagePrivateMethod");
+
+ // PUBLIC visibility - only makes public accessible, returns
others as-is
+ assertNotNull(Visibility.PUBLIC.transform(publicMethod));
+ assertSame(privateMethod,
Visibility.PUBLIC.transform(privateMethod));
+ assertSame(protectedMethod,
Visibility.PUBLIC.transform(protectedMethod));
+ assertSame(packageMethod,
Visibility.PUBLIC.transform(packageMethod));
+
+ // PROTECTED visibility - makes public and protected accessible
+ assertNotNull(Visibility.PROTECTED.transform(publicMethod));
+ assertSame(privateMethod,
Visibility.PROTECTED.transform(privateMethod));
+ assertNotNull(Visibility.PROTECTED.transform(protectedMethod));
+ assertSame(packageMethod,
Visibility.PROTECTED.transform(packageMethod));
+
+ // DEFAULT visibility - makes public, protected, and package
accessible
+ assertNotNull(Visibility.DEFAULT.transform(publicMethod));
+ assertSame(privateMethod,
Visibility.DEFAULT.transform(privateMethod));
+ assertNotNull(Visibility.DEFAULT.transform(protectedMethod));
+ assertNotNull(Visibility.DEFAULT.transform(packageMethod));
+
+ // PRIVATE visibility - makes all accessible
+ assertNotNull(Visibility.PRIVATE.transform(publicMethod));
+ assertNotNull(Visibility.PRIVATE.transform(privateMethod));
+ assertNotNull(Visibility.PRIVATE.transform(protectedMethod));
+ assertNotNull(Visibility.PRIVATE.transform(packageMethod));
+
+ // NONE visibility - doesn't make anything accessible, but
returns as-is
+ assertSame(publicMethod,
Visibility.NONE.transform(publicMethod));
+ assertSame(privateMethod,
Visibility.NONE.transform(privateMethod));
+ assertSame(protectedMethod,
Visibility.NONE.transform(protectedMethod));
+ assertSame(packageMethod,
Visibility.NONE.transform(packageMethod));
+ }
+
+ @Test
+ void a009_transform_method_returnsSameInstance() throws Exception {
+ Method publicMethod = getMethod(PublicClass.class,
"publicMethod");
+ Method result = Visibility.PUBLIC.transform(publicMethod);
+ assertSame(publicMethod, result);
+ }
+}
+
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/utils/Utils_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/utils/Utils_Test.java
index 3b485b799e..4bc226d76a 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/commons/utils/Utils_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/commons/utils/Utils_Test.java
@@ -867,6 +867,53 @@ class Utils_Test extends TestBase {
assertEquals("test error",
wrappedError.getCause().getMessage());
}
+
//====================================================================================================
+ // safe(Snippet, Function<Throwable, RuntimeException>)
+
//====================================================================================================
+ @Test
+ void a48b_safe_Snippet_withExceptionMapper() {
+ // Test normal execution
+ AtomicInteger count = new AtomicInteger(0);
+ safe((Snippet)() -> {
+ count.incrementAndGet();
+ }, e -> new RuntimeException("mapped: " + e.getMessage()));
+ assertEquals(1, count.get());
+
+ // Test RuntimeException is rethrown (not mapped)
+ var re = assertThrows(RuntimeException.class, () ->
safe((Snippet)() -> {
+ throw new RuntimeException("original");
+ }, e -> new RuntimeException("mapped: " + e.getMessage())));
+ assertEquals("original", re.getMessage());
+
+ // Test checked exception is mapped using the provided function
+ var mapped = assertThrows(RuntimeException.class, () ->
safe((Snippet)() -> {
+ throw new Exception("test exception");
+ }, e -> new IllegalArgumentException("custom: " +
e.getMessage())));
+ assertEquals("custom: test exception", mapped.getMessage());
+ assertTrue(mapped instanceof IllegalArgumentException);
+
+ // Test Error is mapped
+ var mappedError = assertThrows(RuntimeException.class, () ->
safe((Snippet)() -> {
+ throw new Error("test error");
+ }, e -> new IllegalStateException("error: " + e.getMessage())));
+ assertEquals("error: test error", mappedError.getMessage());
+ assertTrue(mappedError instanceof IllegalStateException);
+
+ // Test with custom exception type
+ @SuppressWarnings("serial")
+ class CustomRuntimeException extends RuntimeException {
+ CustomRuntimeException(String message, Throwable cause)
{
+ super(message, cause);
+ }
+ }
+ var custom = assertThrows(CustomRuntimeException.class, () ->
safe((Snippet)() -> {
+ throw new Exception("test");
+ }, e -> new CustomRuntimeException("wrapped", e)));
+ assertEquals("wrapped", custom.getMessage());
+ assertNotNull(custom.getCause());
+ assertEquals(Exception.class, custom.getCause().getClass());
+ }
+
//====================================================================================================
// safe(ThrowingSupplier<T>)
//====================================================================================================
@@ -887,6 +934,49 @@ class Utils_Test extends TestBase {
}));
}
+
//====================================================================================================
+ // safe(ThrowingSupplier<T>, Function<Exception, RuntimeException>)
+
//====================================================================================================
+ @Test
+ void a49b_safe_ThrowingSupplier_withExceptionMapper() {
+ // Test normal execution
+ ThrowingSupplier<String> supplier1 = () -> "result";
+ Function<Exception, RuntimeException> mapper1 = e -> new
RuntimeException("mapped: " + e.getMessage());
+ String result = Utils.safe(supplier1, mapper1);
+ assertEquals("result", result);
+
+ // Test RuntimeException is rethrown (not mapped)
+ ThrowingSupplier<String> supplier2 = () -> {
+ throw new RuntimeException("original");
+ };
+ Function<Exception, RuntimeException> mapper2 = e -> new
RuntimeException("mapped: " + e.getMessage());
+ var re = assertThrows(RuntimeException.class, () ->
Utils.safe(supplier2, mapper2));
+ assertEquals("original", re.getMessage());
+
+ // Test checked exception is mapped using the provided function
+ ThrowingSupplier<String> supplier3 = () -> {
+ throw new Exception("test exception");
+ };
+ Function<Exception, RuntimeException> mapper3 = e -> new
IllegalArgumentException("custom: " + e.getMessage());
+ var mapped = assertThrows(RuntimeException.class, () ->
Utils.safe(supplier3, mapper3));
+ assertEquals("custom: test exception", mapped.getMessage());
+ assertTrue(mapped instanceof IllegalArgumentException);
+
+ // Test with custom exception type
+ @SuppressWarnings("serial")
+ class CustomRuntimeException extends RuntimeException {
+ CustomRuntimeException(String message, Throwable cause)
{
+ super(message, cause);
+ }
+ }
+ var custom = assertThrows(CustomRuntimeException.class, () ->
Utils.<String>safeSupplier(() -> {
+ throw new Exception("test");
+ }, e -> new CustomRuntimeException("wrapped", e)));
+ assertEquals("wrapped", custom.getMessage());
+ assertNotNull(custom.getCause());
+ assertEquals(Exception.class, custom.getCause().getClass());
+ }
+
//====================================================================================================
// safeSupplier(ThrowableUtils.SupplierWithThrowable<T>)
//====================================================================================================
@@ -907,6 +997,50 @@ class Utils_Test extends TestBase {
}));
}
+
//====================================================================================================
+ // safeSupplier(ThrowableUtils.SupplierWithThrowable<T>,
Function<Throwable, RuntimeException>)
+
//====================================================================================================
+ @Test
+ void a50b_safeSupplier_withExceptionMapper() {
+ // Test normal execution
+ String result = Utils.<String>safeSupplier(() -> "result", e ->
new RuntimeException("mapped: " + e.getMessage()));
+ assertEquals("result", result);
+
+ // Test RuntimeException is rethrown (not mapped)
+ var re = assertThrows(RuntimeException.class, () ->
Utils.<String>safeSupplier(() -> {
+ throw new RuntimeException("original");
+ }, e -> new RuntimeException("mapped: " + e.getMessage())));
+ assertEquals("original", re.getMessage());
+
+ // Test checked exception is mapped using the provided function
+ var mapped = assertThrows(RuntimeException.class, () ->
Utils.<String>safeSupplier(() -> {
+ throw new Exception("test exception");
+ }, e -> new IllegalArgumentException("custom: " +
e.getMessage())));
+ assertEquals("custom: test exception", mapped.getMessage());
+ assertTrue(mapped instanceof IllegalArgumentException);
+
+ // Test Error is mapped
+ var mappedError = assertThrows(RuntimeException.class, () ->
Utils.<String>safeSupplier(() -> {
+ throw new Error("test error");
+ }, e -> new IllegalStateException("error: " + e.getMessage())));
+ assertEquals("error: test error", mappedError.getMessage());
+ assertTrue(mappedError instanceof IllegalStateException);
+
+ // Test with custom exception type
+ @SuppressWarnings("serial")
+ class CustomRuntimeException extends RuntimeException {
+ CustomRuntimeException(String message, Throwable cause)
{
+ super(message, cause);
+ }
+ }
+ var custom = assertThrows(CustomRuntimeException.class, () ->
Utils.<String>safeSupplier(() -> {
+ throw new Exception("test");
+ }, e -> new CustomRuntimeException("wrapped", e)));
+ assertEquals("wrapped", custom.getMessage());
+ assertNotNull(custom.getCause());
+ assertEquals(Exception.class, custom.getCause().getClass());
+ }
+
//====================================================================================================
// sb(String)
//====================================================================================================
