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 7a6cfe28ad Unit tests
7a6cfe28ad is described below
commit 7a6cfe28ad06436c37ca8482f2544177ead6b5aa
Author: James Bognar <[email protected]>
AuthorDate: Wed Dec 3 12:10:25 2025 -0800
Unit tests
---
.../juneau/commons/utils/CollectionUtils.java | 50 +-
.../juneau/commons/utils/CollectionUtils_Test.java | 1500 +++++++++++++++-----
2 files changed, 1185 insertions(+), 365 deletions(-)
diff --git
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/CollectionUtils.java
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/CollectionUtils.java
index 8b3b28c96b..acd8c58bd1 100644
---
a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/CollectionUtils.java
+++
b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/utils/CollectionUtils.java
@@ -374,8 +374,7 @@ public class CollectionUtils {
*/
@SuppressWarnings("unchecked")
public static <E> E[] array(Collection<E> value, Class<E>
componentType) {
- if (value == null)
- return null;
+ assertArgNotNull("value", value);
var array = (E[])Array.newInstance(componentType, value.size());
return value.toArray(array);
}
@@ -389,10 +388,7 @@ public class CollectionUtils {
* @throws IllegalArgumentException if the input is not an array.
*/
public static List<Object> arrayToList(Object array) {
- if (array == null) {
- return null; // NOSONAR
- }
-
+ assertArgNotNull("array", array);
assertArg(isArray(array), "Input must be an array but was {0}",
cn(array));
var componentType = array.getClass().getComponentType();
@@ -609,9 +605,7 @@ public class CollectionUtils {
* @return A new list with the same values as the specified list, but
with values transformed by the specified function. Null if the list being
copied was null.
*/
public static <E> List<E> copyOf(List<E> l, Function<? super E,?
extends E> valueMapper, Supplier<List<E>> listFactory) {
- if (l == null)
- return null; // NOSONAR - Intentional.
- return
l.stream().map(valueMapper).collect(toCollection(listFactory));
+ return l == null ? null :
l.stream().map(valueMapper).collect(toCollection(listFactory));
}
/**
@@ -650,9 +644,7 @@ public class CollectionUtils {
* @return A new map with the same keys as the specified map, but with
values transformed by the specified function. Null if the map being copied was
null.
*/
public static <K,V> Map<K,V> copyOf(Map<K,V> m, Function<? super V,?
extends V> valueMapper, Supplier<Map<K,V>> mapFactory) {
- if (m == null)
- return null; // NOSONAR - Intentional.
- return m.entrySet().stream().collect(toMap(Map.Entry::getKey, e
-> valueMapper.apply(e.getValue()), (a, b) -> b, mapFactory));
+ return m == null ? null :
m.entrySet().stream().collect(toMap(Map.Entry::getKey, e ->
valueMapper.apply(e.getValue()), (a, b) -> b, mapFactory));
}
/**
@@ -688,9 +680,7 @@ public class CollectionUtils {
* @return A new list with the same values as the specified list, but
with values transformed by the specified function. Null if the list being
copied was null.
*/
public static <E> Set<E> copyOf(Set<E> l, Function<? super E,? extends
E> valueMapper, Supplier<Set<E>> setFactory) {
- if (l == null)
- return null; // NOSONAR - Intentional.
- return
l.stream().map(valueMapper).collect(toCollection(setFactory));
+ return l == null ? null :
l.stream().map(valueMapper).collect(toCollection(setFactory));
}
/**
@@ -719,22 +709,6 @@ public class CollectionUtils {
return value;
}
- /**
- * Returns <jk>true</jk> if the following sorted arrays are equals.
- *
- * @param a1 Array #1.
- * @param a2 Array #2.
- * @return <jk>true</jk> if the following sorted arrays are equals.
- */
- public static boolean equals(String[] a1, String[] a2) {
- if (a1.length != a2.length)
- return false;
- for (var i = 0; i < a1.length; i++)
- if (ne(a1[i], a2[i]))
- return false;
- return true;
- }
-
/**
* Returns the first element in a list.
*
@@ -743,9 +717,7 @@ public class CollectionUtils {
* @return The first element in the list, or <jk>null</jk> if the list
is <jk>null</jk> or empty.
*/
public static <E> E first(List<E> l) {
- if (l == null || l.isEmpty())
- return null;
- return l.get(0);
+ return isEmpty(l) ? null : l.get(0);
}
/**
@@ -866,9 +838,7 @@ public class CollectionUtils {
* @return The last element, or <jk>null</jk> if the array is
<jk>null</jk> or empty.
*/
public static <E> E last(E[] l) {
- if (l == null || l.length == 0)
- return null;
- return l[l.length - 1];
+ return (l == null || l.length == 0) ? null : l[l.length - 1];
}
/**
@@ -879,9 +849,7 @@ public class CollectionUtils {
* @return The last element, or <jk>null</jk> if the list is
<jk>null</jk> or empty.
*/
public static <E> E last(List<E> l) {
- if (l == null || l.isEmpty())
- return null;
- return l.get(l.size() - 1);
+ return isEmpty(l) ? null : l.get(l.size() - 1);
}
/**
@@ -1930,7 +1898,7 @@ public class CollectionUtils {
* @return A new array.
*/
public static <E> Object toArray(Collection<?> c, Class<E> elementType)
{
- Object a = Array.newInstance(elementType, c.size());
+ var a = Array.newInstance(elementType, c.size());
Iterator<?> it = c.iterator();
int i = 0;
while (it.hasNext())
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/commons/utils/CollectionUtils_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/commons/utils/CollectionUtils_Test.java
index 32744ba4d3..1c9f35c140 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/commons/utils/CollectionUtils_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/commons/utils/CollectionUtils_Test.java
@@ -24,6 +24,7 @@ import static org.junit.jupiter.api.Assertions.*;
import java.util.*;
import org.apache.juneau.*;
+import org.apache.juneau.commons.collections.*;
import org.junit.jupiter.api.*;
class CollectionUtils_Test extends TestBase {
@@ -31,563 +32,1414 @@ class CollectionUtils_Test extends TestBase {
//====================================================================================================
// Constructor (line 126)
//====================================================================================================
- // Note: CollectionUtils has a private constructor, so it cannot be
instantiated.
- // Line 126 (class declaration) is covered by using the class's static
methods.
+ @Test
+ void a00_constructor() {
+ // Test line 126: class instantiation
+ // CollectionUtils has a private constructor, so it cannot be
instantiated.
+ // Line 126 (class declaration) is covered by using the class's
static methods.
+ }
//====================================================================================================
- // treeSet(Set)
+ // a(T...)
//====================================================================================================
@Test
- void a01_treeSet_fromSet() {
- LinkedHashSet<String> input = new LinkedHashSet<>(l("c", "a",
"b"));
- TreeSet<String> result = toSortedSet(input);
-
+ void a001_a() {
+ String[] result = a("a", "b", "c");
assertNotNull(result);
- assertEquals(l("a", "b", "c"), new ArrayList<>(result));
-
- // Null input
- assertNull(toSortedSet((Set<String>)null));
+ assertEquals(3, result.length);
+ assertEquals("a", result[0]);
+ assertEquals("b", result[1]);
+ assertEquals("c", result[2]);
+
+ // Empty array
+ String[] empty = a();
+ assertNotNull(empty);
+ assertEquals(0, empty.length);
}
+
//====================================================================================================
+ // a2(E[]...)
+
//====================================================================================================
@Test
- void a02_treeSet_fromSet_numbers() {
- LinkedHashSet<Integer> input = new LinkedHashSet<>(l(3, 1, 2));
- TreeSet<Integer> result = toSortedSet(input);
-
+ void a002_a2() {
+ String[][] result = a2(a("a", "b"), a("c", "d"));
assertNotNull(result);
- assertEquals(l(1, 2, 3), new ArrayList<>(result));
+ assertEquals(2, result.length);
+ assertEquals(2, result[0].length);
+ assertEquals("a", result[0][0]);
+ assertEquals("b", result[0][1]);
+ assertEquals("c", result[1][0]);
+ assertEquals("d", result[1][1]);
+
+ // Single row
+ String[][] single = a2(a("x", "y", "z"));
+ assertEquals(1, single.length);
+ assertEquals(3, single[0].length);
+
+ // Empty
+ String[][] empty = a2();
+ assertNotNull(empty);
+ assertEquals(0, empty.length);
}
//====================================================================================================
- // treeSet(T...)
+ // accumulate(Object)
//====================================================================================================
@Test
- void a03_treeSet_varargs() {
- TreeSet<String> result = sortedSet("c", "a", "b");
-
+ void a003_accumulate() {
+ List<String> list = list("a", "b", "c");
+ List<?> result = accumulate(list);
assertNotNull(result);
- assertEquals(l("a", "b", "c"), new ArrayList<>(result));
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertTrue(result.contains("c"));
}
+
//====================================================================================================
+ // addAll(List<E>, E...)
+
//====================================================================================================
@Test
- void a04_treeSet_varargs_empty() {
- TreeSet<String> result = sortedSet();
+ void a004_addAll_listVarargs() {
+ // Null value creates new list
+ var result1 = addAll((List<String>)null, "a", "b");
+ assertNotNull(result1);
+ assertEquals(list("a", "b"), result1);
+
+ // Existing list adds to it
+ var list = list("x");
+ var result2 = addAll(list, "a", "b");
+ assertSame(list, result2);
+ assertEquals(list("x", "a", "b"), result2);
+
+ // Null entries returns original
+ var list2 = list("a", "b");
+ var result3 = addAll(list2, (String[])null);
+ assertSame(list2, result3);
+ }
- assertNotNull(result);
- assertEmpty(result);
+
//====================================================================================================
+ // addAll(List<E>, List<E>)
+
//====================================================================================================
+ @Test
+ void a005_addAll_listToList() {
+ // Null entries returns original
+ var list = list("a", "b");
+ var result1 = addAll(list, (List<String>)null);
+ assertSame(list, result1);
+ assertEquals(list("a", "b"), result1);
+
+ // Null value creates copy
+ var entries = list("x", "y", "z");
+ var result2 = addAll(null, entries);
+ assertNotNull(result2);
+ assertEquals(list("x", "y", "z"), result2);
+ assertNotSame(entries, result2);
+
+ // Both not null adds to existing
+ var list2 = list("a", "b");
+ var entries2 = list("c", "d");
+ var result3 = addAll(list2, entries2);
+ assertSame(list2, result3);
+ assertEquals(list("a", "b", "c", "d"), result3);
}
+
//====================================================================================================
+ // addAll(Set<E>, E...)
+
//====================================================================================================
@Test
- void a05_treeSet_varargs_single() {
- TreeSet<String> result = sortedSet("a");
+ void a006_addAll_setVarargs() {
+ // Null entries returns original
+ var set = set("a", "b");
+ var result1 = addAll(set, (String[])null);
+ assertSame(set, result1);
+ assertEquals(set("a", "b"), result1);
+
+ // Null value creates new set
+ var result2 = addAll((Set<String>)null, "x", "y", "z");
+ assertNotNull(result2);
+ assertEquals(set("x", "y", "z"), result2);
+
+ // Both not null adds to existing
+ var set2 = set("a", "b");
+ var result3 = addAll(set2, "c", "d");
+ assertSame(set2, result3);
+ assertEquals(set("a", "b", "c", "d"), result3);
+ }
- assertNotNull(result);
- assertEquals(l("a"), new ArrayList<>(result));
+
//====================================================================================================
+ // addAll(SortedSet<E>, E...)
+
//====================================================================================================
+ @Test
+ void a007_addAll_sortedSetVarargs() {
+ // Null entries returns original
+ var set = sortedSet("a", "b");
+ var result1 = addAll(set, (String[])null);
+ assertSame(set, result1);
+ assertEquals(sortedSet("a", "b"), result1);
+
+ // Null value creates new sorted set
+ var result2 = addAll((SortedSet<String>)null, "x", "y", "z");
+ assertNotNull(result2);
+ assertEquals(sortedSet("x", "y", "z"), result2);
+
+ // Both not null adds to existing
+ var set2 = sortedSet("a", "b");
+ var result3 = addAll(set2, "c", "d");
+ assertSame(set2, result3);
+ assertEquals(sortedSet("a", "b", "c", "d"), result3);
}
+
//====================================================================================================
+ // addAll(T[], T...)
+
//====================================================================================================
@Test
- void a06_treeSet_varargs_numbers() {
- TreeSet<Integer> result = sortedSet(3, 1, 2, 5, 4);
+ void a008_addAll_array() {
+ String[] s = {};
+ s = addAll(s, "a", "b");
+ assertList(s, "a", "b");
+
+ s = addAll(s, "c");
+ assertList(s, "a", "b", "c");
+
+ s = addAll(s);
+ assertList(s, "a", "b", "c");
+
+ var o = addAll((Object[])null);
+ assertEmpty(o);
+
+ s = addAll((String[])null, "a", "b");
+ assertList(s, "a", "b");
+ }
+
//====================================================================================================
+ // ao(Object...)
+
//====================================================================================================
+ @Test
+ void a009_ao() {
+ Object[] result = ao("string", 42, true, 3.14, null);
assertNotNull(result);
- assertEquals(l(1, 2, 3, 4, 5), new ArrayList<>(result));
+ assertEquals(5, result.length);
+ assertEquals("string", result[0]);
+ assertEquals(42, result[1]);
+ assertEquals(true, result[2]);
+ assertEquals(3.14, result[3]);
+ assertNull(result[4]);
+
+ // Empty
+ Object[] empty = ao();
+ assertNotNull(empty);
+ assertEquals(0, empty.length);
}
//====================================================================================================
- // map(K,V,K,V,K,V,K,V)
+ // array(Class<E>, int)
//====================================================================================================
@Test
- void a07_map_4pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4);
-
+ void a010_array_classLength() {
+ String[] result = array(String.class, 5);
assertNotNull(result);
- assertSize(4, result);
- assertEquals(1, result.get("a"));
- assertEquals(2, result.get("b"));
- assertEquals(3, result.get("c"));
- assertEquals(4, result.get("d"));
-
- // Verify order (LinkedHashMap maintains insertion order)
- var keys = new ArrayList<>(result.keySet());
- assertEquals(l("a", "b", "c", "d"), keys);
+ assertEquals(5, result.length);
+ for (String s : result) {
+ assertNull(s);
+ }
}
//====================================================================================================
- // map(K,V,K,V,K,V,K,V,K,V)
+ // array(Collection<E>, Class<E>)
//====================================================================================================
@Test
- void a08_map_5pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5);
-
+ void a011_array_collection() {
+ List<String> list = list("a", "b", "c");
+ String[] result = array(list, String.class);
assertNotNull(result);
- assertSize(5, result);
- assertEquals(1, result.get("a"));
- assertEquals(2, result.get("b"));
- assertEquals(3, result.get("c"));
- assertEquals(4, result.get("d"));
- assertEquals(5, result.get("e"));
-
- // Verify order (LinkedHashMap maintains insertion order)
- var keys = new ArrayList<>(result.keySet());
- assertEquals(l("a", "b", "c", "d", "e"), keys);
+ assertEquals(3, result.length);
+ assertEquals("a", result[0]);
+ assertEquals("b", result[1]);
+ assertEquals("c", result[2]);
}
+
//====================================================================================================
+ // arrayToList(Object)
+
//====================================================================================================
@Test
- void a09_map_4pairs_nullValues() {
- LinkedHashMap<String, String> result = map("a", "val1", "b",
null, "c", "val3", "d", null);
-
+ void a012_arrayToList() {
+ String[] arr = {"a", "b", "c"};
+ List<Object> result = arrayToList(arr);
assertNotNull(result);
- assertSize(4, result);
- assertEquals("val1", result.get("a"));
- assertNull(result.get("b"));
- assertEquals("val3", result.get("c"));
- assertNull(result.get("d"));
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
+ assertEquals("b", result.get(1));
+ assertEquals("c", result.get(2));
+
+ // Primitive array
+ int[] intArr = {1, 2, 3};
+ List<Object> intResult = arrayToList(intArr);
+ assertEquals(3, intResult.size());
+ assertEquals(1, intResult.get(0));
+ assertEquals(2, intResult.get(1));
+ assertEquals(3, intResult.get(2));
}
+
//====================================================================================================
+ // booleans(boolean...)
+
//====================================================================================================
@Test
- void a10_map_5pairs_nullValues() {
- LinkedHashMap<String, String> result = map("a", "val1", "b",
null, "c", "val3", "d", null, "e", "val5");
-
+ void a013_booleans() {
+ boolean[] result = booleans(true, false, true);
assertNotNull(result);
- assertSize(5, result);
- assertEquals("val1", result.get("a"));
- assertNull(result.get("b"));
- assertEquals("val3", result.get("c"));
- assertNull(result.get("d"));
- assertEquals("val5", result.get("e"));
+ assertEquals(3, result.length);
+ assertTrue(result[0]);
+ assertFalse(result[1]);
+ assertTrue(result[2]);
}
//====================================================================================================
- // m() - unmodifiable maps
+ // bytes(int...)
//====================================================================================================
@Test
- void a11_m_empty() {
- Map<String, Integer> result = m();
-
+ void a014_bytes() {
+ byte[] result = bytes(1, 2, 3);
assertNotNull(result);
- assertEmpty(result);
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 1));
+ assertEquals(3, result.length);
+ assertEquals(1, result[0]);
+ assertEquals(2, result[1]);
+ assertEquals(3, result[2]);
}
+
//====================================================================================================
+ // chars(char...)
+
//====================================================================================================
@Test
- void a12_m_1pair() {
- Map<String, Integer> result = m("a", 1);
-
+ void a015_chars() {
+ char[] result = chars('a', 'b', 'c');
assertNotNull(result);
- assertSize(1, result);
- assertEquals(1, result.get("a"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 2));
+ assertEquals(3, result.length);
+ assertEquals('a', result[0]);
+ assertEquals('b', result[1]);
+ assertEquals('c', result[2]);
}
+
//====================================================================================================
+ // combine(E[]...)
+
//====================================================================================================
@Test
- void a13_m_2pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2);
+ void a016_combine() {
+ var s1 = a("a");
+ var s2 = a("b");
+
+ assertList(combine(s1, s2), "a", "b");
+ assertList(combine(s1), "a");
+ assertList(combine(s2), "b");
+ assertList(combine(s1, null), "a");
+ assertList(combine(null, s2), "b");
+ assertNull(combine(null, null));
+ assertNull(combine());
+ }
- assertNotNull(result);
- assertSize(2, result);
- assertEquals(1, result.get("a"));
- assertEquals(2, result.get("b"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 3));
+
//====================================================================================================
+ // contains(T, T[])
+
//====================================================================================================
+ @Test
+ void a017_contains() {
+ String[] arr = {"a", "b", "c"};
+ assertTrue(contains("a", arr));
+ assertTrue(contains("b", arr));
+ assertFalse(contains("d", arr));
+ assertFalse(contains(null, arr));
+ assertFalse(contains("a", null));
}
+
//====================================================================================================
+ // copyArrayToList(Object, List)
+
//====================================================================================================
@Test
- void a14_m_3pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3);
+ void a018_copyArrayToList() {
+ String[] arr = {"a", "b", "c"};
+ List<Object> list = new ArrayList<>();
+ List result = copyArrayToList(arr, list);
+ assertSame(list, result);
+ assertEquals(3, list.size());
+ assertEquals("a", list.get(0));
+ assertEquals("b", list.get(1));
+ assertEquals("c", list.get(2));
+
+ // Null array
+ List<Object> list2 = new ArrayList<>();
+ copyArrayToList(null, list2);
+ assertTrue(list2.isEmpty());
+ }
+
//====================================================================================================
+ // copyOf(Collection<E>)
+
//====================================================================================================
+ @Test
+ void a019_copyOf_collection() {
+ Collection<String> col = list("a", "b", "c");
+ Collection<String> result = copyOf(col);
assertNotNull(result);
- assertSize(3, result);
- assertEquals(1, result.get("a"));
- assertEquals(2, result.get("b"));
- assertEquals(3, result.get("c"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 4));
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertTrue(result.contains("c"));
+ assertNotSame(col, result);
+
+ assertNull(copyOf((Collection<String>)null));
}
+
//====================================================================================================
+ // copyOf(List<E>)
+
//====================================================================================================
@Test
- void a15_m_4pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4);
+ void a020_copyOf_list() {
+ List<String> list = list("a", "b", "c");
+ ArrayList<String> result = copyOf(list);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
+ assertEquals("b", result.get(1));
+ assertEquals("c", result.get(2));
+ assertNotSame(list, result);
+
+ assertNull(copyOf((List<String>)null));
+ }
+
//====================================================================================================
+ // copyOf(List<E>, Function)
+
//====================================================================================================
+ @Test
+ void a021_copyOf_listFunction() {
+ List<String> list = list("a", "b", "c");
+ List<String> result = copyOf(list, s -> s.toUpperCase());
assertNotNull(result);
- assertSize(4, result);
- assertEquals(1, result.get("a"));
- assertEquals(2, result.get("b"));
- assertEquals(3, result.get("c"));
- assertEquals(4, result.get("d"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 5));
+ assertEquals(3, result.size());
+ assertEquals("A", result.get(0));
+ assertEquals("B", result.get(1));
+ assertEquals("C", result.get(2));
+
+ assertNull(copyOf((List<String>)null, s -> s));
}
+
//====================================================================================================
+ // copyOf(List<E>, Function, Supplier)
+
//====================================================================================================
@Test
- void a16_m_5pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5);
+ void a022_copyOf_listFunctionSupplier() {
+ List<String> list = list("a", "b");
+ List<String> result = copyOf(list, s -> s.toUpperCase(),
LinkedList::new);
+ assertNotNull(result);
+ assertTrue(result instanceof LinkedList);
+ assertEquals(2, result.size());
+ assertEquals("A", result.get(0));
+ assertEquals("B", result.get(1));
+ }
+
//====================================================================================================
+ // copyOf(Map<K,V>)
+
//====================================================================================================
+ @Test
+ void a023_copyOf_map() {
+ Map<String, Integer> map = map("a", 1, "b", 2);
+ Map<String, Integer> result = copyOf(map);
assertNotNull(result);
- assertSize(5, result);
+ assertEquals(2, result.size());
assertEquals(1, result.get("a"));
assertEquals(2, result.get("b"));
- assertEquals(3, result.get("c"));
- assertEquals(4, result.get("d"));
- assertEquals(5, result.get("e"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 6));
+ assertNotSame(map, result);
+
+ assertNull(copyOf((Map<String, Integer>)null));
}
+
//====================================================================================================
+ // copyOf(Map<K,V>, Function)
+
//====================================================================================================
@Test
- void a17_m_mixedTypes() {
- Map<String, Object> result = m("name", "Alice", "age", 30,
"active", true);
-
+ void a024_copyOf_mapFunction() {
+ Map<String, Integer> map = map("a", 1, "b", 2);
+ Map<String, Integer> result = copyOf(map, v -> v * 2);
assertNotNull(result);
- assertSize(3, result);
- assertEquals("Alice", result.get("name"));
- assertEquals(30, result.get("age"));
- assertEquals(true, result.get("active"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", "y"));
+ assertEquals(2, result.size());
+ assertEquals(2, result.get("a"));
+ assertEquals(4, result.get("b"));
}
//====================================================================================================
- // map() and m() - 6 to 10 pairs
+ // copyOf(Map<K,V>, Function, Supplier)
//====================================================================================================
@Test
- void a18_map_6pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5, "f", 6);
+ void a025_copyOf_mapFunctionSupplier() {
+ Map<String, Integer> map = map("a", 1);
+ Map<String, Integer> result = copyOf(map, v -> v, TreeMap::new);
+ assertNotNull(result);
+ assertTrue(result instanceof TreeMap);
+ assertEquals(1, result.size());
+ }
+
//====================================================================================================
+ // copyOf(Set<E>)
+
//====================================================================================================
+ @Test
+ void a026_copyOf_set() {
+ Set<String> set = set("a", "b", "c");
+ Set<String> result = copyOf(set);
assertNotNull(result);
- assertSize(6, result);
- assertEquals(6, result.get("f"));
- assertEquals(l("a", "b", "c", "d", "e", "f"), new
ArrayList<>(result.keySet()));
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertNotSame(set, result);
+
+ assertNull(copyOf((Set<String>)null));
}
+
//====================================================================================================
+ // copyOf(Set<E>, Function)
+
//====================================================================================================
@Test
- void a19_map_7pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5, "f", 6, "g", 7);
+ void a027_copyOf_setFunction() {
+ Set<String> set = set("a", "b");
+ Set<String> result = copyOf(set, s -> s.toUpperCase());
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ assertTrue(result.contains("A"));
+ assertTrue(result.contains("B"));
+ }
+
//====================================================================================================
+ // copyOf(Set<E>, Function, Supplier)
+
//====================================================================================================
+ @Test
+ void a028_copyOf_setFunctionSupplier() {
+ Set<String> set = set("a", "b");
+ Set<String> result = copyOf(set, s -> s, TreeSet::new);
assertNotNull(result);
- assertSize(7, result);
- assertEquals(7, result.get("g"));
+ assertTrue(result instanceof TreeSet);
+ assertEquals(2, result.size());
}
+
//====================================================================================================
+ // copyOf(T[])
+
//====================================================================================================
@Test
- void a20_map_8pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8);
+ void a029_copyOf_array() {
+ String[] arr = {"a", "b", "c"};
+ String[] result = copyOf(arr);
+ assertNotNull(result);
+ assertEquals(3, result.length);
+ assertEquals("a", result[0]);
+ assertNotSame(arr, result);
+
+ assertNull(copyOf((String[])null));
+ }
+
//====================================================================================================
+ // doubles(double...)
+
//====================================================================================================
+ @Test
+ void a030_doubles() {
+ double[] result = doubles(1.0, 2.0, 3.0);
assertNotNull(result);
- assertSize(8, result);
- assertEquals(8, result.get("h"));
+ assertEquals(3, result.length);
+ assertEquals(1.0, result[0]);
+ assertEquals(2.0, result[1]);
+ assertEquals(3.0, result[2]);
}
+
//====================================================================================================
+ // first(List<E>)
+
//====================================================================================================
@Test
- void a21_map_9pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8, "i", 9);
+ void a031_first() {
+ List<String> list = list("a", "b", "c");
+ assertEquals("a", first(list));
+
+ assertNull(first(null));
+ assertNull(first(list()));
+ }
+
//====================================================================================================
+ // floats(float...)
+
//====================================================================================================
+ @Test
+ void a032_floats() {
+ float[] result = floats(1.0f, 2.0f, 3.0f);
assertNotNull(result);
- assertSize(9, result);
- assertEquals(9, result.get("i"));
+ assertEquals(3, result.length);
+ assertEquals(1.0f, result[0]);
+ assertEquals(2.0f, result[1]);
+ assertEquals(3.0f, result[2]);
}
+
//====================================================================================================
+ // forEachReverse(E[], Consumer)
+
//====================================================================================================
@Test
- void a22_map_10pairs() {
- LinkedHashMap<String, Integer> result = map("a", 1, "b", 2,
"c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8, "i", 9, "j", 10);
+ void a033_forEachReverse_array() {
+ String[] arr = {"a", "b", "c"};
+ List<String> result = new ArrayList<>();
+ forEachReverse(arr, result::add);
+ assertEquals(list("c", "b", "a"), result);
+ }
- assertNotNull(result);
- assertSize(10, result);
- assertEquals(10, result.get("j"));
- assertEquals(l("a", "b", "c", "d", "e", "f", "g", "h", "i",
"j"), new ArrayList<>(result.keySet()));
+
//====================================================================================================
+ // forEachReverse(List<E>, Consumer)
+
//====================================================================================================
+ @Test
+ void a034_forEachReverse_list() {
+ List<String> list = list("a", "b", "c");
+ List<String> result = new ArrayList<>();
+ forEachReverse(list, result::add);
+ assertEquals(list("c", "b", "a"), result);
}
+
//====================================================================================================
+ // indexOf(T, T[])
+
//====================================================================================================
@Test
- void a23_m_6pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6);
+ void a035_indexOf() {
+ String[] arr = {"a", "b", "c"};
+ assertEquals(0, indexOf("a", arr));
+ assertEquals(1, indexOf("b", arr));
+ assertEquals(2, indexOf("c", arr));
+ assertEquals(-1, indexOf("d", arr));
+ assertEquals(-1, indexOf(null, arr));
+ assertEquals(-1, indexOf("a", null));
+ }
+
//====================================================================================================
+ // ints(int...)
+
//====================================================================================================
+ @Test
+ void a036_ints() {
+ int[] result = ints(1, 2, 3);
assertNotNull(result);
- assertSize(6, result);
- assertEquals(6, result.get("f"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 7));
+ assertEquals(3, result.length);
+ assertEquals(1, result[0]);
+ assertEquals(2, result[1]);
+ assertEquals(3, result[2]);
+ }
+
+
//====================================================================================================
+ // isEmptyArray(Object[])
+
//====================================================================================================
+ @Test
+ void a037_isEmptyArray() {
+ assertTrue(isEmptyArray(null));
+ assertTrue(isEmptyArray(new String[0]));
+ assertFalse(isEmptyArray(new String[]{"a"}));
}
+
//====================================================================================================
+ // isNotEmptyArray(Object[])
+
//====================================================================================================
@Test
- void a24_m_7pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7);
+ void a038_isNotEmptyArray() {
+ assertFalse(isNotEmptyArray(null));
+ assertFalse(isNotEmptyArray(new String[0]));
+ assertTrue(isNotEmptyArray(new String[]{"a"}));
+ }
+
//====================================================================================================
+ // l(T...)
+
//====================================================================================================
+ @Test
+ void a039_l() {
+ List<String> result = l("a", "b", "c");
assertNotNull(result);
- assertSize(7, result);
- assertEquals(7, result.get("g"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 8));
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("d"));
+
+ assertNull(l((String[])null));
}
+
//====================================================================================================
+ // last(E[])
+
//====================================================================================================
@Test
- void a25_m_8pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8);
+ void a040_last_array() {
+ String[] arr = {"a", "b", "c"};
+ assertEquals("c", last(arr));
+ String[] nullArr = null;
+ assertNull(last(nullArr));
+ assertNull(last(new String[0]));
+ }
- assertNotNull(result);
- assertSize(8, result);
- assertEquals(8, result.get("h"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 9));
+
//====================================================================================================
+ // last(List<E>)
+
//====================================================================================================
+ @Test
+ void a041_last_list() {
+ List<String> list = list("a", "b", "c");
+ assertEquals("c", last(list));
+ List<String> nullList = null;
+ assertNull(last(nullList));
+ assertNull(last(list()));
}
+
//====================================================================================================
+ // length(Object)
+
//====================================================================================================
@Test
- void a26_m_9pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8, "i", 9);
+ void a042_length() {
+ String[] arr = {"a", "b", "c"};
+ assertEquals(3, length(arr));
+ assertEquals(0, length(null));
+ int[] intArr = {1, 2, 3, 4};
+ assertEquals(4, length(intArr));
+ }
+
//====================================================================================================
+ // list(T...)
+
//====================================================================================================
+ @Test
+ void a043_list() {
+ List<String> result = list("a", "b", "c");
assertNotNull(result);
- assertSize(9, result);
- assertEquals(9, result.get("i"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 10));
+ assertTrue(result instanceof ArrayList);
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
+ result.add("d"); // Modifiable
+ assertEquals(4, result.size());
}
+
//====================================================================================================
+ // listb(Class<E>, Converter...)
+
//====================================================================================================
@Test
- void a27_m_10pairs() {
- Map<String, Integer> result = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8, "i", 9, "j", 10);
+ void a044_listb() {
+ ListBuilder<String> builder = listb(String.class);
+ assertNotNull(builder);
+ List<String> result = builder.add("a").add("b").build();
+ assertEquals(2, result.size());
+ assertEquals("a", result.get(0));
+ assertEquals("b", result.get(1));
+ }
+
//====================================================================================================
+ // liste()
+
//====================================================================================================
+ @Test
+ void a045_liste() {
+ List<String> result = liste();
assertNotNull(result);
- assertSize(10, result);
- assertEquals(10, result.get("j"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 11));
+ assertTrue(result.isEmpty());
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("a"));
}
//====================================================================================================
- // m() - null handling
+ // liste(Class<T>)
//====================================================================================================
@Test
- void a28_m_nullKey() {
- Map<String, Integer> result = m(null, 1);
-
+ void a046_liste_class() {
+ List<String> result = liste(String.class);
assertNotNull(result);
- assertSize(1, result);
- assertEquals(1, result.get(null));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 2));
+ assertTrue(result.isEmpty());
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("a"));
}
+
//====================================================================================================
+ // listn(Class<T>)
+
//====================================================================================================
@Test
- void a29_m_nullValue() {
- Map<String, Integer> result = m("a", null);
+ void a047_listn() {
+ assertNull(listn(String.class));
+ }
+
//====================================================================================================
+ // listOf(Class<E>, E...)
+
//====================================================================================================
+ @Test
+ void a048_listOf() {
+ List<String> result = listOf(String.class, "a", "b", "c");
assertNotNull(result);
- assertSize(1, result);
- assertNull(result.get("a"));
- assertTrue(result.containsKey("a"));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", 2));
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
}
+
//====================================================================================================
+ // listOfSize(int)
+
//====================================================================================================
@Test
- void a30_m_multipleNulls() {
- Map<String, String> result = m("a", "val1", "b", null, "c",
"val3", null, "val4");
+ void a049_listOfSize() {
+ ArrayList<String> result = listOfSize(5);
+ assertNotNull(result);
+ assertEquals(0, result.size());
+ result.add("a");
+ assertEquals(1, result.size());
+ }
+
//====================================================================================================
+ // longs(long...)
+
//====================================================================================================
+ @Test
+ void a050_longs() {
+ long[] result = longs(1L, 2L, 3L);
assertNotNull(result);
- assertSize(4, result);
- assertEquals("val1", result.get("a"));
- assertNull(result.get("b"));
- assertEquals("val3", result.get("c"));
- assertEquals("val4", result.get(null));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", "y"));
+ assertEquals(3, result.length);
+ assertEquals(1L, result[0]);
+ assertEquals(2L, result[1]);
+ assertEquals(3L, result[2]);
}
+
//====================================================================================================
+ // m() - all overloads
+
//====================================================================================================
@Test
- void a31_m_allNulls_duplicateKeys() {
- // This should throw because we have duplicate null keys
- assertThrows(IllegalArgumentException.class, () -> {
- m(null, null, null, null);
+ void a051_m() {
+ // Empty
+ Map<String, Integer> empty = m();
+ assertNotNull(empty);
+ assertTrue(empty.isEmpty());
+ assertThrows(UnsupportedOperationException.class, () ->
empty.put("x", 1));
+
+ // 1 pair
+ Map<String, Integer> m1 = m("a", 1);
+ assertEquals(1, m1.size());
+ assertEquals(1, m1.get("a"));
+
+ // 2 pairs
+ Map<String, Integer> m2 = m("a", 1, "b", 2);
+ assertEquals(2, m2.size());
+ assertEquals(1, m2.get("a"));
+ assertEquals(2, m2.get("b"));
+
+ // 3 pairs
+ Map<String, Integer> m3 = m("a", 1, "b", 2, "c", 3);
+ assertEquals(3, m3.size());
+
+ // 4 pairs
+ Map<String, Integer> m4 = m("a", 1, "b", 2, "c", 3, "d", 4);
+ assertEquals(4, m4.size());
+
+ // 5 pairs
+ Map<String, Integer> m5 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5);
+ assertEquals(5, m5.size());
+
+ // 6 pairs
+ Map<String, Integer> m6 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6);
+ assertEquals(6, m6.size());
+
+ // 7 pairs
+ Map<String, Integer> m7 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7);
+ assertEquals(7, m7.size());
+
+ // 8 pairs
+ Map<String, Integer> m8 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8);
+ assertEquals(8, m8.size());
+
+ // 9 pairs
+ Map<String, Integer> m9 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8, "i", 9);
+ assertEquals(9, m9.size());
+
+ // 10 pairs
+ Map<String, Integer> m10 = m("a", 1, "b", 2, "c", 3, "d", 4,
"e", 5, "f", 6, "g", 7, "h", 8, "i", 9, "j", 10);
+ assertEquals(10, m10.size());
+
+ // Null handling
+ Map<String, Integer> nullKey = m(null, 1);
+ assertEquals(1, nullKey.get(null));
+
+ Map<String, Integer> nullValue = m("a", null);
+ assertNull(nullValue.get("a"));
+ assertTrue(nullValue.containsKey("a"));
+
+ // Duplicate key detection
+ assertThrowsWithMessage(IllegalArgumentException.class,
"Duplicate key found: key1", () -> {
+ m("key1", "value1", "key2", "value2", "key1", "value3");
});
+
+ // Insertion order preservation
+ Map<String, Integer> ordered = m("z", 1, "a", 2, "m", 3, "b",
4);
+ var keys = new ArrayList<>(ordered.keySet());
+ assertEquals(list("z", "a", "m", "b"), keys);
+
+ // Immutability
+ assertThrows(UnsupportedOperationException.class, () ->
m1.put("x", 2));
+ assertThrows(UnsupportedOperationException.class, () ->
m1.remove("a"));
+ assertThrows(UnsupportedOperationException.class, () ->
m1.clear());
}
+
//====================================================================================================
+ // map() - all overloads
+
//====================================================================================================
@Test
- void a32_m_singleNullKeyValue() {
- Map<String, String> result = m(null, null);
+ void a052_map() {
+ // Empty
+ LinkedHashMap<String, Integer> empty = map();
+ assertNotNull(empty);
+ assertTrue(empty.isEmpty());
+ empty.put("x", 1); // Modifiable
+ assertEquals(1, empty.size());
+
+ // 1 pair
+ LinkedHashMap<String, Integer> m1 = map("a", 1);
+ assertEquals(1, m1.size());
+ assertEquals(1, m1.get("a"));
+
+ // 2 pairs
+ LinkedHashMap<String, Integer> m2 = map("a", 1, "b", 2);
+ assertEquals(2, m2.size());
+
+ // 3 pairs
+ LinkedHashMap<String, Integer> m3 = map("a", 1, "b", 2, "c", 3);
+ assertEquals(3, m3.size());
+
+ // 4 pairs
+ LinkedHashMap<String, Integer> m4 = map("a", 1, "b", 2, "c", 3,
"d", 4);
+ assertEquals(4, m4.size());
+ var keys = new ArrayList<>(m4.keySet());
+ assertEquals(l("a", "b", "c", "d"), keys);
+
+ // 5 pairs
+ LinkedHashMap<String, Integer> m5 = map("a", 1, "b", 2, "c", 3,
"d", 4, "e", 5);
+ assertEquals(5, m5.size());
+
+ // 6-10 pairs
+ LinkedHashMap<String, Integer> m6 = map("a", 1, "b", 2, "c", 3,
"d", 4, "e", 5, "f", 6);
+ assertEquals(6, m6.size());
+
+ LinkedHashMap<String, Integer> m10 = map("a", 1, "b", 2, "c",
3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8, "i", 9, "j", 10);
+ assertEquals(10, m10.size());
+ assertEquals(l("a", "b", "c", "d", "e", "f", "g", "h", "i",
"j"), new ArrayList<>(m10.keySet()));
+
+ // Null values
+ LinkedHashMap<String, String> nullVals = map("a", "val1", "b",
null, "c", "val3", "d", null);
+ assertEquals(4, nullVals.size());
+ assertNull(nullVals.get("b"));
+ }
- assertNotNull(result);
- assertSize(1, result);
- assertNull(result.get(null));
- assertTrue(result.containsKey(null));
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", "y"));
+
//====================================================================================================
+ // mapb()
+
//====================================================================================================
+ @Test
+ void a053_mapb() {
+ MapBuilder<String, Object> builder = mapb();
+ assertNotNull(builder);
+ Map<String, Object> result = builder.add("a", 1).add("b",
2).build();
+ assertEquals(2, result.size());
+ assertEquals(1, result.get("a"));
+ assertEquals(2, result.get("b"));
}
//====================================================================================================
- // m() - insertion order preservation
+ // mapb(Class<K>, Class<V>, Converter...)
//====================================================================================================
@Test
- void a33_m_insertionOrder_simpleKeys() {
- Map<String, Integer> result = m("z", 1, "a", 2, "m", 3, "b", 4);
+ void a054_mapb_class() {
+ MapBuilder<String, Integer> builder = mapb(String.class,
Integer.class);
+ assertNotNull(builder);
+ Map<String, Integer> result = builder.add("a", 1).build();
+ assertEquals(1, result.size());
+ }
+
//====================================================================================================
+ // mape(Class<K>, Class<V>)
+
//====================================================================================================
+ @Test
+ void a055_mape() {
+ Map<String, Integer> result = mape(String.class, Integer.class);
assertNotNull(result);
- assertSize(4, result);
-
- // Verify insertion order is preserved
- var keys = new ArrayList<>(result.keySet());
- assertEquals(list("z", "a", "m", "b"), keys);
+ assertTrue(result.isEmpty());
+ assertThrows(UnsupportedOperationException.class, () ->
result.put("a", 1));
}
+
//====================================================================================================
+ // mapn(Class<K>, Class<V>)
+
//====================================================================================================
@Test
- void a34_m_insertionOrder_withNullKey() {
- Map<String, Integer> result = m("first", 1, null, 2, "last", 3);
+ void a056_mapn() {
+ assertNull(mapn(String.class, Integer.class));
+ }
+
//====================================================================================================
+ // mapOf(Class<K>, Class<V>)
+
//====================================================================================================
+ @Test
+ void a057_mapOf() {
+ LinkedHashMap<String, Integer> result = mapOf(String.class,
Integer.class);
assertNotNull(result);
- assertSize(3, result);
+ assertTrue(result.isEmpty());
+ result.put("a", 1); // Modifiable
+ assertEquals(1, result.size());
+ }
- // Verify insertion order is preserved, including null
- var keys = new ArrayList<>(result.keySet());
- assertEquals(list("first", null, "last"), keys);
+
//====================================================================================================
+ // na(Class<T>)
+
//====================================================================================================
+ @Test
+ void a058_na() {
+ assertNull(na(String.class));
}
+
//====================================================================================================
+ // prependAll(List<E>, E...)
+
//====================================================================================================
@Test
- void a35_m_insertionOrder_allPairs() {
- // Test with 10 pairs to ensure order is preserved for larger
maps
- Map<Integer, String> result = m(10, "ten", 9, "nine", 8,
"eight", 7, "seven",
- 6, "six", 5, "five", 4,
"four", 3, "three",
- 2, "two", 1, "one");
+ void a059_prependAll() {
+ // Null value creates new list
+ var result1 = prependAll((List<String>)null, "a", "b");
+ assertNotNull(result1);
+ assertEquals(list("a", "b"), result1);
+
+ // Existing list prepends to it
+ var list = list("x");
+ var result2 = prependAll(list, "a", "b");
+ assertSame(list, result2);
+ assertEquals(list("a", "b", "x"), result2);
+
+ // Null entries returns original
+ var list2 = list("a", "b");
+ var result3 = prependAll(list2, (String[])null);
+ assertSame(list2, result3);
+ }
+
//====================================================================================================
+ // reverse(E[])
+
//====================================================================================================
+ @Test
+ void a060_reverse_array() {
+ String[] arr = {"a", "b", "c"};
+ String[] result = reverse(arr);
+ assertSame(arr, result);
+ assertEquals("c", arr[0]);
+ assertEquals("b", arr[1]);
+ assertEquals("a", arr[2]);
+ }
+
+
//====================================================================================================
+ // reverse(List<E>)
+
//====================================================================================================
+ @Test
+ void a061_reverse_list() {
+ List<String> list = list("a", "b", "c");
+ List<String> result = reverse(list);
assertNotNull(result);
- assertSize(10, result);
+ assertEquals("c", result.get(0));
+ assertEquals("b", result.get(1));
+ assertEquals("a", result.get(2));
+ // View reflects changes - adding to original list adds to end,
which appears at index 0 in reversed view
+ list.add("d");
+ assertEquals(4, result.size());
+ assertEquals("d", result.get(0)); // New element appears at
start of reversed view
+ assertEquals("a", result.get(3)); // Original first element now
at end
+ }
- // Verify insertion order
- var keys = new ArrayList<>(result.keySet());
- assertEquals(l(10, 9, 8, 7, 6, 5, 4, 3, 2, 1), keys);
+
//====================================================================================================
+ // rstream(List<T>)
+
//====================================================================================================
+ @Test
+ void a062_rstream() {
+ List<String> list = list("a", "b", "c");
+ List<String> result = rstream(list).toList();
+ assertEquals(list("c", "b", "a"), result);
+
+ assertTrue(rstream(null).toList().isEmpty());
+ assertTrue(rstream(list()).toList().isEmpty());
}
+
//====================================================================================================
+ // set(T...)
+
//====================================================================================================
@Test
- void a36_m_insertionOrder_entrySet() {
- Map<String, String> result = m("key1", "val1", "key2", "val2",
"key3", "val3");
+ void a063_set() {
+ LinkedHashSet<String> result = set("a", "b", "c");
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertTrue(result.contains("c"));
+ result.add("d"); // Modifiable
+ assertEquals(4, result.size());
+ }
- // Verify order in entrySet
- List<String> orderedKeys = list();
- for (var entry : result.entrySet()) {
- orderedKeys.add(entry.getKey());
- }
+
//====================================================================================================
+ // setb(Class<E>, Converter...)
+
//====================================================================================================
+ @Test
+ void a064_setb() {
+ SetBuilder<String> builder = setb(String.class);
+ assertNotNull(builder);
+ Set<String> result = builder.add("a").add("b").build();
+ assertEquals(2, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ }
- assertEquals(l("key1", "key2", "key3"), orderedKeys);
+
//====================================================================================================
+ // setOf(Class<E>, E...)
+
//====================================================================================================
+ @Test
+ void a065_setOf() {
+ LinkedHashSet<String> result = setOf(String.class, "a", "b",
"c");
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
}
//====================================================================================================
- // m() - duplicate key detection
+ // shorts(int...)
//====================================================================================================
@Test
- void a37_m_duplicateKey_nonNull() {
- assertThrowsWithMessage(IllegalArgumentException.class,
"Duplicate key found: key1", () -> {
- m("key1", "value1", "key2", "value2", "key1", "value3");
- });
+ void a066_shorts() {
+ short[] result = shorts(1, 2, 3);
+ assertNotNull(result);
+ assertEquals(3, result.length);
+ assertEquals(1, result[0]);
+ assertEquals(2, result[1]);
+ assertEquals(3, result[2]);
}
+
//====================================================================================================
+ // sortedList(Comparator<E>, Collection<E>)
+
//====================================================================================================
@Test
- void a38_m_duplicateKey_nullKeys() {
- assertThrowsWithMessage(IllegalArgumentException.class,
"Duplicate key found: null", () -> {
- m(null, "value1", "key2", "value2", null, "value3");
- });
+ void a067_sortedList_comparatorCollection() {
+ List<String> list = list("c", "a", "b");
+ List<String> result = sortedList(Comparator.naturalOrder(),
list);
+ assertNotNull(result);
+ assertEquals(list("a", "b", "c"), result);
}
+
//====================================================================================================
+ // sortedList(Comparator<E>, E[])
+
//====================================================================================================
@Test
- void a39_m_duplicateKey_inLargerMap() {
- assertThrowsWithMessage(IllegalArgumentException.class,
"Duplicate key found: a", () -> {
- m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "a", 6);
- });
+ void a068_sortedList_comparatorArray() {
+ String[] arr = {"c", "a", "b"};
+ List<String> result = sortedList(Comparator.naturalOrder(),
arr);
+ assertNotNull(result);
+ assertEquals(list("a", "b", "c"), result);
}
+
//====================================================================================================
+ // sortedList(E...)
+
//====================================================================================================
@Test
- void a40_m_noDuplicates_success() {
- Map<String, Integer> result = assertDoesNotThrow(() ->
- m("key1", 1, null, 2, "key3", 3, "key4", 4)
- );
+ void a069_sortedList() {
+ List<String> result = sortedList("c", "a", "b");
+ assertNotNull(result);
+ assertEquals(list("a", "b", "c"), result);
+ }
- assertSize(4, result);
- assertEquals(1, result.get("key1"));
- assertEquals(2, result.get(null));
- assertEquals(3, result.get("key3"));
- assertEquals(4, result.get("key4"));
+
//====================================================================================================
+ // sortedMap()
+
//====================================================================================================
+ @Test
+ void a070_sortedMap() {
+ TreeMap<String, Integer> result = sortedMap();
+ assertNotNull(result);
+ assertTrue(result.isEmpty());
+ result.put("a", 1);
+ assertEquals(1, result.size());
}
//====================================================================================================
- // m() - comprehensive integration tests
+ // sortedSet(E...)
//====================================================================================================
@Test
- void a41_m_nullKey_preservesOrder_immutable() {
- Map<String, String> result = m("first", "1st", null,
"null-value", "last", "final");
+ void a071_sortedSet() {
+ TreeSet<String> result = sortedSet("c", "a", "b");
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertEquals(list("a", "b", "c"), new ArrayList<>(result));
+
+ // Empty
+ TreeSet<String> empty = sortedSet();
+ assertNotNull(empty);
+ assertTrue(empty.isEmpty());
+
+ // Single
+ TreeSet<String> single = sortedSet("a");
+ assertEquals(1, single.size());
+
+ // Numbers
+ TreeSet<Integer> numbers = sortedSet(3, 1, 2, 5, 4);
+ assertEquals(list(1, 2, 3, 4, 5), new ArrayList<>(numbers));
+ }
- // Check null key works
- assertEquals("null-value", result.get(null));
+
//====================================================================================================
+ // stream(T[])
+
//====================================================================================================
+ @Test
+ void a072_stream() {
+ String[] arr = {"a", "b", "c"};
+ List<String> result = stream(arr).toList();
+ assertEquals(list("a", "b", "c"), result);
+
+ assertTrue(stream(null).toList().isEmpty());
+ }
- // Check insertion order
- var keys = new ArrayList<>(result.keySet());
- assertEquals(list("first", null, "last"), keys);
+
//====================================================================================================
+ // synced(List<E>)
+
//====================================================================================================
+ @Test
+ void a073_synced_list() {
+ List<String> list = list("a", "b");
+ List<String> result = synced(list);
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertNull(synced((List<String>)null));
+ }
- // Check immutability
- assertThrows(UnsupportedOperationException.class, () ->
result.put("new", "value"));
- assertThrows(UnsupportedOperationException.class, () ->
result.remove("first"));
- assertThrows(UnsupportedOperationException.class, () ->
result.clear());
+
//====================================================================================================
+ // synced(Map<K,V>)
+
//====================================================================================================
+ @Test
+ void a074_synced_map() {
+ Map<String, Integer> map = map("a", 1);
+ Map<String, Integer> result = synced(map);
+ assertNotNull(result);
+ assertEquals(1, result.size());
+ assertEquals(1, result.get("a"));
+ assertNull(synced((Map<String, Integer>)null));
}
+
//====================================================================================================
+ // synced(Set<E>)
+
//====================================================================================================
@Test
- void a42_m_complexScenario() {
- // Test with various types, nulls, and verify all properties
- Map<Object, Object> result = m(
- "string", "value",
- null, "null-key",
- 42, "number",
- true, "boolean"
- );
+ void a075_synced_set() {
+ Set<String> set = set("a", "b");
+ Set<String> result = synced(set);
+ assertNotNull(result);
+ assertEquals(2, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertNull(synced((Set<String>)null));
+ }
- // Verify all entries
- assertSize(4, result);
- assertEquals("value", result.get("string"));
- assertEquals("null-key", result.get(null));
- assertEquals("number", result.get(42));
- assertEquals("boolean", result.get(true));
+
//====================================================================================================
+ // toArray(Collection<?>, Class<E>)
+
//====================================================================================================
+ @Test
+ void a076_toArray() {
+ List<String> list = list("a", "b", "c");
+ Object result = toArray(list, String.class);
+ assertNotNull(result);
+ assertTrue(result instanceof String[]);
+ String[] arr = (String[])result;
+ assertEquals(3, arr.length);
+ assertEquals("a", arr[0]);
+ }
- // Verify order
- var keys = new ArrayList<>(result.keySet());
- assertEquals(list("string", null, 42, true), keys);
+
//====================================================================================================
+ // toList(Collection<E>)
+
//====================================================================================================
+ @Test
+ void a077_toList_collection() {
+ Collection<String> col = set("a", "b", "c");
+ ArrayList<String> result = toList(col);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ }
- // Verify immutability
- assertThrows(UnsupportedOperationException.class, () ->
result.put("x", "y"));
+
//====================================================================================================
+ // toList(Collection<E>, boolean)
+
//====================================================================================================
+ @Test
+ void a078_toList_collectionBoolean() {
+ Collection<String> col = list("a", "b");
+ ArrayList<String> result1 = toList(col, false);
+ assertNotNull(result1);
+ assertEquals(2, result1.size());
+
+ ArrayList<String> result2 = toList(col, true);
+ assertNotNull(result2);
+ assertEquals(2, result2.size());
+
+ Collection<String> empty = list();
+ assertNull(toList(empty, true));
+ assertNotNull(toList(empty, false));
+ assertNull(toList(null, false));
}
//====================================================================================================
- // addAll(T[], T...) - Array utilities from deprecated ArrayUtils
+ // toList(Object)
//====================================================================================================
@Test
- void a43_addAll_arrayToArray() {
- String[] s = {};
+ void a079_toList_object() {
+ // List returns as-is
+ ArrayList<String> arrayList = new ArrayList<>();
+ arrayList.add("a");
+ arrayList.add("b");
+ List<?> result1 = toList((Object)arrayList);
+ assertSame(arrayList, result1);
+
+ // Set converts to list
+ Set<String> set = set("a", "b", "c");
+ List<?> result2 = toList(set);
+ assertNotNull(result2);
+ assertEquals(3, result2.size());
+ assertTrue(result2.contains("a"));
+ assertTrue(result2.contains("b"));
+ assertTrue(result2.contains("c"));
+
+ // Array converts to list
+ String[] arr = {"a", "b", "c"};
+ List<?> result3 = toList(arr);
+ assertEquals(3, result3.size());
+ assertEquals("a", result3.get(0));
+ }
- s = addAll(s, "a", "b");
- assertList(s, "a", "b");
+
//====================================================================================================
+ // toSet(E[])
+
//====================================================================================================
+ @Test
+ void a080_toSet() {
+ String[] arr = {"a", "b", "c"};
+ Set<String> result = toSet(arr);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("d"));
+
+ assertThrows(IllegalArgumentException.class, () ->
toSet((String[])null));
+ }
- s = addAll(s, "c");
- assertList(s, "a", "b", "c");
+
//====================================================================================================
+ // toSortedSet(Set<E>)
+
//====================================================================================================
+ @Test
+ void a081_toSortedSet() {
+ LinkedHashSet<String> input = new LinkedHashSet<>(l("c", "a",
"b"));
+ TreeSet<String> result = toSortedSet(input);
+ assertNotNull(result);
+ assertEquals(l("a", "b", "c"), new ArrayList<>(result));
+
+ LinkedHashSet<Integer> input2 = new LinkedHashSet<>(l(3, 1, 2));
+ TreeSet<Integer> result2 = toSortedSet(input2);
+ assertEquals(l(1, 2, 3), new ArrayList<>(result2));
+
+ assertNull(toSortedSet((Set<String>)null));
+ }
- s = addAll(s);
- assertList(s, "a", "b", "c");
+
//====================================================================================================
+ // traverse(Object, Consumer<T>)
+
//====================================================================================================
+ @Test
+ void a082_traverse() {
+ List<String> list = list("a", "b", "c");
+ List<Object> result = new ArrayList<>();
+ traverse(list, result::add);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertTrue(result.contains("b"));
+ assertTrue(result.contains("c"));
+ }
- var o = addAll((Object[])null);
- assertEmpty(o);
+
//====================================================================================================
+ // toList(Object, Class<E>)
+
//====================================================================================================
+ @Test
+ void a083_toList_objectClass() {
+ String[] arr = {"a", "b", "c"};
+ List<String> result = toList(arr, String.class);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
+ }
- s = addAll((String[])null, "a", "b");
- assertList(s, "a", "b");
+
//====================================================================================================
+ // toObjectList(Object)
+
//====================================================================================================
+ @Test
+ void a084_toObjectList() {
+ String[] arr = {"a", "b", "c"};
+ List<Object> result = toObjectList(arr);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
}
//====================================================================================================
- // toSet(T[]) - Array utilities from deprecated ArrayUtils
+ // toSet(Collection<E>)
//====================================================================================================
@Test
- void a44_toSet_fromArray() {
- assertThrows(IllegalArgumentException.class,
()->toSet((String[])null));
+ void a085_toSet_collection() {
+ Collection<String> col = list("a", "b", "c");
+ Set<String> result = toSet(col);
+ assertNotNull(result);
+ assertEquals(3, result.size());
+ assertTrue(result.contains("a"));
+ assertNull(toSet((Collection<String>)null));
+ }
- var s = a("a");
- var i = toSet(s).iterator();
- assertEquals("a", i.next());
+
//====================================================================================================
+ // toSortedSet(Collection<E>, boolean)
+
//====================================================================================================
+ @Test
+ void a086_toSortedSet_collectionBoolean() {
+ Collection<String> col = list("c", "a", "b");
+ TreeSet<String> result1 = toSortedSet(col, false);
+ assertNotNull(result1);
+ assertEquals(3, result1.size());
+
+ Collection<String> empty = list();
+ assertNull(toSortedSet(empty, true));
+ assertNotNull(toSortedSet(empty, false));
+ assertNull(toSortedSet((Collection<String>)null, false));
+ }
- assertThrows(UnsupportedOperationException.class, i::remove);
- assertThrows(NoSuchElementException.class, i::next);
+
//====================================================================================================
+ // toStream(Object)
+
//====================================================================================================
+ @Test
+ void a087_toStream() {
+ String[] arr = {"a", "b", "c"};
+ List<Object> result = toStream(arr).toList();
+ assertEquals(3, result.size());
+ assertEquals("a", result.get(0));
}
//====================================================================================================
- // combine(T[]...) - Array utilities from deprecated ArrayUtils
+ // toStringArray(Collection<?>)
//====================================================================================================
@Test
- void a45_combine_arrays() {
- var s1 = a("a");
- var s2 = a("b");
+ void a088_toStringArray() {
+ Collection<Integer> col = list(1, 2, 3);
+ String[] result = toStringArray(col);
+ assertNotNull(result);
+ assertEquals(3, result.length);
+ assertEquals("1", result[0]);
+ assertEquals("2", result[1]);
+ assertEquals("3", result[2]);
+ }
- assertList(combine(s1, s2), "a", "b");
- assertList(combine(s1), "a");
- assertList(combine(s2), "b");
- assertList(combine(s1,null), "a");
- assertList(combine(null,s2), "b");
- assertNull(combine(null,null));
- assertNull(combine());
+
//====================================================================================================
+ // u(List<? extends T>)
+
//====================================================================================================
+ @Test
+ void a089_u_list() {
+ List<String> list = list("a", "b");
+ List<String> result = u(list);
+ assertNotNull(result);
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("c"));
+ assertNull(u((List<String>)null));
}
-}
+
//====================================================================================================
+ // u(Map<? extends K,? extends V>)
+
//====================================================================================================
+ @Test
+ void a090_u_map() {
+ Map<String, Integer> map = map("a", 1);
+ Map<String, Integer> result = u(map);
+ assertNotNull(result);
+ assertThrows(UnsupportedOperationException.class, () ->
result.put("b", 2));
+ assertNull(u((Map<String, Integer>)null));
+ }
+
//====================================================================================================
+ // u(Set<? extends T>)
+
//====================================================================================================
+ @Test
+ void a091_u_set() {
+ Set<String> set = set("a", "b");
+ Set<String> result = u(set);
+ assertNotNull(result);
+ assertThrows(UnsupportedOperationException.class, () ->
result.add("c"));
+ assertNull(u((Set<String>)null));
+ }
+}
