You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2025/11/30 22:38:12 UTC

(juneau) branch master updated: Unit tests

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 3f7b26b649 Unit tests
3f7b26b649 is described below

commit 3f7b26b649de0d023aef2ec33f78a2a72f299055
Author: James Bognar <ja...@salesforce.com>
AuthorDate: Sun Nov 30 17:38:07 2025 -0500

    Unit tests
---
 .../java/org/apache/juneau/common/utils/Utils.java |   4 +-
 .../apache/juneau/html/BasicHtmlDocTemplate.java   |  17 +-
 .../juneau/common/utils/StringUtils_Test.java      |   8 -
 .../org/apache/juneau/common/utils/Utils_Test.java | 916 ++++++++++++++++++++-
 4 files changed, 922 insertions(+), 23 deletions(-)

diff --git a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/Utils.java b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/Utils.java
index accb0a3f3d..26aa1ad70b 100644
--- a/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/Utils.java
+++ b/juneau-core/juneau-common/src/main/java/org/apache/juneau/common/utils/Utils.java
@@ -282,8 +282,8 @@ public class Utils {
 			return 1;
 		}
 
-		if (o1.getClass() == o2.getClass() && o1 instanceof Comparable o1_2)
-			return o1_2.compareTo(o2);
+		if (eq(o1.getClass(), o2.getClass()) && o1 instanceof Comparable o1a)
+			return o1a.compareTo(o2);
 
 		return 0;
 	}
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/html/BasicHtmlDocTemplate.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/html/BasicHtmlDocTemplate.java
index 997c566616..949046de39 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/html/BasicHtmlDocTemplate.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/html/BasicHtmlDocTemplate.java
@@ -20,6 +20,9 @@ import static org.apache.juneau.common.utils.CollectionUtils.*;
 import static org.apache.juneau.common.utils.Utils.*;
 import static org.apache.juneau.html.AsideFloat.*;
 
+import java.util.Collection;
+import java.util.Map;
+
 import org.apache.juneau.common.collections.*;
 import org.apache.juneau.common.utils.*;
 
@@ -40,6 +43,18 @@ public class BasicHtmlDocTemplate implements HtmlDocTemplate {
 		return nn(s) && ! "NONE".equals(s);
 	}
 
+	private static boolean isEmptyObject(Object o) {
+		if (o == null)
+			return true;
+		if (o instanceof Collection<?> o2)
+			return o2.isEmpty();
+		if (o instanceof Map<?,?> o2)
+			return o2.isEmpty();
+		if (isArray(o))
+			return (java.lang.reflect.Array.getLength(o) == 0);
+		return o.toString().isEmpty();
+	}
+
 	@Override /* Overridden from HtmlDocTemplate */
 	public void writeTo(HtmlDocSerializerSession session, HtmlWriter w, Object o) throws Exception {
 		w.sTag("html").nl(0);
@@ -68,7 +83,7 @@ public class BasicHtmlDocTemplate implements HtmlDocTemplate {
 
 		if (o == null) {
 			w.append(6, "<null/>").nl(6);
-		} else if (isEmpty(o)) {
+		} else if (isEmptyObject(o)) {
 			String m = session.getNoResultsMessage();
 			if (exists(m))
 				w.append(6, session.resolve(m)).nl(6);
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 dbb5546eeb..6b6796e490 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
@@ -1353,14 +1353,6 @@ class StringUtils_Test extends TestBase {
 		assertTrue(isNotBlank("a"));
 	}
 
-	@Test
-	void a43_isEmpty() {
-		assertTrue(Utils.isEmpty((String)null));
-		assertTrue(Utils.isEmpty(""));
-		assertFalse(Utils.isEmpty("   "));
-		assertFalse(Utils.isEmpty("hello"));
-		assertFalse(Utils.isEmpty("a"));
-	}
 
 	@Test
 	void a44_hasText() {
diff --git a/juneau-utest/src/test/java/org/apache/juneau/common/utils/Utils_Test.java b/juneau-utest/src/test/java/org/apache/juneau/common/utils/Utils_Test.java
index 39ed92c678..042b7f925e 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/common/utils/Utils_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/common/utils/Utils_Test.java
@@ -16,34 +16,356 @@
  */
 package org.apache.juneau.common.utils;
 
+import static org.apache.juneau.common.utils.CollectionUtils.a;
 import static org.apache.juneau.common.utils.Utils.*;
 import static org.junit.jupiter.api.Assertions.*;
 
+import java.lang.annotation.*;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.*;
+
 import org.apache.juneau.*;
+import org.apache.juneau.common.collections.Value;
+import org.apache.juneau.common.function.Snippet;
 import org.junit.jupiter.api.*;
 
+@Retention(RetentionPolicy.RUNTIME)
+@interface TestAnnotation {
+	String value() default "";
+	int num() default 0;
+}
+
 class Utils_Test extends TestBase {
 
 	//====================================================================================================
-	// nn(Object)
+	// b(Object)
 	//====================================================================================================
 	@Test
-	void a01_nn_single() {
-		assertTrue(nn("test"));
-		assertTrue(nn(123));
-		assertTrue(nn(new Object()));
-		assertTrue(nn(""));
-		assertTrue(nn(0));
-		assertTrue(nn(false));
+	void a01_b() {
+		assertTrue(b(true));
+		assertTrue(b("true"));
+		assertTrue(b("TRUE"));
+		assertFalse(b(false));
+		assertFalse(b("false"));
+		assertFalse(b("FALSE"));
+		assertFalse(b(null));
+		assertFalse(b(""));
+		assertFalse(b(123));
+		assertFalse(b(new Object()));
+	}
 
-		assertFalse(nn(null));
+	//====================================================================================================
+	// cast(Class<T>, Object)
+	//====================================================================================================
+	@Test
+	void a02_cast() {
+		var obj = "Hello";
+		assertEquals("Hello", cast(String.class, obj));
+		assertNull(cast(Integer.class, obj));
+		assertNull(cast(String.class, null));
+		assertEquals(123, cast(Integer.class, 123));
+		assertNull(cast(String.class, 123));
+	}
+
+	//====================================================================================================
+	// castOrNull(Object, Class<T>)
+	//====================================================================================================
+	@Test
+	void a03_castOrNull() {
+		var obj = "Hello";
+		assertEquals("Hello", castOrNull(obj, String.class));
+		assertNull(castOrNull(obj, Integer.class));
+		assertNull(castOrNull(null, String.class));
+		assertEquals(123, castOrNull(123, Integer.class));
+		assertNull(castOrNull(123, String.class));
+	}
+
+	//====================================================================================================
+	// cn(Object)
+	//====================================================================================================
+	@Test
+	void a04_cn() {
+		assertEquals("java.lang.String", cn(String.class));
+		assertEquals("java.util.HashMap", cn(new HashMap<>()));
+		assertEquals("java.util.Map$Entry", cn(Map.Entry.class));
+		assertEquals("int", cn(int.class));
+		assertEquals("boolean", cn(boolean.class));
+		assertEquals("[Ljava.lang.String;", cn(String[].class));
+		assertEquals("[I", cn(int[].class));
+		assertNull(cn(null));
+	}
+
+	//====================================================================================================
+	// cns(Object)
+	//====================================================================================================
+	@Test
+	void a05_cns() {
+		assertEquals("String", cns(String.class));
+		assertEquals("HashMap", cns(new HashMap<>()));
+		assertEquals("Entry", cns(Map.Entry.class));
+		assertEquals("int", cns(int.class));
+		assertEquals("boolean", cns(boolean.class));
+		assertEquals("String[]", cns(String[].class));
+		assertEquals("int[]", cns(int[].class));
+		assertNull(cns(null));
+	}
+
+	//====================================================================================================
+	// cnsq(Object)
+	//====================================================================================================
+	@Test
+	void a06_cnsq() {
+		assertEquals("String", cnsq(String.class));
+		assertEquals("HashMap", cnsq(new HashMap<>()));
+		assertEquals("Map.Entry", cnsq(Map.Entry.class));
+		assertEquals("int", cnsq(int.class));
+		assertEquals("boolean", cnsq(boolean.class));
+		assertEquals("String[]", cnsq(String[].class));
+		assertEquals("int[]", cnsq(int[].class));
+		assertNull(cnsq(null));
+	}
+
+	//====================================================================================================
+	// compare(Object, Object)
+	//====================================================================================================
+	@Test
+	void a07_compare() {
+		assertTrue(compare("apple", "banana") < 0);
+		assertTrue(compare("banana", "apple") > 0);
+		assertEquals(0, compare("apple", "apple"));
+		assertEquals(0, compare(null, null));
+		assertTrue(compare(null, "apple") < 0);
+		assertTrue(compare("apple", null) > 0);
+		assertTrue(compare(5, 10) < 0);
+		assertTrue(compare(10, 5) > 0);
+		assertEquals(0, compare(5, 5));
+		assertEquals(0, compare("apple", 5)); // Different types, cannot compare
+
+		// Test line 285 branch: same class but not Comparable
+		class NotComparable {}
+		var nc1 = new NotComparable();
+		var nc2 = new NotComparable();
+		assertEquals(0, compare(nc1, nc2)); // Same class, but not Comparable - covers missing branch
+	}
+
+	//====================================================================================================
+	// ea(Class<T>)
+	//====================================================================================================
+	@Test
+	void a08_ea() {
+		var empty1 = ea(String.class);
+		assertEquals(0, empty1.length);
+		var empty2 = ea(Integer.class);
+		assertEquals(0, empty2.length);
+		var empty3 = ea(List.class);
+		assertEquals(0, empty3.length);
+	}
+
+	//====================================================================================================
+	// emptyIfNull(Object)
+	//====================================================================================================
+	@Test
+	void a09_emptyIfNull() {
+		assertEquals("Hello", emptyIfNull("Hello"));
+		assertEquals("123", emptyIfNull(123));
+		assertEquals("", emptyIfNull(null));
+	}
+
+	//====================================================================================================
+	// env(String)
+	//====================================================================================================
+	@Test
+	void a10_env() {
+		// Test with system property
+		System.setProperty("test.property", "testValue");
+		var result = env("test.property");
+		assertTrue(result.isPresent());
+		assertEquals("testValue", result.get());
+		System.clearProperty("test.property");
+
+		// Test with non-existent property
+		var missing = env("nonexistent.property.xyz");
+		assertFalse(missing.isPresent());
+	}
+
+	//====================================================================================================
+	// env(String, T)
+	//====================================================================================================
+	@Test
+	void a11_env_withDefault() {
+		// Test with system property - covers toType line 1489-1490 (String)
+		System.setProperty("test.property2", "testValue2");
+		var result = env("test.property2", "default");
+		assertEquals("testValue2", result);
+		System.clearProperty("test.property2");
+
+		// Test with default value
+		var defaultValue = env("nonexistent.property.xyz2", "default");
+		assertEquals("default", defaultValue);
+
+		// Test with Boolean type - covers toType line 1493-1496 (ENV_FUNCTIONS)
+		System.setProperty("test.boolean", "true");
+		var boolResult = env("test.boolean", false);
+		assertTrue(boolResult);
+		System.clearProperty("test.boolean");
+
+		// Test with Enum type - covers toType line 1491-1492 (Enum)
+		enum TestEnum { VALUE1, VALUE2 }
+		System.setProperty("test.enum", "VALUE1");
+		var enumResult = env("test.enum", TestEnum.VALUE2);
+		assertEquals(TestEnum.VALUE1, enumResult);
+		System.clearProperty("test.enum");
+
+		// Test null default - covers toType line 1486-1487 (def == null)
+		var nullResult = env("nonexistent.property.null", (String)null);
+		assertNull(nullResult);
+
+		// Test null string - covers toType line 1486-1487 (s == null, def != null)
+		// Use reflection to call private toType method directly
+		try {
+			var toTypeMethod = Utils.class.getDeclaredMethod("toType", String.class, Object.class);
+			toTypeMethod.setAccessible(true);
+			var nullStringResult = (String)toTypeMethod.invoke(null, (String)null, "default");
+			assertNull(nullStringResult);
+		} catch (Exception e) {
+			fail("Failed to test toType with null string: " + e.getMessage());
+		}
+
+		// Test both null - covers toType line 1486-1487 (s == null && def == null)
+		// Use reflection to call private toType method directly
+		try {
+			var toTypeMethod = Utils.class.getDeclaredMethod("toType", String.class, Object.class);
+			toTypeMethod.setAccessible(true);
+			var bothNullResult = (String)toTypeMethod.invoke(null, (String)null, (String)null);
+			assertNull(bothNullResult);
+		} catch (Exception e) {
+			fail("Failed to test toType with both null: " + e.getMessage());
+		}
+
+		// Test invalid type - covers toType line 1494-1495 (exception)
+		// Note: Charset doesn't work because def.getClass() returns concrete implementation class
+		System.setProperty("test.invalid", "value");
+		assertThrows(RuntimeException.class, () -> env("test.invalid", 123)); // Integer not in ENV_FUNCTIONS
+		System.clearProperty("test.invalid");
+	}
+
+	//====================================================================================================
+	// eq(boolean, String, String)
+	//====================================================================================================
+	@Test
+	void a12_eq_caseSensitive() {
+		assertTrue(eq(false, "Hello", "Hello"));
+		assertFalse(eq(false, "Hello", "hello"));
+		assertTrue(eq(false, null, null));
+		assertFalse(eq(false, "Hello", null));
+		assertFalse(eq(false, null, "Hello"));
+		assertTrue(eq(true, "Hello", "hello"));
+		assertTrue(eq(true, "Hello", "HELLO"));
+		assertTrue(eq(true, null, null));
+	}
+
+	//====================================================================================================
+	// eq(T, T)
+	//====================================================================================================
+	@Test
+	void a13_eq() {
+		assertTrue(eq("Hello", "Hello"));
+		assertFalse(eq("Hello", "World"));
+		assertTrue(eq(null, null));
+		assertFalse(eq("Hello", null));
+		assertFalse(eq(null, "Hello"));
+		assertTrue(eq(123, 123));
+		assertFalse(eq(123, 456));
+
+		// Test arrays - covers line 456
+		var arr1 = a(1, 2, 3);
+		var arr2 = a(1, 2, 3);
+		var arr3 = a(1, 2, 4);
+		var arr4 = a(1, 2);  // Different length
+		// Test line 456: both are arrays
+		assertTrue(eq(arr1, arr2));  // Both arrays, same content
+		assertFalse(eq(arr1, arr3));  // Both arrays, different content
+		assertFalse(eq(arr1, arr4));  // Different lengths - covers line 459
+		// Test line 456 branch: one is array, other is not
+		assertFalse(eq(arr1, "not an array"));  // o1 is Array, o2 is not
+		assertFalse(eq("not an array", arr1));  // o1 is not, o2 is Array
+
+		// Test annotations - use actual annotation instances from classes
+		@TestAnnotation("test")
+		class T1 {}
+		@TestAnnotation("test")
+		class T2 {}
+		@TestAnnotation("different")
+		class T3 {}
+
+		var a1 = T1.class.getAnnotation(TestAnnotation.class);
+		var a2 = T2.class.getAnnotation(TestAnnotation.class);
+		var a3 = T3.class.getAnnotation(TestAnnotation.class);
+		// Test annotation equality - covers line 453 (both are annotations)
+		assertTrue(eq(a1, a2));
+		assertFalse(eq(a1, a3));
+		// Test line 453 branch: one is annotation, other is not
+		assertFalse(eq(a1, "not an annotation"));  // o1 is Annotation, o2 is not
+		assertFalse(eq("not an annotation", a1));  // o1 is not, o2 is Annotation
+	}
+
+	//====================================================================================================
+	// eq(T, U, BiPredicate<T,U>)
+	//====================================================================================================
+	@Test
+	void a14_eq_withPredicate() {
+		class Role {
+			int id;
+			String name;
+			Role(int id, String name) { this.id = id; this.name = name; }
+		}
+
+		var r1 = new Role(1, "admin");
+		var r2 = new Role(1, "admin");
+		var r3 = new Role(2, "user");
+
+		assertTrue(eq(r1, r2, (x, y) -> x.id == y.id && x.name.equals(y.name)));
+		assertFalse(eq(r1, r3, (x, y) -> x.id == y.id && x.name.equals(y.name)));
+		assertTrue(eq(null, null, (x, y) -> false));
+		assertFalse(eq(r1, null, (x, y) -> true));
+		assertFalse(eq(null, r2, (x, y) -> true));
+		assertTrue(eq(r1, r1, (x, y) -> false)); // Same reference
+	}
+
+	//====================================================================================================
+	// eqic(Object, Object)
+	//====================================================================================================
+	@Test
+	void a15_eqic_object() {
+		assertTrue(eqic("Hello", "Hello"));
+		assertTrue(eqic("Hello", "hello"));
+		assertTrue(eqic("Hello", "HELLO"));
+		assertTrue(eqic(null, null));
+		assertFalse(eqic("Hello", null));
+		assertFalse(eqic(null, "Hello"));
+		assertTrue(eqic(123, 123));
+		assertFalse(eqic(123, 456));
+	}
+
+	//====================================================================================================
+	// eqic(String, String)
+	//====================================================================================================
+	@Test
+	void a16_eqic_string() {
+		assertTrue(eqic("Hello", "Hello"));
+		assertTrue(eqic("Hello", "hello"));
+		assertTrue(eqic("Hello", "HELLO"));
+		assertTrue(eqic(null, null));
+		assertFalse(eqic("Hello", null));
+		assertFalse(eqic(null, "Hello"));
 	}
 
 	//====================================================================================================
 	// f(String, Object...)
 	//====================================================================================================
 	@Test
-	void a02_f() {
+	void a17_f() {
 		// Basic formatting
 		assertEquals("Hello John, you have 5 items", f("Hello %s, you have %d items", "John", 5));
 		assertEquals("Hello world", f("Hello %s", "world"));
@@ -60,13 +382,33 @@ class Utils_Test extends TestBase {
 		assertEquals("Value: null", f("Value: %s", (String)null));
 		assertThrows(IllegalArgumentException.class, ()->f(null, "test"));
 		assertEquals("test", f("test"));
+
+		// MessageFormat style
+		assertEquals("Hello John, you have 5 items", f("Hello {0}, you have {1} items", "John", 5));
+	}
+
+	//====================================================================================================
+	// firstNonNull(T...)
+	//====================================================================================================
+	@Test
+	void a18_firstNonNull() {
+		assertEquals("Hello", firstNonNull(null, null, "Hello", "World"));
+		assertEquals("Hello", firstNonNull("Hello", "World"));
+		assertNull(firstNonNull(null, null));
+		assertNull(firstNonNull());
+		assertEquals(123, firstNonNull(null, null, 123, 456));
+
+		// Test line 614 branch: null array (varargs array itself is null)
+		// This can happen if called with explicit null cast
+		String[] nullArray = null;
+		assertNull(firstNonNull(nullArray));  // Covers the nn(t) == false branch
 	}
 
 	//====================================================================================================
 	// fs(String, Object...)
 	//====================================================================================================
 	@Test
-	void a03_fs() {
+	void a19_fs() {
 		// Basic supplier
 		var supplier = fs("Hello %s, you have %d items", "John", 5);
 		assertNotNull(supplier);
@@ -89,5 +431,555 @@ class Utils_Test extends TestBase {
 		var emptySupplier = fs("");
 		assertEquals("", emptySupplier.get());
 	}
-}
 
+	//====================================================================================================
+	// hash(Object...)
+	//====================================================================================================
+	@Test
+	void a20_hash() {
+		var hash1 = hash("Hello", 123, true);
+		var hash2 = hash("Hello", 123, true);
+		assertEquals(hash1, hash2);
+
+		var hash3 = hash("Hello", 123, false);
+		assertNotEquals(hash1, hash3);
+
+		// Test with annotations
+		@TestAnnotation("test")
+		class T {}
+		var a1 = T.class.getAnnotation(TestAnnotation.class);
+		var hash4 = hash(a1, "value");
+		assertNotNull(hash4);
+	}
+
+	//====================================================================================================
+	// identity(Object)
+	//====================================================================================================
+	@Test
+	void a21_identity() {
+		var obj = "test";
+		var identity = identity(obj);
+		assertNotNull(identity);
+		assertTrue(identity.contains("String"));
+		assertTrue(identity.contains("@"));
+		assertNull(identity(null));
+		assertNotNull(identity(Optional.of("test")));
+	}
+
+	//====================================================================================================
+	// isArray(Object)
+	//====================================================================================================
+	@Test
+	void a22_isArray() {
+		assertTrue(isArray(new int[]{1, 2, 3}));
+		assertTrue(isArray(a("a", "b")));
+		assertTrue(isArray(a()));
+		assertFalse(isArray("Hello"));
+		assertFalse(isArray(null));
+		assertFalse(isArray(123));
+		assertFalse(isArray(new ArrayList<>()));
+	}
+
+	//====================================================================================================
+	// isBetween(int, int, int)
+	//====================================================================================================
+	@Test
+	void a23_isBetween() {
+		assertTrue(isBetween(5, 1, 10));
+		assertTrue(isBetween(1, 1, 10));
+		assertTrue(isBetween(10, 1, 10));
+		assertFalse(isBetween(0, 1, 10));
+		assertFalse(isBetween(11, 1, 10));
+	}
+
+	//====================================================================================================
+	// isEmpty(CharSequence)
+	//====================================================================================================
+	@Test
+	void a24_isEmpty_CharSequence() {
+		assertTrue(isEmpty((String)null));
+		assertTrue(isEmpty(""));
+		assertFalse(isEmpty("   "));
+		assertFalse(isEmpty("hello"));
+		assertFalse(isEmpty("a"));
+	}
+
+	//====================================================================================================
+	// isEmpty(Collection<?>)
+	//====================================================================================================
+	@Test
+	void a25_isEmpty_Collection() {
+		assertTrue(isEmpty((Collection<?>)null));
+		assertTrue(isEmpty(Collections.emptyList()));
+		assertTrue(isEmpty(new ArrayList<>()));
+		assertFalse(isEmpty(Arrays.asList(1, 2, 3)));
+		assertFalse(isEmpty(Collections.singletonList("test")));
+	}
+
+	//====================================================================================================
+	// isEmpty(Map<?,?>)
+	//====================================================================================================
+	@Test
+	void a26_isEmpty_Map() {
+		assertTrue(isEmpty((Map<?,?>)null));
+		assertTrue(isEmpty(Collections.emptyMap()));
+		assertTrue(isEmpty(new HashMap<>()));
+		assertFalse(isEmpty(Map.of("key", "value")));
+		assertFalse(isEmpty(Collections.singletonMap("key", "value")));
+	}
+
+	@Test
+	void a27_isEmpty_Object() {
+		assertTrue(isEmpty((Object)null));
+		assertTrue(isEmpty((Object)""));
+		// Test line 835: Collection branch
+		assertTrue(isEmpty((Object)Collections.emptyList()));
+		assertFalse(isEmpty((Object)Arrays.asList(1, 2)));  // Non-empty collection
+		// Test line 837: Map branch
+		assertTrue(isEmpty((Object)Collections.emptyMap()));
+		assertFalse(isEmpty((Object)Map.of("key", "value")));  // Non-empty map
+		assertTrue(isEmpty(new int[0]));
+		assertTrue(isEmpty(new String[0]));
+		assertFalse(isEmpty((Object)"hello"));
+		assertFalse(isEmpty(a(1, 2)));
+		assertTrue(isEmpty(new Object() {
+			@Override public String toString() { return ""; }
+		}));
+	}
+
+	//====================================================================================================
+	// isNotEmpty(CharSequence)
+	//====================================================================================================
+	@Test
+	void a28_isNotEmpty_CharSequence() {
+		assertFalse(isNotEmpty((String)null));
+		assertFalse(isNotEmpty(""));
+		assertTrue(isNotEmpty("   "));
+		assertTrue(isNotEmpty("hello"));
+		assertTrue(isNotEmpty("a"));
+	}
+
+	//====================================================================================================
+	// isNotEmpty(Collection<?>)
+	//====================================================================================================
+	@Test
+	void a29_isNotEmpty_Collection() {
+		assertFalse(isNotEmpty((Collection<?>)null));
+		assertFalse(isNotEmpty(Collections.emptyList()));
+		assertFalse(isNotEmpty(new ArrayList<>()));
+		assertTrue(isNotEmpty(Arrays.asList(1, 2, 3)));
+		assertTrue(isNotEmpty(Collections.singletonList("test")));
+	}
+
+	//====================================================================================================
+	// isNotEmpty(Map<?,?>)
+	//====================================================================================================
+	@Test
+	void a30_isNotEmpty_Map() {
+		assertFalse(isNotEmpty((Map<?,?>)null));
+		assertFalse(isNotEmpty(Collections.emptyMap()));
+		assertFalse(isNotEmpty(new HashMap<>()));
+		assertTrue(isNotEmpty(Map.of("key", "value")));
+		assertTrue(isNotEmpty(Collections.singletonMap("key", "value")));
+	}
+
+	//====================================================================================================
+	// isNotEmpty(Object)
+	//====================================================================================================
+	@Test
+	void a31_isNotEmpty_Object() {
+		assertFalse(isNotEmpty((Object)null));
+		// Test line 940: CharSequence branch
+		assertFalse(isNotEmpty((Object)""));
+		assertTrue(isNotEmpty((Object)"hello"));  // Non-empty CharSequence
+		// Test line 942: Collection branch
+		assertFalse(isNotEmpty((Object)Collections.emptyList()));
+		assertTrue(isNotEmpty((Object)Arrays.asList(1, 2)));  // Non-empty collection
+		// Test line 944: Map branch
+		assertFalse(isNotEmpty((Object)Collections.emptyMap()));
+		assertTrue(isNotEmpty((Object)Map.of("key", "value")));  // Non-empty map
+		assertFalse(isNotEmpty(new int[0]));
+		assertFalse(isNotEmpty(new String[0]));
+		assertTrue(isNotEmpty(a(1, 2)));
+		// Test line 947: fallback case (non-String, non-Collection, non-Map, non-Array)
+		assertTrue(isNotEmpty(new Object() {
+			@Override public String toString() { return "test"; }
+		}));
+		assertFalse(isNotEmpty(new Object() {
+			@Override public String toString() { return ""; }
+		}));
+	}
+
+	//====================================================================================================
+	// isNotMinusOne(T)
+	//====================================================================================================
+	@Test
+	void a32_isNotMinusOne() {
+		assertTrue(isNotMinusOne(5));
+		assertTrue(isNotMinusOne(0));
+		assertTrue(isNotMinusOne(100));
+		assertFalse(isNotMinusOne(-1));
+		assertFalse(isNotMinusOne((Integer)null));
+		assertTrue(isNotMinusOne(5L));
+		assertFalse(isNotMinusOne(-1L));
+	}
+
+	//====================================================================================================
+	// isNotNull(T)
+	//====================================================================================================
+	@Test
+	void a33_isNotNull() {
+		assertTrue(isNotNull("Hello"));
+		assertTrue(isNotNull(123));
+		assertTrue(isNotNull(new Object()));
+		assertFalse(isNotNull(null));
+	}
+
+	//====================================================================================================
+	// isTrue(Boolean)
+	//====================================================================================================
+	@Test
+	void a34_isTrue() {
+		assertTrue(isTrue(true));
+		assertFalse(isTrue(false));
+		assertFalse(isTrue(null));
+	}
+
+	//====================================================================================================
+	// lc(String)
+	//====================================================================================================
+	@Test
+	void a35_lc() {
+		assertEquals("hello", lc("Hello"));
+		assertEquals("hello", lc("HELLO"));
+		assertEquals("hello world", lc("Hello World"));
+		assertNull(lc(null));
+		assertEquals("", lc(""));
+	}
+
+	//====================================================================================================
+	// memoize(Supplier<T>)
+	//====================================================================================================
+	@Test
+	void a36_memoize() {
+		var callCount = new AtomicInteger(0);
+		var supplier = memoize(() -> {
+			callCount.incrementAndGet();
+			return "result";
+		});
+
+		var result1 = supplier.get();
+		var result2 = supplier.get();
+		var result3 = supplier.get();
+
+		assertEquals("result", result1);
+		assertEquals("result", result2);
+		assertEquals("result", result3);
+		assertEquals(1, callCount.get()); // Should only be called once
+	}
+
+	//====================================================================================================
+	// memoizeResettable(Supplier<T>)
+	//====================================================================================================
+	@Test
+	void a37_memoizeResettable() {
+		var callCount = new AtomicInteger(0);
+		var supplier = memoizeResettable(() -> {
+			callCount.incrementAndGet();
+			return "result";
+		});
+
+		var result1 = supplier.get();
+		var result2 = supplier.get();
+		assertEquals(1, callCount.get());
+
+		supplier.reset();
+		var result3 = supplier.get();
+		assertEquals(2, callCount.get());
+
+		assertEquals("result", result1);
+		assertEquals("result", result2);
+		assertEquals("result", result3);
+	}
+
+	//====================================================================================================
+	// n(Class<T>)
+	//====================================================================================================
+	@Test
+	void a38_n() {
+		assertNull(n(String.class));
+		assertNull(n(Integer.class));
+		assertNull(n(List.class));
+	}
+
+	//====================================================================================================
+	// ne(T, T)
+	//====================================================================================================
+	@Test
+	void a39_ne() {
+		assertTrue(ne("Hello", "World"));
+		assertFalse(ne("Hello", "Hello"));
+		assertFalse(ne(null, null));
+		assertTrue(ne("Hello", null));
+		assertTrue(ne(null, "Hello"));
+		assertTrue(ne(123, 456));
+		assertFalse(ne(123, 123));
+	}
+
+	//====================================================================================================
+	// ne(T, U, BiPredicate<T,U>)
+	//====================================================================================================
+	@Test
+	void a40_ne_withPredicate() {
+		class Role {
+			int id;
+			String name;
+			Role(int id, String name) { this.id = id; this.name = name; }
+		}
+
+		var r1 = new Role(1, "admin");
+		var r2 = new Role(1, "admin");
+		var r3 = new Role(2, "user");
+
+		assertFalse(ne(r1, r2, (x, y) -> x.id == y.id && x.name.equals(y.name)));
+		assertTrue(ne(r1, r3, (x, y) -> x.id == y.id && x.name.equals(y.name)));
+		assertFalse(ne(null, null, (x, y) -> true));
+		assertTrue(ne(r1, null, (x, y) -> false));
+		assertTrue(ne(null, r2, (x, y) -> false));
+		assertFalse(ne(r1, r1, (x, y) -> true)); // Same reference
+	}
+
+	//====================================================================================================
+	// neic(String, String)
+	//====================================================================================================
+	@Test
+	void a41_neic() {
+		assertTrue(neic("Hello", "World"));
+		assertFalse(neic("Hello", "hello"));
+		assertFalse(neic("Hello", "HELLO"));
+		assertFalse(neic(null, null));
+		assertTrue(neic("Hello", null));
+		assertTrue(neic(null, "Hello"));
+	}
+
+	//====================================================================================================
+	// nn(Object)
+	//====================================================================================================
+	@Test
+	void a42_nn() {
+		assertTrue(nn("test"));
+		assertTrue(nn(123));
+		assertTrue(nn(new Object()));
+		assertTrue(nn(""));
+		assertTrue(nn(0));
+		assertTrue(nn(false));
+		assertFalse(nn(null));
+	}
+
+	//====================================================================================================
+	// opt(T)
+	//====================================================================================================
+	@Test
+	void a43_opt() {
+		var opt1 = opt("Hello");
+		assertTrue(opt1.isPresent());
+		assertEquals("Hello", opt1.get());
+
+		var opt2 = opt(null);
+		assertFalse(opt2.isPresent());
+	}
+
+	//====================================================================================================
+	// opte()
+	//====================================================================================================
+	@Test
+	void a44_opte() {
+		var empty = opte();
+		assertFalse(empty.isPresent());
+	}
+
+	//====================================================================================================
+	// printLines(String[])
+	//====================================================================================================
+	@Test
+	void a45_printLines() {
+		// This test just verifies the method doesn't throw
+		printLines(a("Line 1", "Line 2", "Line 3"));
+		printLines(a());
+	}
+
+	//====================================================================================================
+	// r(Object)
+	//====================================================================================================
+	@Test
+	void a46_r() {
+		assertEquals("hello", r("hello"));
+		assertEquals("123", r(123));
+		assertEquals("[1,2,3]", r(Arrays.asList(1, 2, 3)));
+		assertNull(r(null));
+		var bytes = new byte[]{1, 2};
+		assertEquals("0102", r(bytes));
+	}
+
+	//====================================================================================================
+	// s(Object)
+	//====================================================================================================
+	@Test
+	void a47_s() {
+		assertEquals("Hello", s("Hello"));
+		assertEquals("123", s(123));
+		assertEquals("true", s(true));
+		assertNull(s(null));
+	}
+
+	//====================================================================================================
+	// safe(Snippet)
+	//====================================================================================================
+	@Test
+	void a48_safe_Snippet() {
+		// Test normal execution - covers line 1371
+		AtomicInteger count = new AtomicInteger(0);
+		safe((Snippet)() -> {
+			count.incrementAndGet();
+		});
+		assertEquals(1, count.get());
+
+		// Test RuntimeException is rethrown - covers lines 1372-1373
+		var re = assertThrows(RuntimeException.class, () -> safe((Snippet)() -> {
+			throw new RuntimeException("test");
+		}));
+		assertEquals("test", re.getMessage());
+
+		// Test checked exception is wrapped - covers lines 1374-1375
+		var wrapped = assertThrows(RuntimeException.class, () -> safe((Snippet)() -> {
+			throw new Exception("test");
+		}));
+		assertNotNull(wrapped.getCause());
+		assertEquals(Exception.class, wrapped.getCause().getClass());
+		assertEquals("test", wrapped.getCause().getMessage());
+
+		// Test Error is wrapped - covers lines 1374-1375 with Error
+		var wrappedError = assertThrows(RuntimeException.class, () -> safe((Snippet)() -> {
+			throw new Error("test error");
+		}));
+		assertNotNull(wrappedError.getCause());
+		assertEquals(Error.class, wrappedError.getCause().getClass());
+		assertEquals("test error", wrappedError.getCause().getMessage());
+	}
+
+	//====================================================================================================
+	// safe(ThrowingSupplier<T>)
+	//====================================================================================================
+	@Test
+	void a49_safe_ThrowingSupplier() {
+		// Test normal execution
+		var result = safe(() -> "result");
+		assertEquals("result", result);
+
+		// Test RuntimeException is rethrown
+		assertThrows(RuntimeException.class, () -> safe(() -> {
+			throw new RuntimeException("test");
+		}));
+
+		// Test checked exception is wrapped
+		assertThrows(RuntimeException.class, () -> safe(() -> {
+			throw new Exception("test");
+		}));
+	}
+
+	//====================================================================================================
+	// safeSupplier(ThrowableUtils.SupplierWithThrowable<T>)
+	//====================================================================================================
+	@Test
+	void a50_safeSupplier() {
+		// Test normal execution
+		var result = safeSupplier(() -> "result");
+		assertEquals("result", result);
+
+		// Test RuntimeException is rethrown
+		assertThrows(RuntimeException.class, () -> safeSupplier(() -> {
+			throw new RuntimeException("test");
+		}));
+
+		// Test checked exception is wrapped
+		assertThrows(RuntimeException.class, () -> safeSupplier(() -> {
+			throw new Exception("test");
+		}));
+	}
+
+	//====================================================================================================
+	// sb(String)
+	//====================================================================================================
+	@Test
+	void a51_sb() {
+		var sb = sb("Hello");
+		assertNotNull(sb);
+		assertEquals("Hello", sb.toString());
+	}
+
+	//====================================================================================================
+	// ss(Supplier<?>)
+	//====================================================================================================
+	@Test
+	void a52_ss() {
+		var stringSupplier = ss(() -> "test");
+		assertEquals("test", stringSupplier.get());
+
+		var intSupplier = ss(() -> 123);
+		assertEquals("123", intSupplier.get());
+	}
+
+	//====================================================================================================
+	// uc(String)
+	//====================================================================================================
+	@Test
+	void a53_uc() {
+		assertEquals("HELLO", uc("Hello"));
+		assertEquals("HELLO", uc("hello"));
+		assertEquals("HELLO WORLD", uc("Hello World"));
+		assertNull(uc(null));
+		assertEquals("", uc(""));
+	}
+
+	//====================================================================================================
+	// unwrap(Object)
+	//====================================================================================================
+	@Test
+	void a54_unwrap() {
+		// Test with Supplier
+		Supplier<String> supplier = () -> "test";
+		assertEquals("test", unwrap(supplier));
+
+		// Test with Value
+		var value = Value.of("test");
+		assertEquals("test", unwrap(value));
+
+		// Test with Optional
+		var optional = Optional.of("test");
+		assertEquals("test", unwrap(optional));
+
+		// Test nested unwrapping
+		Supplier<Optional<String>> nested = () -> Optional.of("test");
+		assertEquals("test", unwrap(nested));
+
+		// Test regular object
+		assertEquals("test", unwrap("test"));
+		assertEquals(123, unwrap(123));
+	}
+
+	//====================================================================================================
+	// Utils() constructor
+	//====================================================================================================
+	@Test
+	void a55_Utils_constructor() {
+		// Test protected constructor - covers line 1500
+		// Create a subclass to access the protected constructor
+		class TestUtils extends Utils {
+			TestUtils() {
+				super(); // This calls the protected Utils() constructor
+			}
+		}
+		var testUtils = new TestUtils();
+		assertNotNull(testUtils);
+	}
+}