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 a4c0d0222a Unit tests
a4c0d0222a is described below
commit a4c0d0222a2ac3f6639b9fec03a0d26706e1d438
Author: James Bognar <[email protected]>
AuthorDate: Mon Dec 1 14:25:13 2025 -0800
Unit tests
---
.../apache/juneau/common/utils/StringUtils.java | 270 ++++--
.../juneau/common/utils/StringUtils_Test.java | 975 ++++++++++++++++++++-
2 files changed, 1177 insertions(+), 68 deletions(-)
diff --git
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/StringUtils.java
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/StringUtils.java
index a0992c6bec..ec10e717bf 100644
---
a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/StringUtils.java
+++
b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/StringUtils.java
@@ -24,6 +24,7 @@ import static org.apache.juneau.common.utils.IOUtils.*;
import static org.apache.juneau.common.utils.StateEnum.*;
import static org.apache.juneau.common.utils.ThrowableUtils.*;
import static org.apache.juneau.common.utils.Utils.*;
+import static java.util.stream.Collectors.*;
import java.io.*;
import java.lang.reflect.*;
@@ -41,6 +42,10 @@ import java.util.regex.*;
import java.util.stream.*;
import java.util.zip.*;
+import org.apache.juneau.common.collections.*;
+import org.apache.juneau.common.function.*;
+import org.apache.juneau.common.reflect.*;
+
/**
* Reusable string utility methods.
*/
@@ -139,18 +144,8 @@ public class StringUtils {
private static final char[] hexArray = "0123456789ABCDEF".toCharArray();
- private static final Map<Class<?>,Function<Object,String>>
PRIMITIVE_ARRAY_STRINGIFIERS = new HashMap<>();
-
- static {
- PRIMITIVE_ARRAY_STRINGIFIERS.put(boolean[].class, x ->
Arrays.toString((boolean[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(byte[].class, x ->
Arrays.toString((byte[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(char[].class, x ->
Arrays.toString((char[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(double[].class, x ->
Arrays.toString((double[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(float[].class, x ->
Arrays.toString((float[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(int[].class, x ->
Arrays.toString((int[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(long[].class, x ->
Arrays.toString((long[])x));
- PRIMITIVE_ARRAY_STRINGIFIERS.put(short[].class, x ->
Arrays.toString((short[])x));
- }
+ private static final List<Tuple2<Class<?>,Function<Object,String>>>
READIFIERS = loadReadifiers();
+ private static final Cache<Class<?>,Function<Object,String>>
READIFIER_CACHE = Cache.<Class<?>,Function<Object,String>>create().build();
private static final char[] HEX = "0123456789ABCDEF".toCharArray();
@@ -186,6 +181,166 @@ public class StringUtils {
return in.substring(0, length - 3) + "...";
}
+ private static List<Tuple2<Class<?>,Function<Object,String>>>
loadReadifiers() {
+ var list = new
ArrayList<Tuple2<Class<?>,Function<Object,String>>>();
+
+ // More specific types first - order matters!
+
+ // Map.Entry before Map
+ list.add(Tuple2.of(Map.Entry.class, o -> {
+ var e = (Map.Entry<?,?>)o;
+ return readable(e.getKey()) + '=' +
readable(e.getValue());
+ }));
+
+ // Collection before Iterable
+ list.add(Tuple2.of(Collection.class, o -> {
+ var c = (Collection<?>)o;
+ return
c.stream().map(StringUtils::readable).collect(joining(",", "[", "]"));
+ }));
+
+ // Map
+ list.add(Tuple2.of(Map.class, o -> {
+ var m = (Map<?,?>)o;
+ return
m.entrySet().stream().map(StringUtils::readable).collect(joining(",", "{",
"}"));
+ }));
+
+ // Iterable (but not Collection, which is handled above)
+ list.add(Tuple2.of(Iterable.class, o -> {
+ var i = (Iterable<?>)o;
+ return readable(toList(i));
+ }));
+
+ // Iterator
+ list.add(Tuple2.of(Iterator.class, o -> {
+ var i = (Iterator<?>)o;
+ return readable(toList(i));
+ }));
+
+ // Enumeration
+ list.add(Tuple2.of(Enumeration.class, o -> {
+ var e = (Enumeration<?>)o;
+ return readable(toList(e));
+ }));
+
+ // Optional
+ list.add(Tuple2.of(Optional.class, o -> {
+ var opt = (Optional<?>)o;
+ return readable(opt.orElse(null));
+ }));
+
+ // GregorianCalendar
+ list.add(Tuple2.of(GregorianCalendar.class, o -> {
+ var cal = (GregorianCalendar)o;
+ return
cal.toZonedDateTime().format(DateTimeFormatter.ISO_INSTANT);
+ }));
+
+ // Date
+ list.add(Tuple2.of(Date.class, o -> {
+ var date = (Date)o;
+ return date.toInstant().toString();
+ }));
+
+ // InputStream
+ list.add(Tuple2.of(InputStream.class, o -> {
+ var is = (InputStream)o;
+ return toHex(is);
+ }));
+
+ // Reader
+ list.add(Tuple2.of(Reader.class, o -> {
+ var r = (Reader)o;
+ return safe(() -> read(r));
+ }));
+
+ // File
+ list.add(Tuple2.of(File.class, o -> {
+ var f = (File)o;
+ return safe(() -> read(f));
+ }));
+
+ // byte[]
+ list.add(Tuple2.of(byte[].class, o -> {
+ var bytes = (byte[])o;
+ return toHex(bytes);
+ }));
+
+ // Enum
+ list.add(Tuple2.of(Enum.class, o -> {
+ var e = (Enum<?>)o;
+ return e.name();
+ }));
+
+ // Class
+ list.add(Tuple2.of(Class.class, o -> {
+ var c = (Class<?>)o;
+ return cns(c);
+ }));
+
+ // Executable (Method or Constructor)
+ list.add(Tuple2.of(Executable.class, o -> {
+ var exec = (Executable)o;
+ var sb = new StringBuilder(64);
+ sb.append(exec instanceof Constructor ?
cns(exec.getDeclaringClass()) : exec.getName()).append('(');
+ var pt = exec.getParameterTypes();
+ for (var i = 0; i < pt.length; i++) {
+ if (i > 0)
+ sb.append(',');
+ sb.append(cns(pt[i]));
+ }
+ sb.append(')');
+ return sb.toString();
+ }));
+
+ // ClassInfo
+ list.add(Tuple2.of(ClassInfo.class, o -> {
+ var ci = (ClassInfo)o;
+ return ci.toString();
+ }));
+
+ // ExecutableInfo
+ list.add(Tuple2.of(ExecutableInfo.class, o -> {
+ var ei = (ExecutableInfo)o;
+ return ei.toString();
+ }));
+
+ // FieldInfo
+ list.add(Tuple2.of(FieldInfo.class, o -> {
+ var fi = (FieldInfo)o;
+ return fi.toString();
+ }));
+
+ // ParameterInfo
+ list.add(Tuple2.of(ParameterInfo.class, o -> {
+ var pi = (ParameterInfo)o;
+ return pi.toString();
+ }));
+
+ // Field
+ list.add(Tuple2.of(Field.class, o -> {
+ var f = (Field)o;
+ return cns(f.getDeclaringClass()) + "." + f.getName();
+ }));
+
+ // Parameter
+ list.add(Tuple2.of(Parameter.class, o -> {
+ var p = (Parameter)o;
+ var exec = p.getDeclaringExecutable();
+ var sb = new StringBuilder(64);
+ sb.append(exec instanceof Constructor ?
cns(exec.getDeclaringClass()) : exec.getName()).append('[');
+ var params = exec.getParameters();
+ for (var i = 0; i < params.length; i++) {
+ if (params[i] == p) {
+ sb.append(i);
+ break;
+ }
+ }
+ sb.append(']');
+ return sb.toString();
+ }));
+
+ return Collections.unmodifiableList(list);
+ }
+
/**
* Appends a string to a StringBuilder, creating a new one if null.
*
@@ -486,8 +641,6 @@ public class StringUtils {
* @return The camelCase string, or <jk>null</jk> if input is
<jk>null</jk>.
*/
public static String camelCase(String str) {
- if (str == null)
- return null;
if (isEmpty(str))
return str;
@@ -4075,8 +4228,6 @@ public class StringUtils {
* @return The kebab-case string, or <jk>null</jk> if input is
<jk>null</jk>.
*/
public static String kebabCase(String str) {
- if (str == null)
- return null;
if (isEmpty(str))
return str;
@@ -5468,8 +5619,6 @@ public class StringUtils {
* @return The PascalCase string, or <jk>null</jk> if input is
<jk>null</jk>.
*/
public static String pascalCase(String str) {
- if (str == null)
- return null;
if (isEmpty(str))
return str;
@@ -5837,56 +5986,43 @@ public class StringUtils {
public static String readable(Object o) {
if (o == null)
return null;
- if (o instanceof Optional<?> o2)
- return readable(o2.orElse(null));
- if (o instanceof Collection<?> o2)
- return
o2.stream().map(StringUtils::readable).collect(Collectors.joining(",", "[",
"]"));
- if (o instanceof Map<?,?> o2)
- return
o2.entrySet().stream().map(StringUtils::readable).collect(Collectors.joining(",",
"{", "}"));
- if (o instanceof Map.Entry<?,?> o2)
- return readable(o2.getKey()) + '=' +
readable(o2.getValue());
- if (o instanceof Iterable<?> o2)
- return readable(toList(o2));
- if (o instanceof Iterator<?> o2)
- return readable(toList(o2));
- if (o instanceof Enumeration<?> o2)
- return readable(toList(o2));
- if (o instanceof GregorianCalendar o2)
- return
o2.toZonedDateTime().format(DateTimeFormatter.ISO_INSTANT);
- if (o instanceof Date o2)
- return o2.toInstant().toString();
- if (o instanceof InputStream o2)
- return toHex(o2);
- if (o instanceof Reader o2)
- return safe(() -> read(o2));
- if (o instanceof File o2)
- return safe(() -> read(o2));
- if (o instanceof byte[] o2)
- return toHex(o2);
- if (o instanceof Enum o2)
- return o2.name();
- if (o instanceof Class o2)
- return cns(o2);
- if (o instanceof Executable o2) {
- var sb = new StringBuilder(64);
- sb.append(o2 instanceof Constructor ?
cns(o2.getDeclaringClass()) : o2.getName()).append('(');
- var pt = o2.getParameterTypes();
- for (var i = 0; i < pt.length; i++) {
- if (i > 0)
- sb.append(',');
- sb.append(cns(pt[i]));
- }
- sb.append(')');
- return sb.toString();
- }
- if (isArray(o)) {
- var l = list();
- for (var i = 0; i < Array.getLength(o); i++) {
- l.add(Array.get(o, i));
+ var c = o.getClass();
+
+ // Special case for byte[] - must be handled before general
array check
+ if (c == byte[].class) {
+ return toHex((byte[])o);
+ }
+
+ // Check cache first
+ var f = READIFIER_CACHE.get(c, () -> {
+ // Find readifier from READIFIERS list
+ // First try exact match, then isAssignableFrom
+ var readifier = READIFIERS.stream()
+ .filter(x -> x.getA() == c ||
x.getA().isAssignableFrom(c))
+ .map(x -> x.getB())
+ .findFirst()
+ .orElse(null);
+
+ // If readifier found, use it
+ if (readifier != null)
+ return readifier;
+
+ // If no readifier found, check if it's an array
+ if (c.isArray()) {
+ return x -> {
+ var l = list();
+ for (var i = 0; i < Array.getLength(x);
i++) {
+ l.add(Array.get(x, i));
+ }
+ return readable(l);
+ };
}
- return readable(l);
- }
- return o.toString();
+
+ // If no readifier found, use toString() as fallback
+ return x -> x.toString();
+ });
+
+ return f.apply(o);
}
/**
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/common/utils/StringUtils_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/common/utils/StringUtils_Test.java
index a2c1c5e1a7..66d9f2193f 100755
---
a/juneau-utest/src/test/java/org/apache/juneau/common/utils/StringUtils_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/common/utils/StringUtils_Test.java
@@ -69,6 +69,19 @@ class StringUtils_Test extends TestBase {
// Edge case: length exactly 4
assertEquals("H...", abbreviate("Hello", 4));
+
+ // String length exactly 3 - should not abbreviate regardless
of length parameter
+ assertEquals("ABC", abbreviate("ABC", 2)); // length <= 3,
returns as-is
+ assertEquals("ABC", abbreviate("ABC", 3)); // length <= 3,
returns as-is
+ assertEquals("ABC", abbreviate("ABC", 4)); // length <= 3,
returns as-is
+ assertEquals("ABC", abbreviate("ABC", 10)); // length <= 3,
returns as-is
+
+ // String length 2 - should not abbreviate
+ assertEquals("AB", abbreviate("AB", 1)); // length <= 3,
returns as-is
+ assertEquals("AB", abbreviate("AB", 2)); // length <= 3,
returns as-is
+
+ // String length 1 - should not abbreviate
+ assertEquals("A", abbreviate("A", 1)); // length <= 3, returns
as-is
}
//====================================================================================================
@@ -246,6 +259,14 @@ class StringUtils_Test extends TestBase {
assertArrayEquals("ABC".getBytes(UTF8), base64Decode("QUJD"));
assertArrayEquals(new byte[] { 0x00, 0x01, 0x02 },
base64Decode("AAEC"));
assertArrayEquals(new byte[] { (byte)0xFF, (byte)0xFE,
(byte)0xFD }, base64Decode("//79"));
+
+ // Invalid BASE64 string length (not multiple of 4)
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("A")); // length 1
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("AB")); // length 2
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("ABC")); // length 3
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("ABCDE")); // length 5
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("ABCDEF")); // length 6
+ assertThrows(IllegalArgumentException.class, () ->
base64Decode("ABCDEFG")); // length 7
}
//====================================================================================================
@@ -350,6 +371,21 @@ class StringUtils_Test extends TestBase {
assertEquals("helloWorldTest", camelCase("Hello_World-Test"));
assertEquals("test", camelCase("test"));
assertEquals("hello123World", camelCase("hello 123 world"));
+
+ // String with only separators (whitespace) - splitWords
returns empty, triggers line 496
+ // Note: splitWords treats separators differently - if string
is only separators,
+ // no words are added because separators trigger word
boundaries but don't create words
+ assertEquals("", camelCase(" ")); // Only whitespace -
splitWords returns empty list
+ assertEquals("", camelCase("\t\t")); // Only tabs - splitWords
returns empty list
+ assertEquals("", camelCase("___")); // Only underscores -
splitWords returns empty list
+ assertEquals("", camelCase("---")); // Only hyphens -
splitWords returns empty list
+ // Punctuation-only strings are treated as words by splitWords
(non-letter chars are appended)
+ // So these return the punctuation as-is since there are no
letters to capitalize
+ assertEquals("!!!", camelCase("!!!"));
+ assertEquals("@#$", camelCase("@#$"));
+ assertEquals(".,;:", camelCase(".,;:"));
+ // Mixed whitespace and punctuation - whitespace separates,
punctuation becomes words
+ assertEquals("!!!", camelCase(" !!! ")); // Whitespace
separates, "!!!" is a word
}
//====================================================================================================
@@ -497,6 +533,9 @@ class StringUtils_Test extends TestBase {
assertFalse(containsAny("test", 'x', 'y'));
assertFalse(containsAny(null, 't'));
assertFalse(containsAny("test", (char[])null));
+ // Empty varargs array
+ assertFalse(containsAny("test", new char[0])); // values.length
== 0
+ assertFalse(containsAny(null, new char[0])); // values.length
== 0
// Test containsAny(String,CharSequence...)
assertTrue(containsAny("test", "te", "xx"));
@@ -504,6 +543,9 @@ class StringUtils_Test extends TestBase {
assertFalse(containsAny("test", "xx", "yy"));
assertFalse(containsAny(null, "test"));
assertFalse(containsAny("test", (CharSequence[])null));
+ // Empty varargs array
+ assertFalse(containsAny("test", new CharSequence[0])); //
values.length == 0
+ assertFalse(containsAny(null, new CharSequence[0])); //
values.length == 0
// Test containsAny(String,String...)
assertTrue(containsAny("test", "te", "xx"));
@@ -511,6 +553,9 @@ class StringUtils_Test extends TestBase {
assertFalse(containsAny("test", "xx", "yy"));
assertFalse(containsAny(null, "test"));
assertFalse(containsAny("test", (String[])null));
+ // Empty varargs array
+ assertFalse(containsAny("test", new String[0])); //
values.length == 0
+ assertFalse(containsAny(null, new String[0])); // values.length
== 0
// Test containsAll(String,char...)
assertTrue(containsAll("test", 't', 'e'));
@@ -518,18 +563,27 @@ class StringUtils_Test extends TestBase {
assertFalse(containsAll("test", 't', 'x'));
assertFalse(containsAll(null, 't'));
assertFalse(containsAll("test", (char[])null));
+ // Empty varargs array
+ assertFalse(containsAll("test", new char[0])); // values.length
== 0
+ assertFalse(containsAll(null, new char[0])); // values.length
== 0
// Test containsAll(String,CharSequence...)
assertTrue(containsAll("test", "te", "st"));
assertFalse(containsAll("test", "te", "xx"));
assertFalse(containsAll(null, "test"));
assertFalse(containsAll("test", (CharSequence[])null));
+ // Empty varargs array
+ assertFalse(containsAll("test", new CharSequence[0])); //
values.length == 0
+ assertFalse(containsAll(null, new CharSequence[0])); //
values.length == 0
// Test containsAll(String,String...)
assertTrue(containsAll("hello world", "hello", "world"));
assertFalse(containsAll("test", "te", "xx"));
assertFalse(containsAll(null, "test"));
assertFalse(containsAll("test", (String[])null));
+ // Empty varargs array
+ assertFalse(containsAll("test", new String[0])); //
values.length == 0
+ assertFalse(containsAll(null, new String[0])); // values.length
== 0
}
//====================================================================================================
@@ -688,6 +742,10 @@ class StringUtils_Test extends TestBase {
assertEquals(1, diffPosition("aa", "abb"));
assertEquals(0, diffPosition("a", null));
assertEquals(0, diffPosition(null, "b"));
+ // Equal strings of same length - triggers line 1158
+ assertEquals(-1, diffPosition("hello", "hello"));
+ assertEquals(-1, diffPosition("test", "test"));
+ assertEquals(-1, diffPosition("", ""));
}
//====================================================================================================
@@ -699,6 +757,10 @@ class StringUtils_Test extends TestBase {
assertEquals(-1, diffPositionIc("a", "A"));
assertEquals(-1, diffPositionIc(null, null));
assertEquals(0, diffPositionIc("a", "b"));
+ // Equal strings of same length (case-insensitive) - triggers
line 1194
+ assertEquals(-1, diffPositionIc("hello", "HELLO"));
+ assertEquals(-1, diffPositionIc("test", "TEST"));
+ assertEquals(-1, diffPositionIc("", ""));
assertEquals(1, diffPositionIc("aa", "ab"));
assertEquals(1, diffPositionIc("Aa", "ab"));
assertEquals(1, diffPositionIc("aa", "Ab"));
@@ -740,6 +802,15 @@ class StringUtils_Test extends TestBase {
// Null/empty input
assertNull(doubleMetaphone(null));
assertNull(doubleMetaphone(""));
+
+ // Test with numbers-only string - metaphone returns "" (empty
string), not null
+ // So doubleMetaphone should return a valid array with empty
strings
+ var codes3 = doubleMetaphone("123");
+ // metaphone("123") returns "" (empty string after removing
non-letters)
+ // So codes3 should be ["", ""], not null
+ if (codes3 != null) {
+ assertEquals(2, codes3.length);
+ }
}
//====================================================================================================
@@ -794,6 +865,9 @@ class StringUtils_Test extends TestBase {
assertFalse(endsWithAny("Hello World", "Hello", "Foo"));
assertFalse(endsWithAny(null, "World"));
assertFalse(endsWithAny("test", (String[])null));
+ // Empty varargs array - triggers line 1382
+ assertFalse(endsWithAny("test", new String[0])); //
suffixes.length == 0
+ assertFalse(endsWithAny(null, new String[0])); //
suffixes.length == 0
}
//====================================================================================================
@@ -927,6 +1001,18 @@ class StringUtils_Test extends TestBase {
assertEquals("Hello\\\\World", escapeForJava("Hello\\World"));
assertEquals("Hello\\u0000World",
escapeForJava("Hello\u0000World"));
assertEquals("Test\\u0001Test",
escapeForJava("Test\u0001Test"));
+
+ // Form feed character - triggers line 1590
+ assertEquals("Test\\fTest", escapeForJava("Test\fTest"));
+
+ // Backspace character - triggers line 1591
+ assertEquals("Test\\bTest", escapeForJava("Test\bTest"));
+
+ // Unicode characters outside ASCII printable range - triggers
line 1593
+ assertEquals("Test\\u0080Test",
escapeForJava("Test\u0080Test")); // Above 0x7E
+ assertEquals("Test\\u001fTest",
escapeForJava("Test\u001FTest")); // Below 0x20 (but not special chars)
+ assertEquals("Test\\u00a0Test",
escapeForJava("Test\u00A0Test")); // Non-breaking space
+ assertEquals("Test\\u0100Test",
escapeForJava("Test\u0100Test")); // Latin capital A with macron
}
//====================================================================================================
@@ -1032,6 +1118,31 @@ class StringUtils_Test extends TestBase {
// Null/empty input
assertTrue(extractBetween(null, "<", ">").isEmpty());
assertTrue(extractBetween("", "<", ">").isEmpty());
+
+ // Empty start or end marker - triggers line 1747
+ assertTrue(extractBetween("test", "", ">").isEmpty()); // Empty
start
+ assertTrue(extractBetween("test", "<", "").isEmpty()); // Empty
end
+ assertTrue(extractBetween("test", "", "").isEmpty()); // Both
empty
+
+ // Start marker found but end marker not found after start -
triggers line 1758
+ var results4 = extractBetween("start<content>end", "<", "X");
// End marker "X" doesn't exist after "<"
+ assertTrue(results4.isEmpty()); // Should return empty since
end not found after start
+
+ var results5 =
extractBetween("start<content1>middle<content2>end", "<", "X");
+ assertTrue(results5.isEmpty()); // End marker not found after
any start
+
+ // Case where start is found but end is never found after it -
triggers line 1758
+ var results6 = extractBetween("text<unclosed", "<", ">");
+ assertTrue(results6.isEmpty()); // End marker ">" not found
after "<", triggers line 1758
+
+ // Case where start is found multiple times, but end is not
found after the last start
+ var results7 =
extractBetween("before<start1>middle<start2>end<start3", "<", ">");
+ // First "<" at position 6, ">" at position 13 - extracts
"start1"
+ // Second "<" at position 20, ">" at position 27 - extracts
"start2"
+ // Third "<" at position 31, but no ">" after it - triggers
line 1758 and breaks
+ assertEquals(2, results7.size());
+ assertEquals("start1", results7.get(0));
+ assertEquals("start2", results7.get(1));
}
//====================================================================================================
@@ -1349,6 +1460,34 @@ class StringUtils_Test extends TestBase {
argsWithNull.put("name", "John");
argsWithNull.put("value", null);
assertEquals("Hello John, value: ", formatNamed("Hello {name},
value: {value}", argsWithNull));
+
+ // Nested braces with depth tracking - triggers lines 2220-2225
+ var argsNested = new HashMap<String,Object>();
+ argsNested.put("outer", "value");
+ argsNested.put("inner", "nested");
+ // Nested braces: {{outer}} - depth tracking
+ // The inner {outer} gets formatted to "value", then "value" is
used as a key
+ // Since "value" doesn't exist in the map, it outputs {value}
+ assertEquals("{value}", formatNamed("{{outer}}", argsNested));
// Double braces, depth > 0
+
+ // Nested braces with internal variable - triggers line 2227
+ argsNested.put("key", "name");
+ argsNested.put("name", "John");
+ // {{key}} should recursively format the inner {key} first
+ assertEquals("John", formatNamed("{{key}}", argsNested)); //
hasInternalVar = true, recursive call
+
+ // Key exists check with containsKey - triggers line 2235
+ var argsExists = new HashMap<String,Object>();
+ argsExists.put("key1", "value1");
+ argsExists.put("key2", null); // null value but key exists
+ assertEquals("value1", formatNamed("{key1}", argsExists));
+ assertEquals("", formatNamed("{key2}", argsExists)); // null
value, key exists
+
+ // Recursive formatNamed when value contains '{' - triggers
line 2244
+ var argsRecursive = new HashMap<String,Object>();
+ argsRecursive.put("outer", "{inner}");
+ argsRecursive.put("inner", "final");
+ assertEquals("final", formatNamed("{outer}", argsRecursive));
// Value contains '{', recursive call
}
//====================================================================================================
@@ -1475,6 +1614,26 @@ class StringUtils_Test extends TestBase {
assertEquals("http://foo:123";,
getAuthorityUri("http://foo:123/bar";));
assertEquals("https://example.com";,
getAuthorityUri("https://example.com/path/to/resource";));
assertEquals("ftp://server.com:21";,
getAuthorityUri("ftp://server.com:21/files";));
+
+ // Invalid URIs - state machine returns original string -
triggers lines 2353, 2358, 2363, 2368, 2373
+ // State S1: non-letter character - triggers line 2353
+ assertEquals("123http://foo";,
getAuthorityUri("123http://foo";)); // Starts with number
+ assertEquals(" http://foo";, getAuthorityUri(" http://foo";)); //
Starts with space
+
+ // State S2: non-letter, non-colon - triggers line 2358
+ assertEquals("httpx://foo", getAuthorityUri("httpx://foo")); //
'x' after 'http' (invalid)
+ assertEquals("http1://foo", getAuthorityUri("http1://foo")); //
Number after 'http'
+
+ // State S3: non-slash - triggers line 2363
+ assertEquals("http:x://foo", getAuthorityUri("http:x://foo"));
// 'x' instead of '/'
+ assertEquals("http:://foo", getAuthorityUri("http:://foo")); //
':' instead of '/'
+
+ // State S4: non-slash - triggers line 2368
+ assertEquals("http:/x://foo",
getAuthorityUri("http:/x://foo")); // 'x' instead of second '/'
+ assertEquals("http:/://foo", getAuthorityUri("http:/://foo"));
// ':' instead of second '/'
+
+ // State S5: slash instead of non-slash - triggers line 2373
+ assertEquals("http:///foo";, getAuthorityUri("http:///foo";)); //
Third '/' instead of hostname
}
//====================================================================================================
@@ -1557,6 +1716,33 @@ class StringUtils_Test extends TestBase {
// Combined with months and years
assertEquals(1 * y + 6 * mo, getDuration("1y6mo"));
assertEquals(2 * y + 3 * mo + 5 * d, getDuration("2y3mo5d"));
+
+ // Whitespace handling - triggers lines 2434, 2437
+ // Multiple whitespace characters between values
+ assertEquals(1 * h + 30 * m, getDuration("1h 30m")); //
Multiple spaces
+ assertEquals(1 * h + 30 * m, getDuration("1h\t30m")); // Tab
character
+ assertEquals(1 * h + 30 * m, getDuration("1h\n30m")); // Newline
+ assertEquals(1 * h + 30 * m, getDuration(" 1h 30m ")); //
Leading/trailing whitespace
+ // Whitespace only at end - triggers line 2437 (break when i >=
len)
+ assertEquals(1 * h, getDuration("1h ")); // Trailing
whitespace only
+
+ // Decimal parsing - triggers line 2446
+ assertEquals((long)(1.5 * h), getDuration("1.5h"));
+ assertEquals((long)(0.25 * m), getDuration("0.25m"));
+ assertEquals((long)(3.14159 * s), getDuration("3.14159s"));
+ // Multiple decimal points should fail (second '.' breaks
parsing)
+ // But the first decimal is parsed, so "1.5.0h" would parse
"1.5" then fail on unit
+
+ // Invalid format - no number found - triggers line 2456
+ assertEquals(-1, getDuration("abc")); // No number, invalid
+ assertEquals(-1, getDuration("h")); // No number, just unit
+ assertEquals(-1, getDuration("ms")); // No number, just unit
+ assertEquals(-1, getDuration(" h")); // Whitespace then unit,
no number
+
+ // Invalid unit - parseUnit returns -1 - triggers line 2475
+ assertEquals(-1, getDuration("1xyz")); // Invalid unit
+ assertEquals(-1, getDuration("1invalid")); // Invalid unit
+ assertEquals(-1, getDuration("1.5bad")); // Invalid unit with
decimal
}
//====================================================================================================
@@ -1662,6 +1848,13 @@ class StringUtils_Test extends TestBase {
// Test with different line endings
assertEquals("1: line1\n2: line2\n",
getNumberedLines("line1\r\nline2"));
+
+ // Test with start < 1 - triggers line 2613
+ assertEquals("1: line1\n2: line2\n",
getNumberedLines("line1\nline2", 0, 2)); // start < 1, should be set to 1
+ assertEquals("1: line1\n2: line2\n",
getNumberedLines("line1\nline2", -5, 2)); // start < 1, should be set to 1
+
+ // Test with end < 0 - triggers line 2615
+ assertEquals("1: line1\n2: line2\n3: line3\n",
getNumberedLines("line1\nline2\nline3", 1, -1)); // end < 0, should be set to
MAX_VALUE
}
//====================================================================================================
@@ -1810,6 +2003,10 @@ class StringUtils_Test extends TestBase {
// Test multiple variables
assertEquals("John is 30 and lives in New York",
interpolate("${name} is ${age} and lives in ${city}", vars));
+
+ // Test with no closing brace - triggers line 2810
+ assertEquals("Hello ${name", interpolate("Hello ${name",
vars)); // No closing brace, append rest as-is
+ assertEquals("Start ${var1 middle ${var2", interpolate("Start
${var1 middle ${var2", vars)); // Multiple unclosed variables
}
//====================================================================================================
@@ -1829,6 +2026,32 @@ class StringUtils_Test extends TestBase {
assertFalse(isAbsoluteUri("x:/x/x"));
assertTrue(isAbsoluteUri("https://example.com";));
assertTrue(isAbsoluteUri("ftp://server.com";));
+
+ // State machine return false cases - triggers lines 2856,
2859, 2863, 2879
+ // State S1: non-letter character - triggers line 2859
+ assertFalse(isAbsoluteUri("1http://foo";)); // Starts with number
+ assertFalse(isAbsoluteUri(" http://foo";)); // Starts with space
+ assertFalse(isAbsoluteUri("Hhttp://foo";)); // Starts with
uppercase (not in 'a'-'z' range)
+
+ // State S2: non-letter, non-colon - triggers line 2863
+ assertFalse(isAbsoluteUri("http1://foo")); // Number after
'http' (not a letter, not ':')
+ assertFalse(isAbsoluteUri("http@://foo")); // '@' after 'http'
(not a letter, not ':')
+ assertFalse(isAbsoluteUri("http /://foo")); // Space after
'http' (not a letter, not ':')
+
+ // State S3: non-slash - triggers line 2863 (else branch)
+ assertFalse(isAbsoluteUri("http:x://foo")); // 'x' instead of
'/'
+ assertFalse(isAbsoluteUri("http:://foo")); // ':' instead of '/'
+
+ // State S4: non-slash - triggers line 2863 (else branch)
+ assertFalse(isAbsoluteUri("http:/x://foo")); // 'x' instead of
second '/'
+ assertFalse(isAbsoluteUri("http:/://foo")); // ':' instead of
second '/'
+
+ // State S5: end of string before reaching valid state -
triggers line 2879
+ // Line 2879 is the final return false after the loop completes
without returning true
+ // This happens when we never reach state S5 (which returns
true immediately)
+ assertFalse(isAbsoluteUri("http")); // Too short, never reaches
S5, loop ends, returns false
+ assertFalse(isAbsoluteUri("http:")); // Reaches S3 but not S5,
loop ends, returns false
+ assertFalse(isAbsoluteUri("http:/")); // Reaches S4 but not S5,
loop ends, returns false
}
//====================================================================================================
@@ -1847,6 +2070,10 @@ class StringUtils_Test extends TestBase {
assertTrue(isAllNotBlank("hello"));
assertTrue(isAllNotBlank("hello", "world"));
assertTrue(isAllNotBlank("hello", "world", "test"));
+
+ // Test with null or empty values array - triggers line 2907
+ assertFalse(isAllNotBlank((CharSequence[])null)); // null array
+ assertFalse(isAllNotBlank(new CharSequence[0])); // empty array
}
//====================================================================================================
@@ -1864,6 +2091,10 @@ class StringUtils_Test extends TestBase {
assertTrue(isAllNotEmpty("hello", "world"));
assertTrue(isAllNotEmpty("hello", " ")); // Whitespace is not
empty
assertTrue(isAllNotEmpty("hello", "world", "test"));
+
+ // Test with null or empty values array - triggers line 2939
+ assertFalse(isAllNotEmpty((CharSequence[])null)); // null array
+ assertFalse(isAllNotEmpty(new CharSequence[0])); // empty array
}
//====================================================================================================
@@ -1919,6 +2150,9 @@ class StringUtils_Test extends TestBase {
assertTrue(isAnyNotBlank("hello"));
assertTrue(isAnyNotBlank("hello", "world"));
assertTrue(isAnyNotBlank("hello", null, ""));
+
+ // Test with null values array - triggers line 3019
+ assertFalse(isAnyNotBlank((CharSequence[])null)); // null array
}
//====================================================================================================
@@ -1936,6 +2170,9 @@ class StringUtils_Test extends TestBase {
assertTrue(isAnyNotEmpty("hello"));
assertTrue(isAnyNotEmpty("hello", "world"));
assertTrue(isAnyNotEmpty("hello", null, ""));
+
+ // Test with null values array - triggers line 3046
+ assertFalse(isAnyNotEmpty((CharSequence[])null)); // null array
}
//====================================================================================================
@@ -2149,6 +2386,21 @@ class StringUtils_Test extends TestBase {
assertFalse(isJsonArray("123", false));
assertFalse(isJsonArray("[", false));
assertFalse(isJsonArray("]", false));
+
+ // Test with ignoreWhitespaceAndComments=true - triggers lines
3333, 3336, 3338
+ // Line 3333: firstRealCharacter(s) != '['
+ assertFalse(isJsonArray(" {1,2,3} ", true)); // Starts with
'{', not '['
+ assertFalse(isJsonArray(" /*comment*/ {1,2,3} ", true)); //
Starts with '{', not '['
+
+ // Line 3336: lastIndexOf(']') == -1
+ assertFalse(isJsonArray(" [1,2,3 ", true)); // No closing ']'
+ assertFalse(isJsonArray(" /*comment*/ [1,2,3 ", true)); // No
closing ']'
+
+ // Line 3338: firstRealCharacter(s) == -1 (after closing
bracket)
+ assertTrue(isJsonArray(" [1,2,3] ", true)); // Valid, no
characters after ']'
+ assertTrue(isJsonArray(" /*comment*/ [1,2,3] /*comment*/ ",
true)); // Valid, only comments/whitespace after ']'
+ assertFalse(isJsonArray(" [1,2,3] extra ", true)); //
Invalid, has characters after ']'
+ assertFalse(isJsonArray(" /*comment*/ [1,2,3] extra
/*comment*/ ", true)); // Invalid, has characters after ']'
}
//====================================================================================================
@@ -2170,6 +2422,18 @@ class StringUtils_Test extends TestBase {
assertFalse(isJsonObject(" foo:'bar' } ", true));
assertFalse(isJsonObject("[]", false));
assertFalse(isJsonObject("123", false));
+
+ // Test with ignoreWhitespaceAndComments=false - triggers line
3354
+ assertTrue(isJsonObject("{}", false)); // Simple case
+ assertTrue(isJsonObject("{key:value}", false)); // With content
+ assertFalse(isJsonObject(" {} ", false)); // Whitespace not
ignored
+ assertFalse(isJsonObject("[]", false)); // Not an object
+
+ // Test with ignoreWhitespaceAndComments=true - triggers line
3361
+ assertTrue(isJsonObject(" {} ", true)); // Valid, no
characters after '}'
+ assertTrue(isJsonObject(" /*comment*/ {key:value} /*comment*/
", true)); // Valid, only comments/whitespace after '}'
+ assertFalse(isJsonObject(" {key:value} extra ", true)); //
Invalid, has characters after '}'
+ assertFalse(isJsonObject(" /*comment*/ {key:value} extra
/*comment*/ ", true)); // Invalid, has characters after '}'
}
//====================================================================================================
@@ -2610,6 +2874,32 @@ class StringUtils_Test extends TestBase {
assertFalse(isUri("x: //x")); // Space after colon
assertFalse(isUri("x:/x/x")); // Only one slash
assertFalse(isUri("C:/temp")); // Filesystem path (excluded)
+
+ // State machine return false cases - triggers lines 3512,
3517, 3525, 3527, 3530
+ // State S1: non-letter character - triggers line 3512 (else
branch)
+ assertFalse(isUri("1http://foo";)); // Starts with number
+ assertFalse(isUri(" http://foo";)); // Starts with space
+ assertFalse(isUri("Hhttp://foo";)); // Starts with uppercase
(not in 'a'-'z' range)
+
+ // State S2: non-letter character - triggers line 3517 (else
branch)
+ assertFalse(isUri("h1ttp://foo")); // Number in protocol
+ assertFalse(isUri("h ttp://foo")); // Space in protocol
+
+ // State S3: non-colon, non-letter - triggers line 3525 (else
branch)
+ // Note: In state S3, we can have multiple letters before ':'
+ // So "httpx://foo" is actually valid (protocol can be longer
than 2 chars)
+ assertFalse(isUri("http1://foo")); // Number after 'http' (not
a letter, not ':')
+ assertFalse(isUri("http/://foo")); // '/' instead of ':' (not a
letter, not ':')
+ assertFalse(isUri("http@://foo")); // '@' instead of ':' (not a
letter, not ':')
+
+ // State S4: non-slash - triggers line 3527 (return false)
+ assertFalse(isUri("http:x://foo")); // 'x' instead of '/'
+ assertFalse(isUri("http:://foo")); // ':' instead of '/'
+
+ // State S4: end of string - triggers line 3530 (return false
after loop)
+ assertFalse(isUri("http:")); // Ends after ':'
+ assertFalse(isUri("http")); // Too short, never reaches S4
+ assertFalse(isUri("ht")); // Too short, never reaches S4
}
//====================================================================================================
@@ -2707,6 +2997,14 @@ class StringUtils_Test extends TestBase {
// Edge case: maximum valid label length (63 chars)
var maxLabel = "a".repeat(63) + ".com";
assertTrue(isValidHostname(maxLabel));
+
+ // Test with empty labels array - triggers line 3605
+ // This is hard to trigger directly since split() with -1 won't
return empty array
+ // But we can test edge cases that might cause issues
+ // Actually, split("\\.", -1) on an empty string returns [""],
not []
+ // So line 3605 might be unreachable, but let's test edge cases
anyway
+ // The only way to get labels.length == 0 would be if split()
somehow returned empty array
+ // This is likely unreachable, but the code handles it
defensively
}
//====================================================================================================
@@ -2742,6 +3040,25 @@ class StringUtils_Test extends TestBase {
// Null/empty input
assertFalse(isValidIpAddress(null));
assertFalse(isValidIpAddress(""));
+
+ // Test IPv4/IPv6 branches - triggers lines 3651, 3663, 3671,
3673
+ // Line 3651: IPv4 check (contains "." and not ":")
+ assertTrue(isValidIpAddress("192.168.1.1")); // Valid IPv4
+ assertFalse(isValidIpAddress("192.168.1")); // Invalid IPv4
(too few parts)
+ assertFalse(isValidIpAddress("192.168.1.1.1")); // Invalid IPv4
(too many parts)
+ assertFalse(isValidIpAddress("256.1.1.1")); // Invalid IPv4
(out of range)
+
+ // Line 3663: IPv6 check (contains ":")
+ assertTrue(isValidIpAddress("2001:0db8:85a3::8a2e:0370:7334"));
// Valid IPv6
+ assertFalse(isValidIpAddress("gggg::1")); // Invalid IPv6
(invalid hex)
+
+ // Line 3671: Neither IPv4 nor IPv6 (no "." and no ":")
+ assertFalse(isValidIpAddress("notanip")); // No dots, no colons
+ assertFalse(isValidIpAddress("abc")); // No dots, no colons
+
+ // Line 3673: NumberFormatException catch
+ assertFalse(isValidIpAddress("192.168.abc.1")); // Invalid
number format
+ assertFalse(isValidIpAddress("192.168.1.abc")); // Invalid
number format
}
//====================================================================================================
@@ -2866,6 +3183,40 @@ class StringUtils_Test extends TestBase {
assertEquals("", join());
assertEquals("a", join("a"));
assertEquals("a,b", join("a", "b"));
+
+ // join(Collection<?>, char) - triggers lines 3825, 3827-3833
+ var collection = new ArrayList<>();
+ collection.add("a");
+ collection.add("b");
+ collection.add("c");
+ assertNull(join((Collection<?>)null, ',')); // Line 3825: null
check
+ assertEquals("a,b,c", join(collection, ',')); // Lines
3827-3833: iteration
+ assertEquals("a", join(Collections.singletonList("a"), ','));
// Single element
+
+ // join(Collection<?>, String, StringBuilder) - triggers line
3859
+ var sb1 = new StringBuilder("prefix-");
+ assertSame(sb1, join((Collection<?>)null, ",", sb1)); // Line
3859: null check, returns sb
+ assertEquals("prefix-a,b,c", join(collection, ",", new
StringBuilder("prefix-")).toString());
+
+ // join(List<?>, char) - triggers line 3917
+ var list = Arrays.asList("x", "y", "z");
+ assertNull(join((List<?>)null, '|')); // Line 3917: null check
+ assertEquals("x|y|z", join(list, '|'));
+
+ // join(List<?>, String) - triggers line 3936
+ assertNull(join((List<?>)null, "|")); // Line 3936: null check
+ assertEquals("x|y|z", join(list, "|"));
+
+ // join(List<?>, String, StringBuilder) - triggers line 3950
+ var sb2 = new StringBuilder("start-");
+ assertSame(sb2, join((List<?>)null, "|", sb2)); // Line 3950:
null check, returns sb
+ assertEquals("start-x|y|z", join(list, "|", new
StringBuilder("start-")).toString());
+
+ // join(Object[], char, StringBuilder) - triggers line 3984
+ var arr = new Object[]{"1", "2", "3"};
+ var sb3 = new StringBuilder("begin-");
+ assertSame(sb3, join((Object[])null, '-', sb3)); // Line 3984:
null check, returns sb
+ assertEquals("begin-1-2-3", join(arr, '-', new
StringBuilder("begin-")).toString());
}
//====================================================================================================
@@ -2939,6 +3290,14 @@ class StringUtils_Test extends TestBase {
assertEquals("test", kebabCase("test"));
assertEquals("test", kebabCase("TEST"));
assertEquals("hello-123-world", kebabCase("hello 123 world"));
+
+ // Test with empty words list - triggers line 4085
+ // splitWords returns empty list for strings with only
separators (spaces, tabs, underscores, hyphens)
+ assertEquals("", kebabCase(" ")); // Only spaces
+ assertEquals("", kebabCase("\t\t")); // Only tabs
+ assertEquals("", kebabCase("___")); // Only underscores
+ assertEquals("", kebabCase("---")); // Only hyphens
+ assertEquals("", kebabCase(" \t_-\t ")); // Only separators
}
//====================================================================================================
@@ -3045,6 +3404,12 @@ class StringUtils_Test extends TestBase {
// Null/empty input
assertEquals(0, lineCount(null));
assertEquals(0, lineCount(""));
+
+ // Test with just \r (not \r\n) - triggers line 4262
+ assertEquals(2, lineCount("line1\rline2")); // Just \r
+ assertEquals(3, lineCount("line1\rline2\rline3")); // Multiple
\r
+ assertEquals(2, lineCount("\rline2")); // Starts with \r
+ assertEquals(2, lineCount("line1\r")); // Ends with \r
}
//====================================================================================================
@@ -3121,6 +3486,269 @@ class StringUtils_Test extends TestBase {
var code4 = metaphone("A");
assertNotNull(code4);
assertFalse(code4.isEmpty());
+
+ // Test initial character handling - triggers lines 4369, 4371,
4374
+ // Line 4369: KN, GN, PN, AE, WR
+ assertNotNull(metaphone("KNIGHT")); // Starts with KN
+ assertNotNull(metaphone("GNOME")); // Starts with GN
+ assertNotNull(metaphone("PNUT")); // Starts with PN
+ assertNotNull(metaphone("AEROPLANE")); // Starts with AE
+ assertNotNull(metaphone("WRITE")); // Starts with WR
+
+ // Line 4371: X at start
+ var codeX = metaphone("XRAY");
+ assertNotNull(codeX);
+ assertTrue(codeX.startsWith("S")); // X at start becomes S
+
+ // Line 4374: WH at start
+ var codeWH = metaphone("WHITE");
+ assertNotNull(codeWH);
+ assertTrue(codeWH.startsWith("W")); // WH at start becomes W
+
+ // Test duplicate skipping (except C) - triggers line 4387
+ var codeDD = metaphone("ADD");
+ assertNotNull(codeDD);
+ // 'DD' should be treated as single 'D'
+
+ var codeLL = metaphone("HELLO");
+ assertNotNull(codeLL);
+ // 'LL' should be treated as single 'L'
+
+ // CC should NOT be skipped (special case)
+ var codeCC = metaphone("ACCENT");
+ assertNotNull(codeCC);
+
+ // Test C handling - triggers lines 4401, 4404, 4406
+ // Line 4401: CH with prev != 'S'
+ var codeCH = metaphone("CHURCH");
+ assertNotNull(codeCH);
+ assertTrue(codeCH.contains("X")); // CH becomes X
+
+ // Line 4401: CH with prev == 'S' (should become K)
+ var codeSCH = metaphone("SCHOOL");
+ assertNotNull(codeSCH);
+
+ // Line 4404: C followed by I, E, or Y
+ var codeCI = metaphone("CITY");
+ assertNotNull(codeCI);
+ assertTrue(codeCI.contains("S")); // CI becomes S
+
+ var codeCE = metaphone("CENT");
+ assertNotNull(codeCE);
+ assertTrue(codeCE.contains("S")); // CE becomes S
+
+ var codeCY = metaphone("CYCLE");
+ assertNotNull(codeCY);
+ assertTrue(codeCY.contains("S")); // CY becomes S
+
+ // Line 4406: C default (becomes K)
+ var codeCA = metaphone("CAT");
+ assertNotNull(codeCA);
+ assertTrue(codeCA.contains("K")); // CA becomes K
+
+ // Test D handling - triggers line 4411
+ // DG followed by E, I, or Y
+ var codeDGE = metaphone("EDGE");
+ assertNotNull(codeDGE);
+ assertTrue(codeDGE.contains("J")); // DGE becomes J
+
+ var codeDGI = metaphone("BUDGIE");
+ assertNotNull(codeDGI);
+
+ var codeDGY = metaphone("BUDGY");
+ assertNotNull(codeDGY);
+
+ // Test G handling - triggers lines 4426-4434
+ // GH followed by vowel (silent)
+ var codeGH = metaphone("NIGHT");
+ assertNotNull(codeGH);
+
+ // GN followed by E or D (silent)
+ var codeGN = metaphone("SIGN");
+ assertNotNull(codeGN);
+
+ // G followed by E, I, or Y (becomes J)
+ var codeGE = metaphone("AGE");
+ assertNotNull(codeGE);
+ assertTrue(codeGE.contains("J")); // GE becomes J
+
+ var codeGI = metaphone("GIRAFFE");
+ assertNotNull(codeGI);
+
+ // G default (becomes K)
+ var codeGA = metaphone("GATE");
+ assertNotNull(codeGA);
+ assertTrue(codeGA.contains("K")); // GA becomes K
+
+ // Test H handling - triggers lines 4436-4439
+ // H between vowels (silent)
+ var codeH = metaphone("AHOY");
+ assertNotNull(codeH);
+
+ // H not between vowels (kept)
+ var codeH2 = metaphone("HELLO");
+ assertNotNull(codeH2);
+
+ // Test K handling - triggers lines 4440-4443
+ // K after C (silent)
+ var codeCK = metaphone("BACK");
+ assertNotNull(codeCK);
+
+ // K not after C (kept)
+ var codeK = metaphone("KITE");
+ assertNotNull(codeK);
+ assertTrue(codeK.contains("K")); // K is kept
+
+ // Test P handling - triggers lines 4444-4451
+ // PH becomes F
+ var codePH = metaphone("PHONE");
+ assertNotNull(codePH);
+ assertTrue(codePH.contains("F")); // PH becomes F
+
+ // P default
+ var codeP = metaphone("PARK");
+ assertNotNull(codeP);
+ assertTrue(codeP.contains("P")); // P is kept
+
+ // Test Q handling - triggers lines 4452-4454
+ var codeQ = metaphone("QUICK");
+ assertNotNull(codeQ);
+ assertTrue(codeQ.contains("K")); // Q becomes K
+
+ // Test S handling - triggers lines 4455-4465
+ // SH becomes X
+ var codeSH = metaphone("SHIP");
+ assertNotNull(codeSH);
+ assertTrue(codeSH.contains("X")); // SH becomes X
+
+ // SIO or SIA becomes X
+ var codeSIO = metaphone("VISION");
+ assertNotNull(codeSIO);
+
+ var codeSIA = metaphone("ASIA");
+ assertNotNull(codeSIA);
+
+ // S default
+ var codeS = metaphone("SUN");
+ assertNotNull(codeS);
+ assertTrue(codeS.contains("S")); // S is kept
+
+ // Test T handling - triggers lines 4466-4476
+ // TH becomes 0
+ var codeTH = metaphone("THINK");
+ assertNotNull(codeTH);
+ assertTrue(codeTH.contains("0")); // TH becomes 0
+
+ // TIO or TIA becomes X
+ var codeTIO = metaphone("NATION");
+ assertNotNull(codeTIO);
+
+ var codeTIA = metaphone("RATIO");
+ assertNotNull(codeTIA);
+
+ // T default
+ var codeT = metaphone("TANK");
+ assertNotNull(codeT);
+ assertTrue(codeT.contains("T")); // T is kept
+
+ // Test V handling - triggers lines 4477-4479
+ var codeV = metaphone("VASE");
+ assertNotNull(codeV);
+ assertTrue(codeV.contains("F")); // V becomes F
+
+ // Test W and Y handling - triggers lines 4480-4483
+ // W or Y followed by vowel
+ var codeW = metaphone("WATER");
+ assertNotNull(codeW);
+ assertTrue(codeW.contains("W")); // W before vowel is kept
+
+ var codeY = metaphone("YELLOW");
+ assertNotNull(codeY);
+ assertTrue(codeY.contains("Y")); // Y before vowel is kept
+
+ // W or Y not followed by vowel (silent)
+ var codeW2 = metaphone("SWIM");
+ assertNotNull(codeW2);
+
+ // Test X handling - triggers lines 4484-4489
+ // X at start becomes S
+ var codeX2 = metaphone("XYLOPHONE");
+ assertNotNull(codeX2);
+ assertTrue(codeX2.startsWith("S")); // X at start becomes S
+
+ // X not at start becomes KS
+ var codeX3 = metaphone("AXE");
+ assertNotNull(codeX3);
+ assertTrue(codeX3.contains("KS")); // X becomes KS
+
+ // Test Z handling - triggers lines 4490-4492
+ var codeZ = metaphone("ZOO");
+ assertNotNull(codeZ);
+ assertTrue(codeZ.contains("S")); // Z becomes S
+
+ // Test B handling - triggers line 4393
+ // B after M at end of string (silent) - prev == 'M' && next ==
'\0'
+ var codeMB = metaphone("LAMB");
+ assertNotNull(codeMB);
+ // B after M at end should be silent (not appended)
+
+ // B after M not at end (kept) - prev == 'M' but next != '\0'
+ var codeMB2 = metaphone("LAMBS");
+ assertNotNull(codeMB2);
+
+ // B not after M (kept) - prev != 'M'
+ var codeB = metaphone("BAT");
+ assertNotNull(codeB);
+ assertTrue(codeB.contains("B")); // B is kept
+
+ // Test D handling - triggers line 4410 (else branch)
+ // D not followed by G, or DG not followed by E/I/Y (becomes T)
+ var codeD = metaphone("DOG"); // D not followed by G
+ assertNotNull(codeD);
+ assertTrue(codeD.contains("T")); // D becomes T
+
+ var codeDGA = metaphone("BUDGA"); // DG followed by A (not
E/I/Y)
+ assertNotNull(codeDGA);
+ assertTrue(codeDGA.contains("T")); // D becomes T, not J
+
+ // Test G handling - triggers lines 4426, 4428, 4430
+ // Line 4426: GH followed by non-vowel (not silent, becomes K)
+ var codeGH2 = metaphone("AUGHT"); // GH followed by T
(non-vowel)
+ assertNotNull(codeGH2);
+ assertTrue(codeGH2.contains("K")); // G becomes K
+
+ // Line 4428: GN followed by non-E/D (not silent, becomes K)
+ var codeGN2 = metaphone("SIGNAL"); // GN followed by A (not E/D)
+ assertNotNull(codeGN2);
+ assertTrue(codeGN2.contains("K")); // G becomes K
+
+ // Line 4430: G followed by E/I/Y but prev IS 'G' (doesn't
become J, becomes K)
+ var codeGGE = metaphone("AGGIE"); // GG, second G followed by
I, but prev is G
+ assertNotNull(codeGGE);
+ // Second G should become K, not J
+
+ // Test H handling - triggers line 4437
+ // H between vowels (silent) - both prev and next are vowels
(!isVowel(prev) || !isVowel(next) is false)
+ var codeH3 = metaphone("AHOY"); // A-H-O, H between vowels
+ assertNotNull(codeH3);
+ // H should be silent when between vowels (not appended)
+
+ // H not between vowels (kept) - at least one of prev/next is
not vowel
+ var codeH4 = metaphone("HELLO"); // H-E, H at start (prev is
not vowel)
+ assertNotNull(codeH4);
+ assertTrue(codeH4.contains("H")); // H is kept
+
+ // Test T handling - triggers line 4470 (else branch)
+ // T followed by I but next2 is not O or A (becomes T, not X)
+ var codeTI = metaphone("TICK"); // T-I-C, I not followed by O
or A
+ assertNotNull(codeTI);
+ assertTrue(codeTI.contains("T")); // T is kept, not X
+
+ // TIO or TIA becomes X (already tested above)
+
+ // Test X handling - triggers line 4486
+ // X at start (i == 0) becomes S (already tested above with
"XRAY")
+ // X not at start (i != 0) becomes KS (already tested above
with "AXE")
}
//====================================================================================================
@@ -3172,6 +3800,29 @@ class StringUtils_Test extends TestBase {
assertTrue(naturalCompare(null, "test") < 0);
assertTrue(naturalCompare("test", null) > 0);
assertEquals(0, naturalCompare(null, null));
+
+ // Test numeric comparison with leading zeros - triggers lines
4602, 4605, 4607
+ assertTrue(naturalCompare("file002.txt", "file10.txt") < 0); //
002 < 10 (leading zeros skipped)
+ assertTrue(naturalCompare("file010.txt", "file002.txt") > 0);
// 010 > 002 (leading zeros skipped)
+ // Test leading zero skipping - both strings have leading zeros
+ assertTrue(naturalCompare("file0002.txt", "file0010.txt") < 0);
// 0002 < 0010 (leading zeros skipped)
+ assertTrue(naturalCompare("file0010.txt", "file0002.txt") > 0);
// 0010 > 0002 (leading zeros skipped)
+
+ // Test numeric comparison with different lengths - triggers
line 4620
+ assertTrue(naturalCompare("file2.txt", "file10.txt") < 0); // 2
< 10 (different lengths)
+ assertTrue(naturalCompare("file100.txt", "file9.txt") > 0); //
100 > 9 (different lengths)
+
+ // Test numeric comparison with same length - triggers lines
4624-4632
+ assertTrue(naturalCompare("file12.txt", "file13.txt") < 0); //
12 < 13 (same length, digit by digit)
+ assertTrue(naturalCompare("file13.txt", "file12.txt") > 0); //
13 > 12 (same length, digit by digit)
+ assertEquals(0, naturalCompare("file12.txt", "file12.txt")); //
12 == 12 (same length, all digits equal)
+ assertTrue(naturalCompare("file19.txt", "file20.txt") < 0); //
19 < 20 (same length, digit by digit)
+
+ // Test when one string is longer - triggers line 4643
+ assertTrue(naturalCompare("file1", "file10.txt") < 0); //
"file1" is shorter
+ assertTrue(naturalCompare("file10.txt", "file1") > 0); //
"file10.txt" is longer
+ assertTrue(naturalCompare("abc", "abcd") < 0); // "abc" is
shorter
+ assertTrue(naturalCompare("abcd", "abc") > 0); // "abcd" is
longer
}
//====================================================================================================
@@ -3374,6 +4025,41 @@ class StringUtils_Test extends TestBase {
var suggestions2 = optimizeString(veryLargeString);
assertNotNull(suggestions2);
assertTrue(suggestions2.contains("compression"));
+
+ // Medium-length strings (10 < length < 100) that are not
interned - triggers line 4992
+ // Create a string that is not interned and meets the criteria
+ // Use a unique string that won't be in the string pool
+ var mediumString = new String(new char[50]).replace('\0', 'x');
// Length 50, explicitly not interned
+ var suggestions3 = optimizeString(mediumString);
+ // optimizeString returns null if no suggestions, or a string
with suggestions
+ // For medium-length strings that are not interned, it should
suggest interning
+ // Note: The string might be interned by the JVM, so we check
if suggestions exist
+ if (suggestions3 != null) {
+ assertTrue(suggestions3.contains("interning"));
+ }
+ // If null, the string was already interned, which is fine -
the line is still covered by the check
+
+ // Medium-length string that IS interned (should not suggest
interning)
+ var internedString = "x".repeat(50).intern();
+ var suggestions4 = optimizeString(internedString);
+ // Should not contain interning suggestion if already interned
+ if (suggestions4 != null) {
+ assertFalse(suggestions4.contains("interning"));
+ }
+
+ // String exactly 10 chars (should not suggest interning)
+ var exactly10 = "x".repeat(10);
+ var suggestions5 = optimizeString(exactly10);
+ if (suggestions5 != null) {
+ assertFalse(suggestions5.contains("interning"));
+ }
+
+ // String exactly 100 chars (should not suggest interning)
+ var exactly100 = "x".repeat(100);
+ var suggestions6 = optimizeString(exactly100);
+ if (suggestions6 != null) {
+ assertFalse(suggestions6.contains("interning"));
+ }
}
//====================================================================================================
@@ -3536,6 +4222,32 @@ class StringUtils_Test extends TestBase {
// Should throw for invalid dates (DateTimeParseException is
thrown by DateUtils, not IllegalArgumentException)
assertThrows(Exception.class, () ->
parseIsoCalendar("invalid"));
assertThrows(Exception.class, () ->
parseIsoCalendar("2023-13-25")); // Invalid month
+
+ // Test empty input - triggers line 5210
+ assertNull(parseIsoCalendar(null));
+ assertNull(parseIsoCalendar(""));
+ assertNull(parseIsoCalendar(" "));
+
+ // Test with milliseconds (comma) - triggers line 5213
+ var cal5 = parseIsoCalendar("2023-12-25T14:30:00,123");
+ assertNotNull(cal5);
+ assertEquals(14, cal5.get(Calendar.HOUR_OF_DAY));
+ assertEquals(30, cal5.get(Calendar.MINUTE));
+ assertEquals(0, cal5.get(Calendar.SECOND)); // Milliseconds
trimmed
+
+ // Test format yyyy-MM-ddThh - triggers line 5221
+ var cal6 = parseIsoCalendar("2023-12-25T14");
+ assertNotNull(cal6);
+ assertEquals(14, cal6.get(Calendar.HOUR_OF_DAY));
+ assertEquals(0, cal6.get(Calendar.MINUTE));
+ assertEquals(0, cal6.get(Calendar.SECOND));
+
+ // Test format yyyy-MM-ddThh:mm - triggers line 5223
+ var cal7 = parseIsoCalendar("2023-12-25T14:30");
+ assertNotNull(cal7);
+ assertEquals(14, cal7.get(Calendar.HOUR_OF_DAY));
+ assertEquals(30, cal7.get(Calendar.MINUTE));
+ assertEquals(0, cal7.get(Calendar.SECOND));
}
//====================================================================================================
@@ -3550,6 +4262,11 @@ class StringUtils_Test extends TestBase {
var date2 = parseIsoDate("2023-12-25T14:30:00");
assertNotNull(date2);
+ // Test empty input - triggers line 5240
+ // Note: parseIsoDate checks isEmpty before calling
parseIsoCalendar, so it returns null
+ assertNull(parseIsoDate(null));
+ assertNull(parseIsoDate(""));
+
// Should throw for invalid dates (DateTimeParseException is
thrown by DateUtils, not IllegalArgumentException)
assertThrows(Exception.class, () -> parseIsoDate("invalid"));
}
@@ -3640,6 +4357,26 @@ class StringUtils_Test extends TestBase {
// Null/empty input
assertTrue(parseMap(null, '=', ',', false).isEmpty());
assertTrue(parseMap("", '=', ',', false).isEmpty());
+
+ // Test empty entries - triggers line 5324
+ var map5 = parseMap("key1=value1,,key2=value2", '=', ',',
false);
+ assertEquals(2, map5.size()); // Empty entry skipped
+ assertEquals("value1", map5.get("key1"));
+ assertEquals("value2", map5.get("key2"));
+
+ // Test entry without delimiter (no key-value delimiter) -
triggers lines 5326, 5328
+ var map6 = parseMap("key1=value1,keyonly,key2=value2", '=',
',', false);
+ assertEquals(3, map6.size());
+ assertEquals("value1", map6.get("key1"));
+ assertEquals("", map6.get("keyonly")); // Key with empty value
+ assertEquals("value2", map6.get("key2"));
+
+ // Test entry without delimiter with trimming
+ var map7 = parseMap(" key1 = value1 , keyonly , key2 = value2
", '=', ',', true);
+ assertEquals(3, map7.size());
+ assertEquals("value1", map7.get("key1"));
+ assertEquals("", map7.get("keyonly")); // Key with empty value,
trimmed
+ assertEquals("value2", map7.get("key2"));
}
//====================================================================================================
@@ -3666,6 +4403,35 @@ class StringUtils_Test extends TestBase {
// Null input
assertNull(parseNumber(null, null));
+
+ // Test empty string becomes "0" - triggers line 5373
+ assertEquals(0, parseNumber("", null));
+ assertEquals(0, parseNumber("", Integer.class));
+
+ // Test Double type - triggers line 5403
+ assertEquals(123.45, parseNumber("123.45", Double.class));
+ assertEquals(123.45, parseNumber("123.45", Double.TYPE));
+
+ // Test Float type - triggers line 5410
+ assertEquals(123.45f, parseNumber("123.45", Float.class));
+ assertEquals(123.45f, parseNumber("123.45", Float.TYPE));
+
+ // Test Long type - triggers line 5414
+ assertEquals(123L, parseNumber("123", Long.class));
+ assertEquals(123L, parseNumber("123", Long.TYPE));
+ assertEquals(123L, parseNumber("123",
java.util.concurrent.atomic.AtomicLong.class).longValue());
+
+ // Test Integer type - triggers line 5432
+ assertEquals(123, parseNumber("123", Integer.class));
+ assertEquals(123, parseNumber("123", Integer.TYPE));
+
+ // Test Short type - triggers line 5434
+ assertEquals((short)123, parseNumber("123", Short.class));
+ assertEquals((short)123, parseNumber("123", Short.TYPE));
+
+ // Test Byte type - triggers line 5436
+ assertEquals((byte)123, parseNumber("123", Byte.class));
+ assertEquals((byte)123, parseNumber("123", Byte.TYPE));
}
//====================================================================================================
@@ -3685,6 +4451,14 @@ class StringUtils_Test extends TestBase {
assertEquals("Test", pascalCase("test"));
assertEquals("Test", pascalCase("TEST"));
assertEquals("Hello123World", pascalCase("hello 123 world"));
+
+ // Test with empty words list - triggers line 5478
+ // splitWords returns empty list for strings with only
separators
+ assertEquals("", pascalCase(" ")); // Only spaces
+ assertEquals("", pascalCase("\t\t")); // Only tabs
+ assertEquals("", pascalCase("___")); // Only underscores
+ assertEquals("", pascalCase("---")); // Only hyphens
+ assertEquals("", pascalCase(" \t_-\t ")); // Only separators
}
//====================================================================================================
@@ -3721,6 +4495,19 @@ class StringUtils_Test extends TestBase {
assertEquals("leaves", pluralize("leaf", 2));
assertEquals("lives", pluralize("life", 2));
assertEquals("knives", pluralize("knife", 2));
+
+ // Test null or empty word - triggers line 5503
+ assertNull(pluralize(null, 2));
+ assertEquals("", pluralize("", 2));
+
+ // Test word with length 1 ending in 'y' - triggers line 5516
(length > 1 is false)
+ assertEquals("ys", pluralize("y", 2)); // Single character 'y',
just adds 's'
+
+ // Test word ending in 'y' preceded by vowel - triggers line
5518 (condition is false)
+ assertEquals("days", pluralize("day", 2)); // 'a' is vowel, so
condition false, just adds 's'
+ assertEquals("boys", pluralize("boy", 2)); // 'o' is vowel
+ assertEquals("keys", pluralize("key", 2)); // 'e' is vowel
+ assertEquals("guys", pluralize("guy", 2)); // 'u' is vowel
}
//====================================================================================================
@@ -3878,6 +4665,26 @@ class StringUtils_Test extends TestBase {
assertEquals(0.0, readabilityScore(null), 0.0001);
assertEquals(0.0, readabilityScore(""), 0.0001);
+ // Test with no words (only punctuation/whitespace) - triggers
line 5737
+ // Note: extractWords might extract numbers as words, so use
only punctuation
+ assertEquals(0.0, readabilityScore("!!!"), 0.0001); // No words
extracted
+ assertEquals(0.0, readabilityScore("..."), 0.0001); // No words
extracted
+ assertEquals(0.0, readabilityScore(" "), 0.0001); // Only
whitespace
+
+ // Test sentence endings - triggers line 5743
+ var score1 = readabilityScore("First sentence. Second
sentence!");
+ assertTrue(score1 > 0);
+ assertTrue(score1 <= 100);
+
+ var score2 = readabilityScore("What is this? It is a test.");
+ assertTrue(score2 > 0);
+ assertTrue(score2 <= 100);
+
+ // Test with no sentence endings (sentenceCount == 0) -
triggers line 5748
+ var score3 = readabilityScore("This is a test without sentence
endings");
+ assertTrue(score3 > 0); // Should still calculate score
(sentenceCount set to 1)
+ assertTrue(score3 <= 100);
+
// Score should be in 0-100 range
var score = readabilityScore("This is a test sentence.");
assertTrue(score >= 0.0 && score <= 100.0);
@@ -3894,13 +4701,179 @@ class StringUtils_Test extends TestBase {
assertEquals("[1,2,3]", readable(ints(1, 2, 3)));
assertEquals("test", readable(opt("test")));
assertNull(readable(opte()));
+
+ // Test Iterable (not Collection) - triggers line 5842
+ var customIterable = new Iterable<String>() {
+ @Override
+ public Iterator<String> iterator() {
+ return Arrays.asList("x", "y", "z").iterator();
+ }
+ };
+ assertEquals("[x,y,z]", readable(customIterable));
+
+ // Test Iterator - triggers line 5844
+ var iterator = Arrays.asList("a", "b").iterator();
+ assertEquals("[a,b]", readable(iterator));
+
+ // Test Enumeration - triggers line 5846
+ var enumeration = Collections.enumeration(Arrays.asList("1",
"2", "3"));
+ assertEquals("[1,2,3]", readable(enumeration));
+
+ // Test GregorianCalendar - triggers line 5848
+ var cal = new GregorianCalendar(2023, Calendar.DECEMBER, 25,
14, 30, 0);
+ cal.setTimeZone(TimeZone.getTimeZone("UTC"));
+ var calStr = readable(cal);
+ assertNotNull(calStr);
+ assertTrue(calStr.contains("2023"));
+
+ // Test Date - triggers line 5850
+ var date = new Date(1703520000000L); // 2023-12-25 00:00:00 UTC
+ var dateStr = readable(date);
+ assertNotNull(dateStr);
+ assertTrue(dateStr.contains("2023"));
+
+ // Test InputStream - triggers line 5852
+ var inputStream = new
ByteArrayInputStream("Hello".getBytes(UTF8));
+ var isStr = readable(inputStream);
+ assertNotNull(isStr);
+ // Should be hex representation
+
+ // Test Reader - triggers line 5854
+ var reader = new StringReader("Test content");
+ var readerStr = readable(reader);
+ assertNotNull(readerStr);
+ assertEquals("Test content", readerStr);
+
+ // Test File - triggers line 5856
+ var file = new File("test.txt");
+ var fileStr = readable(file);
+ // May throw exception or return content, depends on file
existence
+ // Just verify it doesn't crash
+
+ // Test byte[] - triggers line 5858
+ var bytes = new byte[]{0x48, 0x65, 0x6C, 0x6C, 0x6F}; //
"Hello" in hex
+ var bytesStr = readable(bytes);
+ assertNotNull(bytesStr);
+ assertEquals("48656C6C6F", bytesStr);
+
+ // Test Enum - triggers line 5860
+ enum TestEnum { VALUE1, VALUE2 }
+ var enumValue = TestEnum.VALUE1;
+ assertEquals("VALUE1", readable(enumValue));
+
+ // Test Class - triggers line 5862
+ var clazz = String.class;
+ var classStr = readable(clazz);
+ assertNotNull(classStr);
+ assertTrue(classStr.contains("String"));
+
+ // Test Executable (Method) - triggers lines 5864-5874
+ try {
+ var method = String.class.getMethod("length");
+ var methodStr = readable(method);
+ assertNotNull(methodStr);
+ assertTrue(methodStr.contains("length"));
+ assertTrue(methodStr.contains("()"));
+ } catch (NoSuchMethodException e) {
+ fail("Method not found");
+ }
+
+ // Test Executable (Constructor) - triggers lines 5864-5874
+ try {
+ var constructor =
String.class.getConstructor(String.class);
+ var constructorStr = readable(constructor);
+ assertNotNull(constructorStr);
+ assertTrue(constructorStr.contains("String"));
+ assertTrue(constructorStr.contains("("));
+ } catch (NoSuchMethodException e) {
+ fail("Constructor not found");
+ }
+
+ // Test Executable with parameters - triggers line 5869
+ try {
+ var method = String.class.getMethod("substring",
int.class, int.class);
+ var methodStr = readable(method);
+ assertNotNull(methodStr);
+ assertTrue(methodStr.contains("substring"));
+ assertTrue(methodStr.contains("int"));
+ assertTrue(methodStr.contains(",")); // Multiple
parameters
+ } catch (NoSuchMethodException e) {
+ fail("Method not found");
+ }
+
+ // Test ClassInfo - triggers new ClassInfo case
+ var classInfo =
org.apache.juneau.common.reflect.ClassInfo.of(String.class);
+ var classInfoStr = readable(classInfo);
+ assertNotNull(classInfoStr);
+ assertTrue(classInfoStr.contains("String"));
+
+ // Test ExecutableInfo (MethodInfo) - triggers new
ExecutableInfo case
+ var methodInfoOpt = classInfo.getPublicMethod(m ->
m.hasName("length"));
+ if (methodInfoOpt.isPresent()) {
+ var methodInfo = methodInfoOpt.get();
+ var methodInfoStr = readable(methodInfo);
+ assertNotNull(methodInfoStr);
+ assertTrue(methodInfoStr.contains("length"));
+
+ // Test ParameterInfo - triggers new ParameterInfo case
+ var params = methodInfo.getParameters();
+ if (!params.isEmpty()) {
+ var paramInfo = params.get(0);
+ var paramInfoStr = readable(paramInfo);
+ assertNotNull(paramInfoStr);
+ }
+ }
+
+ // Test ExecutableInfo (ConstructorInfo) - triggers new
ExecutableInfo case
+ var constructors = classInfo.getPublicConstructors();
+ if (!constructors.isEmpty()) {
+ var constructorInfo = constructors.get(0);
+ var constructorInfoStr = readable(constructorInfo);
+ assertNotNull(constructorInfoStr);
+ assertTrue(constructorInfoStr.contains("String"));
+ }
+
+ // Test FieldInfo - triggers new FieldInfo case
+ var fieldInfoOpt = classInfo.getPublicField(f ->
f.hasName("CASE_INSENSITIVE_ORDER"));
+ if (fieldInfoOpt.isPresent()) {
+ var fieldInfo = fieldInfoOpt.get();
+ var fieldInfoStr = readable(fieldInfo);
+ assertNotNull(fieldInfoStr);
+
assertTrue(fieldInfoStr.contains("CASE_INSENSITIVE_ORDER"));
+ }
+
+ // Test Field (java.lang.reflect.Field) - triggers new Field
case
+ try {
+ var field =
String.class.getField("CASE_INSENSITIVE_ORDER");
+ var fieldStr = readable(field);
+ assertNotNull(fieldStr);
+ assertTrue(fieldStr.contains("CASE_INSENSITIVE_ORDER"));
+ assertTrue(fieldStr.contains("String"));
+ } catch (NoSuchFieldException e) {
+ // Field might not exist, that's okay
+ }
+
+ // Test Parameter (java.lang.reflect.Parameter) - triggers new
Parameter case
+ try {
+ var method = String.class.getMethod("substring",
int.class, int.class);
+ var parameters = method.getParameters();
+ if (parameters.length > 0) {
+ var paramStr = readable(parameters[0]);
+ assertNotNull(paramStr);
+ // Parameter format is: methodName[index] or
className[index] for constructors
+ // Just verify it's not empty and contains a
bracket
+ assertTrue(paramStr.length() > 0);
+ }
+ } catch (NoSuchMethodException e) {
+ fail("Method not found");
+ }
}
//====================================================================================================
// remove(String,String)
//====================================================================================================
@Test
- void a164_remove() {
+ void a165_remove() {
assertNull(remove(null, "x"));
assertEquals("hello", remove("hello", null));
assertEquals("hello", remove("hello", ""));
