1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.juneau.commons.utils;
18
19 import static org.apache.juneau.TestUtils.assertThrowsWithMessage;
20 import static org.apache.juneau.commons.utils.CollectionUtils.*;
21 import static org.apache.juneau.junit.bct.BctAssertions.*;
22 import static org.junit.jupiter.api.Assertions.*;
23
24 import java.util.*;
25
26 import org.apache.juneau.*;
27 import org.apache.juneau.commons.collections.*;
28 import org.junit.jupiter.api.*;
29
30 class CollectionUtils_Test extends TestBase {
31
32
33
34
35 @Test
36 void a00_constructor() {
37
38
39
40 }
41
42
43
44
45 @Test
46 void a001_a() {
47 String[] result = a("a", "b", "c");
48 assertNotNull(result);
49 assertEquals(3, result.length);
50 assertEquals("a", result[0]);
51 assertEquals("b", result[1]);
52 assertEquals("c", result[2]);
53
54
55 String[] empty = a();
56 assertNotNull(empty);
57 assertEquals(0, empty.length);
58 }
59
60
61
62
63 @Test
64 void a002_a2() {
65 String[][] result = a2(a("a", "b"), a("c", "d"));
66 assertNotNull(result);
67 assertEquals(2, result.length);
68 assertEquals(2, result[0].length);
69 assertEquals("a", result[0][0]);
70 assertEquals("b", result[0][1]);
71 assertEquals("c", result[1][0]);
72 assertEquals("d", result[1][1]);
73
74
75 String[][] single = a2(a("x", "y", "z"));
76 assertEquals(1, single.length);
77 assertEquals(3, single[0].length);
78
79
80 String[][] empty = a2();
81 assertNotNull(empty);
82 assertEquals(0, empty.length);
83 }
84
85
86
87
88 @Test
89 void a003_accumulate() {
90 List<String> list = list("a", "b", "c");
91 List<?> result = accumulate(list);
92 assertNotNull(result);
93 assertEquals(3, result.size());
94 assertTrue(result.contains("a"));
95 assertTrue(result.contains("b"));
96 assertTrue(result.contains("c"));
97 }
98
99
100
101
102 @Test
103 void a004_addAll_listVarargs() {
104
105 var result1 = addAll((List<String>)null, "a", "b");
106 assertNotNull(result1);
107 assertEquals(list("a", "b"), result1);
108
109
110 var list = list("x");
111 var result2 = addAll(list, "a", "b");
112 assertSame(list, result2);
113 assertEquals(list("x", "a", "b"), result2);
114
115
116 var list2 = list("a", "b");
117 var result3 = addAll(list2, (String[])null);
118 assertSame(list2, result3);
119 }
120
121
122
123
124 @Test
125 void a005_addAll_listToList() {
126
127 var list = list("a", "b");
128 var result1 = addAll(list, (List<String>)null);
129 assertSame(list, result1);
130 assertEquals(list("a", "b"), result1);
131
132
133 var entries = list("x", "y", "z");
134 var result2 = addAll(null, entries);
135 assertNotNull(result2);
136 assertEquals(list("x", "y", "z"), result2);
137 assertNotSame(entries, result2);
138
139
140 var list2 = list("a", "b");
141 var entries2 = list("c", "d");
142 var result3 = addAll(list2, entries2);
143 assertSame(list2, result3);
144 assertEquals(list("a", "b", "c", "d"), result3);
145 }
146
147
148
149
150 @Test
151 void a006_addAll_setVarargs() {
152
153 var set = set("a", "b");
154 var result1 = addAll(set, (String[])null);
155 assertSame(set, result1);
156 assertEquals(set("a", "b"), result1);
157
158
159 var result2 = addAll((Set<String>)null, "x", "y", "z");
160 assertNotNull(result2);
161 assertEquals(set("x", "y", "z"), result2);
162
163
164 var set2 = set("a", "b");
165 var result3 = addAll(set2, "c", "d");
166 assertSame(set2, result3);
167 assertEquals(set("a", "b", "c", "d"), result3);
168 }
169
170
171
172
173 @Test
174 void a007_addAll_sortedSetVarargs() {
175
176 var set = sortedSet("a", "b");
177 var result1 = addAll(set, (String[])null);
178 assertSame(set, result1);
179 assertEquals(sortedSet("a", "b"), result1);
180
181
182 var result2 = addAll((SortedSet<String>)null, "x", "y", "z");
183 assertNotNull(result2);
184 assertEquals(sortedSet("x", "y", "z"), result2);
185
186
187 var set2 = sortedSet("a", "b");
188 var result3 = addAll(set2, "c", "d");
189 assertSame(set2, result3);
190 assertEquals(sortedSet("a", "b", "c", "d"), result3);
191 }
192
193
194
195
196 @Test
197 void a008_addAll_array() {
198 String[] s = {};
199 s = addAll(s, "a", "b");
200 assertList(s, "a", "b");
201
202 s = addAll(s, "c");
203 assertList(s, "a", "b", "c");
204
205 s = addAll(s);
206 assertList(s, "a", "b", "c");
207
208 var o = addAll((Object[])null);
209 assertEmpty(o);
210
211 s = addAll((String[])null, "a", "b");
212 assertList(s, "a", "b");
213 }
214
215
216
217
218 @Test
219 void a009_ao() {
220 Object[] result = ao("string", 42, true, 3.14, null);
221 assertNotNull(result);
222 assertEquals(5, result.length);
223 assertEquals("string", result[0]);
224 assertEquals(42, result[1]);
225 assertEquals(true, result[2]);
226 assertEquals(3.14, result[3]);
227 assertNull(result[4]);
228
229
230 Object[] empty = ao();
231 assertNotNull(empty);
232 assertEquals(0, empty.length);
233 }
234
235
236
237
238 @Test
239 void a010_array_classLength() {
240 String[] result = array(String.class, 5);
241 assertNotNull(result);
242 assertEquals(5, result.length);
243 for (String s : result) {
244 assertNull(s);
245 }
246 }
247
248
249
250
251 @Test
252 void a011_array_collection() {
253 List<String> list = list("a", "b", "c");
254 String[] result = array(list, String.class);
255 assertNotNull(result);
256 assertEquals(3, result.length);
257 assertEquals("a", result[0]);
258 assertEquals("b", result[1]);
259 assertEquals("c", result[2]);
260 }
261
262
263
264
265 @Test
266 void a012_arrayToList() {
267 String[] arr = {"a", "b", "c"};
268 List<Object> result = arrayToList(arr);
269 assertNotNull(result);
270 assertEquals(3, result.size());
271 assertEquals("a", result.get(0));
272 assertEquals("b", result.get(1));
273 assertEquals("c", result.get(2));
274
275
276 int[] intArr = {1, 2, 3};
277 List<Object> intResult = arrayToList(intArr);
278 assertEquals(3, intResult.size());
279 assertEquals(1, intResult.get(0));
280 assertEquals(2, intResult.get(1));
281 assertEquals(3, intResult.get(2));
282
283
284 char[] charArr = {'a', 'b', 'c'};
285 List<Object> charResult = arrayToList(charArr);
286 assertEquals(3, charResult.size());
287 assertEquals('a', charResult.get(0));
288 assertEquals('b', charResult.get(1));
289 assertEquals('c', charResult.get(2));
290 }
291
292
293
294
295 @Test
296 void a013_booleans() {
297 boolean[] result = booleans(true, false, true);
298 assertNotNull(result);
299 assertEquals(3, result.length);
300 assertTrue(result[0]);
301 assertFalse(result[1]);
302 assertTrue(result[2]);
303 }
304
305
306
307
308 @Test
309 void a014_bytes() {
310 byte[] result = bytes(1, 2, 3);
311 assertNotNull(result);
312 assertEquals(3, result.length);
313 assertEquals(1, result[0]);
314 assertEquals(2, result[1]);
315 assertEquals(3, result[2]);
316 }
317
318
319
320
321 @Test
322 void a015_chars() {
323 char[] result = chars('a', 'b', 'c');
324 assertNotNull(result);
325 assertEquals(3, result.length);
326 assertEquals('a', result[0]);
327 assertEquals('b', result[1]);
328 assertEquals('c', result[2]);
329 }
330
331
332
333
334 @Test
335 void a016_combine() {
336 var s1 = a("a");
337 var s2 = a("b");
338
339 assertList(combine(s1, s2), "a", "b");
340 assertList(combine(s1), "a");
341 assertList(combine(s2), "b");
342 assertList(combine(s1, null), "a");
343 assertList(combine(null, s2), "b");
344 assertNull(combine(null, null));
345 assertNull(combine());
346 }
347
348
349
350
351 @Test
352 void a017_contains() {
353 String[] arr = {"a", "b", "c"};
354 assertTrue(contains("a", arr));
355 assertTrue(contains("b", arr));
356 assertFalse(contains("d", arr));
357 assertFalse(contains(null, arr));
358 assertFalse(contains("a", null));
359 }
360
361
362
363
364 @Test
365 void a018_copyArrayToList() {
366 String[] arr = {"a", "b", "c"};
367 List<Object> list = new ArrayList<>();
368 var result = copyArrayToList(arr, list);
369 assertSame(list, result);
370 assertEquals(3, list.size());
371 assertEquals("a", list.get(0));
372 assertEquals("b", list.get(1));
373 assertEquals("c", list.get(2));
374
375
376 List<Object> list2 = new ArrayList<>();
377 copyArrayToList(null, list2);
378 assertTrue(list2.isEmpty());
379 }
380
381
382
383
384 @Test
385 void a019_copyOf_collection() {
386 Collection<String> col = list("a", "b", "c");
387 Collection<String> result = copyOf(col);
388 assertNotNull(result);
389 assertEquals(3, result.size());
390 assertTrue(result.contains("a"));
391 assertTrue(result.contains("b"));
392 assertTrue(result.contains("c"));
393 assertNotSame(col, result);
394
395 assertNull(copyOf((Collection<String>)null));
396 }
397
398
399
400
401 @Test
402 void a020_copyOf_list() {
403 List<String> list = list("a", "b", "c");
404 ArrayList<String> result = copyOf(list);
405 assertNotNull(result);
406 assertEquals(3, result.size());
407 assertEquals("a", result.get(0));
408 assertEquals("b", result.get(1));
409 assertEquals("c", result.get(2));
410 assertNotSame(list, result);
411
412 assertNull(copyOf((List<String>)null));
413 }
414
415
416
417
418 @Test
419 void a021_copyOf_listFunction() {
420 List<String> list = list("a", "b", "c");
421 List<String> result = copyOf(list, s -> s.toUpperCase());
422 assertNotNull(result);
423 assertEquals(3, result.size());
424 assertEquals("A", result.get(0));
425 assertEquals("B", result.get(1));
426 assertEquals("C", result.get(2));
427
428 assertNull(copyOf((List<String>)null, s -> s));
429 }
430
431
432
433
434 @Test
435 void a022_copyOf_listFunctionSupplier() {
436 List<String> list = list("a", "b");
437 List<String> result = copyOf(list, s -> s.toUpperCase(), LinkedList::new);
438 assertNotNull(result);
439 assertTrue(result instanceof LinkedList);
440 assertEquals(2, result.size());
441 assertEquals("A", result.get(0));
442 assertEquals("B", result.get(1));
443 }
444
445
446
447
448 @Test
449 void a023_copyOf_map() {
450 Map<String, Integer> map = map("a", 1, "b", 2);
451 Map<String, Integer> result = copyOf(map);
452 assertNotNull(result);
453 assertEquals(2, result.size());
454 assertEquals(1, result.get("a"));
455 assertEquals(2, result.get("b"));
456 assertNotSame(map, result);
457
458 assertNull(copyOf((Map<String, Integer>)null));
459 }
460
461
462
463
464 @Test
465 void a024_copyOf_mapFunction() {
466 Map<String, Integer> map = map("a", 1, "b", 2);
467 Map<String, Integer> result = copyOf(map, v -> v * 2);
468 assertNotNull(result);
469 assertEquals(2, result.size());
470 assertEquals(2, result.get("a"));
471 assertEquals(4, result.get("b"));
472 }
473
474
475
476
477 @Test
478 void a025_copyOf_mapFunctionSupplier() {
479 Map<String, Integer> map = map("a", 1);
480 Map<String, Integer> result = copyOf(map, v -> v, TreeMap::new);
481 assertNotNull(result);
482 assertTrue(result instanceof TreeMap);
483 assertEquals(1, result.size());
484
485
486 assertNull(copyOf((Map<String, Integer>)null, v -> v, TreeMap::new));
487 }
488
489
490
491
492 @Test
493 void a026_copyOf_set() {
494 Set<String> set = set("a", "b", "c");
495 Set<String> result = copyOf(set);
496 assertNotNull(result);
497 assertEquals(3, result.size());
498 assertTrue(result.contains("a"));
499 assertNotSame(set, result);
500
501 assertNull(copyOf((Set<String>)null));
502 }
503
504
505
506
507 @Test
508 void a027_copyOf_setFunction() {
509 Set<String> set = set("a", "b");
510 Set<String> result = copyOf(set, s -> s.toUpperCase());
511 assertNotNull(result);
512 assertEquals(2, result.size());
513 assertTrue(result.contains("A"));
514 assertTrue(result.contains("B"));
515 }
516
517
518
519
520 @Test
521 void a028_copyOf_setFunctionSupplier() {
522 Set<String> set = set("a", "b");
523 Set<String> result = copyOf(set, s -> s, TreeSet::new);
524 assertNotNull(result);
525 assertTrue(result instanceof TreeSet);
526 assertEquals(2, result.size());
527 }
528
529
530
531
532 @Test
533 void a029_copyOf_array() {
534 String[] arr = {"a", "b", "c"};
535 String[] result = copyOf(arr);
536 assertNotNull(result);
537 assertEquals(3, result.length);
538 assertEquals("a", result[0]);
539 assertNotSame(arr, result);
540
541 assertNull(copyOf((String[])null));
542 }
543
544
545
546
547 @Test
548 void a030_doubles() {
549 double[] result = doubles(1.0, 2.0, 3.0);
550 assertNotNull(result);
551 assertEquals(3, result.length);
552 assertEquals(1.0, result[0]);
553 assertEquals(2.0, result[1]);
554 assertEquals(3.0, result[2]);
555 }
556
557
558
559
560 @Test
561 void a031_first() {
562 List<String> list = list("a", "b", "c");
563 assertEquals("a", first(list));
564
565 assertNull(first(null));
566 assertNull(first(list()));
567 }
568
569
570
571
572 @Test
573 void a032_floats() {
574 float[] result = floats(1.0f, 2.0f, 3.0f);
575 assertNotNull(result);
576 assertEquals(3, result.length);
577 assertEquals(1.0f, result[0]);
578 assertEquals(2.0f, result[1]);
579 assertEquals(3.0f, result[2]);
580 }
581
582
583
584
585 @Test
586 void a033_forEachReverse_array() {
587 String[] arr = {"a", "b", "c"};
588 List<String> result = new ArrayList<>();
589 forEachReverse(arr, result::add);
590 assertEquals(list("c", "b", "a"), result);
591 }
592
593
594
595
596 @Test
597 void a034_forEachReverse_list() {
598 List<String> list = list("a", "b", "c");
599 List<String> result = new ArrayList<>();
600 forEachReverse(list, result::add);
601 assertEquals(list("c", "b", "a"), result);
602
603
604 LinkedList<String> linkedList = new LinkedList<>(list("x", "y", "z"));
605 List<String> result2 = new ArrayList<>();
606 forEachReverse(linkedList, result2::add);
607 assertEquals(list("z", "y", "x"), result2);
608 }
609
610
611
612
613 @Test
614 void a035_indexOf() {
615 String[] arr = {"a", "b", "c"};
616 assertEquals(0, indexOf("a", arr));
617 assertEquals(1, indexOf("b", arr));
618 assertEquals(2, indexOf("c", arr));
619 assertEquals(-1, indexOf("d", arr));
620 assertEquals(-1, indexOf(null, arr));
621 assertEquals(-1, indexOf("a", null));
622 }
623
624
625
626
627 @Test
628 void a036_ints() {
629 int[] result = ints(1, 2, 3);
630 assertNotNull(result);
631 assertEquals(3, result.length);
632 assertEquals(1, result[0]);
633 assertEquals(2, result[1]);
634 assertEquals(3, result[2]);
635 }
636
637
638
639
640 @Test
641 void a037_isEmptyArray() {
642 assertTrue(isEmptyArray(null));
643 assertTrue(isEmptyArray(new String[0]));
644 assertFalse(isEmptyArray(new String[]{"a"}));
645 }
646
647
648
649
650 @Test
651 void a038_isNotEmptyArray() {
652 assertFalse(isNotEmptyArray(null));
653 assertFalse(isNotEmptyArray(new String[0]));
654 assertTrue(isNotEmptyArray(new String[]{"a"}));
655 }
656
657
658
659
660 @Test
661 void a039_l() {
662 List<String> result = l("a", "b", "c");
663 assertNotNull(result);
664 assertEquals(3, result.size());
665 assertEquals("a", result.get(0));
666 assertThrows(UnsupportedOperationException.class, () -> result.add("d"));
667
668 assertNull(l((String[])null));
669 }
670
671
672
673
674 @Test
675 void a040_last_array() {
676 String[] arr = {"a", "b", "c"};
677 assertEquals("c", last(arr));
678 String[] nullArr = null;
679 assertNull(last(nullArr));
680 assertNull(last(new String[0]));
681 }
682
683
684
685
686 @Test
687 void a041_last_list() {
688 List<String> list = list("a", "b", "c");
689 assertEquals("c", last(list));
690 List<String> nullList = null;
691 assertNull(last(nullList));
692 assertNull(last(list()));
693 }
694
695
696
697
698 @Test
699 void a042_length() {
700 String[] arr = {"a", "b", "c"};
701 assertEquals(3, length(arr));
702 assertEquals(0, length(null));
703 int[] intArr = {1, 2, 3, 4};
704 assertEquals(4, length(intArr));
705 }
706
707
708
709
710 @Test
711 void a043_list() {
712 List<String> result = list("a", "b", "c");
713 assertNotNull(result);
714 assertTrue(result instanceof ArrayList);
715 assertEquals(3, result.size());
716 assertEquals("a", result.get(0));
717 result.add("d");
718 assertEquals(4, result.size());
719 }
720
721
722
723
724 @Test
725 void a044_listb() {
726 Lists<String> builder = listb(String.class);
727 assertNotNull(builder);
728 List<String> result = builder.add("a").add("b").build();
729 assertEquals(2, result.size());
730 assertEquals("a", result.get(0));
731 assertEquals("b", result.get(1));
732 }
733
734
735
736
737 @Test
738 void a045_liste() {
739 List<String> result = liste();
740 assertNotNull(result);
741 assertTrue(result.isEmpty());
742 assertThrows(UnsupportedOperationException.class, () -> result.add("a"));
743 }
744
745
746
747
748 @Test
749 void a046_liste_class() {
750 List<String> result = liste(String.class);
751 assertNotNull(result);
752 assertTrue(result.isEmpty());
753 assertThrows(UnsupportedOperationException.class, () -> result.add("a"));
754 }
755
756
757
758
759 @Test
760 void a047_listn() {
761 assertNull(listn(String.class));
762 }
763
764
765
766
767 @Test
768 void a048_listOf() {
769 List<String> result = listOf(String.class, "a", "b", "c");
770 assertNotNull(result);
771 assertEquals(3, result.size());
772 assertEquals("a", result.get(0));
773 }
774
775
776
777
778 @Test
779 void a049_listOfSize() {
780 ArrayList<String> result = listOfSize(5);
781 assertNotNull(result);
782 assertEquals(0, result.size());
783 result.add("a");
784 assertEquals(1, result.size());
785 }
786
787
788
789
790 @Test
791 void a050_longs() {
792 long[] result = longs(1L, 2L, 3L);
793 assertNotNull(result);
794 assertEquals(3, result.length);
795 assertEquals(1L, result[0]);
796 assertEquals(2L, result[1]);
797 assertEquals(3L, result[2]);
798 }
799
800
801
802
803 @Test
804 void a051_m() {
805
806 Map<String, Integer> empty = m();
807 assertNotNull(empty);
808 assertTrue(empty.isEmpty());
809 assertThrows(UnsupportedOperationException.class, () -> empty.put("x", 1));
810
811
812 Map<String, Integer> m1 = m("a", 1);
813 assertEquals(1, m1.size());
814 assertEquals(1, m1.get("a"));
815
816
817 Map<String, Integer> m2 = m("a", 1, "b", 2);
818 assertEquals(2, m2.size());
819 assertEquals(1, m2.get("a"));
820 assertEquals(2, m2.get("b"));
821
822
823 Map<String, Integer> m3 = m("a", 1, "b", 2, "c", 3);
824 assertEquals(3, m3.size());
825
826
827 Map<String, Integer> m4 = m("a", 1, "b", 2, "c", 3, "d", 4);
828 assertEquals(4, m4.size());
829
830
831 Map<String, Integer> m5 = m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5);
832 assertEquals(5, m5.size());
833
834
835 Map<String, Integer> m6 = m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6);
836 assertEquals(6, m6.size());
837
838
839 Map<String, Integer> m7 = m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7);
840 assertEquals(7, m7.size());
841
842
843 Map<String, Integer> m8 = m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8);
844 assertEquals(8, m8.size());
845
846
847 Map<String, Integer> m9 = m("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8, "i", 9);
848 assertEquals(9, m9.size());
849
850
851 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);
852 assertEquals(10, m10.size());
853
854
855 Map<String, Integer> nullKey = m(null, 1);
856 assertEquals(1, nullKey.get(null));
857
858 Map<String, Integer> nullValue = m("a", null);
859 assertNull(nullValue.get("a"));
860 assertTrue(nullValue.containsKey("a"));
861
862
863 assertThrowsWithMessage(IllegalArgumentException.class, "Duplicate key found: key1", () -> {
864 m("key1", "value1", "key2", "value2", "key1", "value3");
865 });
866
867
868 Map<String, Integer> ordered = m("z", 1, "a", 2, "m", 3, "b", 4);
869 var keys = new ArrayList<>(ordered.keySet());
870 assertEquals(list("z", "a", "m", "b"), keys);
871
872
873 assertThrows(UnsupportedOperationException.class, () -> m1.put("x", 2));
874 assertThrows(UnsupportedOperationException.class, () -> m1.remove("a"));
875 assertThrows(UnsupportedOperationException.class, () -> m1.clear());
876 }
877
878
879
880
881 @Test
882 void a052_map() {
883
884 LinkedHashMap<String, Integer> empty = map();
885 assertNotNull(empty);
886 assertTrue(empty.isEmpty());
887 empty.put("x", 1);
888 assertEquals(1, empty.size());
889
890
891 LinkedHashMap<String, Integer> m1 = map("a", 1);
892 assertEquals(1, m1.size());
893 assertEquals(1, m1.get("a"));
894
895
896 LinkedHashMap<String, Integer> m2 = map("a", 1, "b", 2);
897 assertEquals(2, m2.size());
898
899
900 LinkedHashMap<String, Integer> m3 = map("a", 1, "b", 2, "c", 3);
901 assertEquals(3, m3.size());
902
903
904 LinkedHashMap<String, Integer> m4 = map("a", 1, "b", 2, "c", 3, "d", 4);
905 assertEquals(4, m4.size());
906 var keys = new ArrayList<>(m4.keySet());
907 assertEquals(l("a", "b", "c", "d"), keys);
908
909
910 LinkedHashMap<String, Integer> m5 = map("a", 1, "b", 2, "c", 3, "d", 4, "e", 5);
911 assertEquals(5, m5.size());
912
913
914 LinkedHashMap<String, Integer> m6 = map("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6);
915 assertEquals(6, m6.size());
916
917
918 LinkedHashMap<String, Integer> m7 = map("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7);
919 assertEquals(7, m7.size());
920 assertEquals(7, m7.get("g"));
921
922
923 LinkedHashMap<String, Integer> m8 = map("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8);
924 assertEquals(8, m8.size());
925 assertEquals(8, m8.get("h"));
926
927
928 LinkedHashMap<String, Integer> m9 = map("a", 1, "b", 2, "c", 3, "d", 4, "e", 5, "f", 6, "g", 7, "h", 8, "i", 9);
929 assertEquals(9, m9.size());
930 assertEquals(9, m9.get("i"));
931
932
933 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);
934 assertEquals(10, m10.size());
935 assertEquals(l("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"), new ArrayList<>(m10.keySet()));
936
937
938 LinkedHashMap<String, String> nullVals = map("a", "val1", "b", null, "c", "val3", "d", null);
939 assertEquals(4, nullVals.size());
940 assertNull(nullVals.get("b"));
941 }
942
943
944
945
946 @Test
947 void a053_mapb() {
948 Maps<String, Object> builder = mapb();
949 assertNotNull(builder);
950 Map<String, Object> result = builder.add("a", 1).add("b", 2).build();
951 assertEquals(2, result.size());
952 assertEquals(1, result.get("a"));
953 assertEquals(2, result.get("b"));
954 }
955
956
957
958
959 @Test
960 void a054_mapb_class() {
961 Maps<String, Integer> builder = mapb(String.class, Integer.class);
962 assertNotNull(builder);
963 Map<String, Integer> result = builder.add("a", 1).build();
964 assertEquals(1, result.size());
965 }
966
967
968
969
970 @Test
971 void a055_mape() {
972 Map<String, Integer> result = mape(String.class, Integer.class);
973 assertNotNull(result);
974 assertTrue(result.isEmpty());
975 assertThrows(UnsupportedOperationException.class, () -> result.put("a", 1));
976 }
977
978
979
980
981 @Test
982 void a056_mapn() {
983 assertNull(mapn(String.class, Integer.class));
984 }
985
986
987
988
989 @Test
990 void a057_mapOf() {
991 LinkedHashMap<String, Integer> result = mapOf(String.class, Integer.class);
992 assertNotNull(result);
993 assertTrue(result.isEmpty());
994 result.put("a", 1);
995 assertEquals(1, result.size());
996 }
997
998
999
1000
1001 @Test
1002 void a058_na() {
1003 assertNull(na(String.class));
1004 }
1005
1006
1007
1008
1009 @Test
1010 void a059_prependAll() {
1011
1012 var result1 = prependAll((List<String>)null, "a", "b");
1013 assertNotNull(result1);
1014 assertEquals(list("a", "b"), result1);
1015
1016
1017 var list = list("x");
1018 var result2 = prependAll(list, "a", "b");
1019 assertSame(list, result2);
1020 assertEquals(list("a", "b", "x"), result2);
1021
1022
1023 var list2 = list("a", "b");
1024 var result3 = prependAll(list2, (String[])null);
1025 assertSame(list2, result3);
1026 }
1027
1028
1029
1030
1031 @Test
1032 void a060_reverse_array() {
1033 String[] arr = {"a", "b", "c"};
1034 String[] result = reverse(arr);
1035 assertSame(arr, result);
1036 assertEquals("c", arr[0]);
1037 assertEquals("b", arr[1]);
1038 assertEquals("a", arr[2]);
1039 }
1040
1041
1042
1043
1044 @Test
1045 void a061_reverse_list() {
1046 List<String> list = list("a", "b", "c");
1047 List<String> result = reverse(list);
1048 assertNotNull(result);
1049 assertEquals("c", result.get(0));
1050 assertEquals("b", result.get(1));
1051 assertEquals("a", result.get(2));
1052
1053 list.add("d");
1054 assertEquals(4, result.size());
1055 assertEquals("d", result.get(0));
1056 assertEquals("a", result.get(3));
1057 }
1058
1059
1060
1061
1062 @Test
1063 void a062_rstream() {
1064 List<String> list = list("a", "b", "c");
1065 List<String> result = rstream(list).toList();
1066 assertEquals(list("c", "b", "a"), result);
1067
1068 assertTrue(rstream(null).toList().isEmpty());
1069 assertTrue(rstream(list()).toList().isEmpty());
1070 }
1071
1072
1073
1074
1075 @Test
1076 void a063_set() {
1077 LinkedHashSet<String> result = set("a", "b", "c");
1078 assertNotNull(result);
1079 assertEquals(3, result.size());
1080 assertTrue(result.contains("a"));
1081 assertTrue(result.contains("b"));
1082 assertTrue(result.contains("c"));
1083 result.add("d");
1084 assertEquals(4, result.size());
1085 }
1086
1087
1088
1089
1090 @Test
1091 void a064_setb() {
1092 Sets<String> builder = setb(String.class);
1093 assertNotNull(builder);
1094 Set<String> result = builder.add("a").add("b").build();
1095 assertEquals(2, result.size());
1096 assertTrue(result.contains("a"));
1097 assertTrue(result.contains("b"));
1098 }
1099
1100
1101
1102
1103 @Test
1104 void a065_setOf() {
1105 LinkedHashSet<String> result = setOf(String.class, "a", "b", "c");
1106 assertNotNull(result);
1107 assertEquals(3, result.size());
1108 assertTrue(result.contains("a"));
1109 }
1110
1111
1112
1113
1114 @Test
1115 void a066_shorts() {
1116 short[] result = shorts(1, 2, 3);
1117 assertNotNull(result);
1118 assertEquals(3, result.length);
1119 assertEquals(1, result[0]);
1120 assertEquals(2, result[1]);
1121 assertEquals(3, result[2]);
1122 }
1123
1124
1125
1126
1127 @Test
1128 void a067_sortedList_comparatorCollection() {
1129 List<String> list = list("c", "a", "b");
1130 List<String> result = sortedList(Comparator.naturalOrder(), list);
1131 assertNotNull(result);
1132 assertEquals(list("a", "b", "c"), result);
1133 }
1134
1135
1136
1137
1138 @Test
1139 void a068_sortedList_comparatorArray() {
1140 String[] arr = {"c", "a", "b"};
1141 List<String> result = sortedList(Comparator.naturalOrder(), arr);
1142 assertNotNull(result);
1143 assertEquals(list("a", "b", "c"), result);
1144 }
1145
1146
1147
1148
1149 @Test
1150 void a069_sortedList() {
1151 List<String> result = sortedList("c", "a", "b");
1152 assertNotNull(result);
1153 assertEquals(list("a", "b", "c"), result);
1154 }
1155
1156
1157
1158
1159 @Test
1160 void a070_sortedMap() {
1161 TreeMap<String, Integer> result = sortedMap();
1162 assertNotNull(result);
1163 assertTrue(result.isEmpty());
1164 result.put("a", 1);
1165 assertEquals(1, result.size());
1166 }
1167
1168
1169
1170
1171 @Test
1172 void a071_sortedSet() {
1173 TreeSet<String> result = sortedSet("c", "a", "b");
1174 assertNotNull(result);
1175 assertEquals(3, result.size());
1176 assertEquals(list("a", "b", "c"), new ArrayList<>(result));
1177
1178
1179 TreeSet<String> empty = sortedSet();
1180 assertNotNull(empty);
1181 assertTrue(empty.isEmpty());
1182
1183
1184 TreeSet<String> single = sortedSet("a");
1185 assertEquals(1, single.size());
1186
1187
1188 TreeSet<Integer> numbers = sortedSet(3, 1, 2, 5, 4);
1189 assertEquals(list(1, 2, 3, 4, 5), new ArrayList<>(numbers));
1190 }
1191
1192
1193
1194
1195 @Test
1196 void a072_stream() {
1197 String[] arr = {"a", "b", "c"};
1198 List<String> result = stream(arr).toList();
1199 assertEquals(list("a", "b", "c"), result);
1200
1201 assertTrue(stream(null).toList().isEmpty());
1202 }
1203
1204
1205
1206
1207 @Test
1208 void a073_synced_list() {
1209 List<String> list = list("a", "b");
1210 List<String> result = synced(list);
1211 assertNotNull(result);
1212 assertEquals(2, result.size());
1213 assertTrue(result.contains("a"));
1214 assertTrue(result.contains("b"));
1215 assertNull(synced((List<String>)null));
1216 }
1217
1218
1219
1220
1221 @Test
1222 void a074_synced_map() {
1223 Map<String, Integer> map = map("a", 1);
1224 Map<String, Integer> result = synced(map);
1225 assertNotNull(result);
1226 assertEquals(1, result.size());
1227 assertEquals(1, result.get("a"));
1228 assertNull(synced((Map<String, Integer>)null));
1229 }
1230
1231
1232
1233
1234 @Test
1235 void a075_synced_set() {
1236 Set<String> set = set("a", "b");
1237 Set<String> result = synced(set);
1238 assertNotNull(result);
1239 assertEquals(2, result.size());
1240 assertTrue(result.contains("a"));
1241 assertTrue(result.contains("b"));
1242 assertNull(synced((Set<String>)null));
1243 }
1244
1245
1246
1247
1248 @Test
1249 void a076_toArray() {
1250 List<String> list = list("a", "b", "c");
1251 Object result = toArray(list, String.class);
1252 assertNotNull(result);
1253 assertTrue(result instanceof String[]);
1254 String[] arr = (String[])result;
1255 assertEquals(3, arr.length);
1256 assertEquals("a", arr[0]);
1257 }
1258
1259
1260
1261
1262 @Test
1263 void a077_toList_collection() {
1264 Collection<String> col = set("a", "b", "c");
1265 ArrayList<String> result = toList(col);
1266 assertNotNull(result);
1267 assertEquals(3, result.size());
1268 assertTrue(result.contains("a"));
1269 }
1270
1271
1272
1273
1274 @Test
1275 void a078_toList_collectionBoolean() {
1276 Collection<String> col = list("a", "b");
1277 ArrayList<String> result1 = toList(col, false);
1278 assertNotNull(result1);
1279 assertEquals(2, result1.size());
1280
1281 ArrayList<String> result2 = toList(col, true);
1282 assertNotNull(result2);
1283 assertEquals(2, result2.size());
1284
1285 Collection<String> empty = list();
1286 assertNull(toList(empty, true));
1287 assertNotNull(toList(empty, false));
1288 assertNull(toList(null, false));
1289 }
1290
1291
1292
1293
1294 @Test
1295 void a079_toList_object() {
1296
1297 ArrayList<String> arrayList = new ArrayList<>();
1298 arrayList.add("a");
1299 arrayList.add("b");
1300 @SuppressWarnings("cast")
1301 List<?> result1 = toList((Object)arrayList);
1302 assertSame(arrayList, result1);
1303
1304
1305 Set<String> set = set("a", "b", "c");
1306 List<?> result2 = toList(set);
1307 assertNotNull(result2);
1308 assertEquals(3, result2.size());
1309 assertTrue(result2.contains("a"));
1310 assertTrue(result2.contains("b"));
1311 assertTrue(result2.contains("c"));
1312
1313
1314 String[] arr = {"a", "b", "c"};
1315 List<?> result3 = toList(arr);
1316 assertEquals(3, result3.size());
1317 assertEquals("a", result3.get(0));
1318
1319
1320
1321 List<?> result4 = toList(java.util.stream.Stream.of("x", "y", "z"));
1322 assertEquals(3, result4.size());
1323 assertEquals("x", result4.get(0));
1324
1325
1326 Map<String, Integer> map = map("a", 1, "b", 2);
1327 List<?> result5 = toList(map);
1328 assertEquals(2, result5.size());
1329
1330
1331 List<?> result6 = toList(Optional.empty());
1332 assertTrue(result6.isEmpty());
1333
1334
1335 List<?> result7 = toList(Optional.of("test"));
1336 assertEquals(1, result7.size());
1337 assertEquals("test", result7.get(0));
1338
1339
1340 assertThrows(RuntimeException.class, () -> {
1341 toList(new Object() {});
1342 });
1343 }
1344
1345
1346
1347
1348 @Test
1349 void a080_toSet() {
1350 String[] arr = {"a", "b", "c"};
1351 Set<String> result = toSet(arr);
1352 assertNotNull(result);
1353 assertEquals(3, result.size());
1354 assertTrue(result.contains("a"));
1355 assertThrows(UnsupportedOperationException.class, () -> result.add("d"));
1356
1357 assertThrows(IllegalArgumentException.class, () -> toSet((String[])null));
1358
1359
1360 Iterator<String> it = result.iterator();
1361 assertTrue(it.hasNext());
1362 assertEquals("a", it.next());
1363 assertEquals("b", it.next());
1364 assertEquals("c", it.next());
1365 assertFalse(it.hasNext());
1366
1367
1368 assertThrows(java.util.NoSuchElementException.class, () -> {
1369 it.next();
1370 });
1371
1372
1373 Iterator<String> it2 = result.iterator();
1374 it2.next();
1375 assertThrows(UnsupportedOperationException.class, () -> {
1376 it2.remove();
1377 });
1378 }
1379
1380
1381
1382
1383 @Test
1384 void a081_toSortedSet() {
1385 LinkedHashSet<String> input = new LinkedHashSet<>(l("c", "a", "b"));
1386 TreeSet<String> result = toSortedSet(input);
1387 assertNotNull(result);
1388 assertEquals(l("a", "b", "c"), new ArrayList<>(result));
1389
1390 LinkedHashSet<Integer> input2 = new LinkedHashSet<>(l(3, 1, 2));
1391 TreeSet<Integer> result2 = toSortedSet(input2);
1392 assertEquals(l(1, 2, 3), new ArrayList<>(result2));
1393
1394 assertNull(toSortedSet((Set<String>)null));
1395 }
1396
1397
1398
1399
1400 @Test
1401 void a082_traverse() {
1402 List<String> list = list("a", "b", "c");
1403 List<Object> result = new ArrayList<>();
1404 traverse(list, result::add);
1405 assertEquals(3, result.size());
1406 assertTrue(result.contains("a"));
1407 assertTrue(result.contains("b"));
1408 assertTrue(result.contains("c"));
1409
1410
1411 List<Object> result2 = new ArrayList<>();
1412 traverse(null, result2::add);
1413 assertTrue(result2.isEmpty());
1414
1415
1416 List<Object> result3 = new ArrayList<>();
1417 traverse(java.util.stream.Stream.of("x", "y", "z"), result3::add);
1418 assertEquals(3, result3.size());
1419 assertTrue(result3.contains("x"));
1420 assertTrue(result3.contains("y"));
1421 assertTrue(result3.contains("z"));
1422 }
1423
1424
1425
1426
1427 @Test
1428 void a083_toList_objectClass() {
1429 String[] arr = {"a", "b", "c"};
1430 List<String> result = toList(arr, String.class);
1431 assertNotNull(result);
1432 assertEquals(3, result.size());
1433 assertEquals("a", result.get(0));
1434 }
1435
1436
1437
1438
1439 @Test
1440 void a084_toObjectList() {
1441 String[] arr = {"a", "b", "c"};
1442
1443
1444 String[][] nestedArr = {{"a", "b"}, {"c", "d"}};
1445 List<Object> nestedResult = toObjectList(nestedArr);
1446 assertEquals(2, nestedResult.size());
1447 assertTrue(nestedResult.get(0) instanceof List);
1448 assertTrue(nestedResult.get(1) instanceof List);
1449
1450 List<Object> result = toObjectList(arr);
1451 assertNotNull(result);
1452 assertEquals(3, result.size());
1453 assertEquals("a", result.get(0));
1454 }
1455
1456
1457
1458
1459 @Test
1460 void a085_toSet_collection() {
1461 Collection<String> col = list("a", "b", "c");
1462 Set<String> result = toSet(col);
1463 assertNotNull(result);
1464 assertEquals(3, result.size());
1465 assertTrue(result.contains("a"));
1466 assertNull(toSet((Collection<String>)null));
1467 }
1468
1469
1470
1471
1472 @Test
1473 void a085b_toSortedSet_collection() {
1474
1475 Collection<String> col = list("c", "a", "b");
1476 TreeSet<String> result = toSortedSet(col);
1477 assertNotNull(result);
1478 assertEquals(l("a", "b", "c"), new ArrayList<>(result));
1479
1480 Collection<Integer> col2 = list(3, 1, 2);
1481 TreeSet<Integer> result2 = toSortedSet(col2);
1482 assertEquals(l(1, 2, 3), new ArrayList<>(result2));
1483
1484
1485 assertNull(toSortedSet((Collection<String>)null));
1486 }
1487
1488
1489
1490
1491 @Test
1492 void a086_toSortedSet_collectionBoolean() {
1493 Collection<String> col = list("c", "a", "b");
1494 TreeSet<String> result1 = toSortedSet(col, false);
1495 assertNotNull(result1);
1496 assertEquals(3, result1.size());
1497
1498 Collection<String> empty = list();
1499 assertNull(toSortedSet(empty, true));
1500 assertNotNull(toSortedSet(empty, false));
1501 assertNull(toSortedSet((Collection<String>)null, false));
1502 }
1503
1504
1505
1506
1507 @Test
1508 void a087_toStream() {
1509 String[] arr = {"a", "b", "c"};
1510 List<Object> result = toStream(arr).toList();
1511 assertEquals(3, result.size());
1512 assertEquals("a", result.get(0));
1513 }
1514
1515
1516
1517
1518 @Test
1519 void a088_toStringArray() {
1520 Collection<Integer> col = list(1, 2, 3);
1521 String[] result = toStringArray(col);
1522 assertNotNull(result);
1523 assertEquals(3, result.length);
1524 assertEquals("1", result[0]);
1525 assertEquals("2", result[1]);
1526 assertEquals("3", result[2]);
1527 }
1528
1529
1530
1531
1532 @Test
1533 void a089_u_list() {
1534 List<String> list = list("a", "b");
1535 List<String> result = u(list);
1536 assertNotNull(result);
1537 assertThrows(UnsupportedOperationException.class, () -> result.add("c"));
1538 assertNull(u((List<String>)null));
1539 }
1540
1541
1542
1543
1544 @Test
1545 void a090_u_map() {
1546 Map<String, Integer> map = map("a", 1);
1547 Map<String, Integer> result = u(map);
1548 assertNotNull(result);
1549 assertThrows(UnsupportedOperationException.class, () -> result.put("b", 2));
1550 assertNull(u((Map<String, Integer>)null));
1551 }
1552
1553
1554
1555
1556 @Test
1557 void a091_u_set() {
1558 Set<String> set = set("a", "b");
1559 Set<String> result = u(set);
1560 assertNotNull(result);
1561 assertThrows(UnsupportedOperationException.class, () -> result.add("c"));
1562 assertNull(u((Set<String>)null));
1563 }
1564
1565
1566
1567
1568 @Test
1569 void a092_al() {
1570 ArrayList<String> list = al("a", "b", "c");
1571 assertNotNull(list);
1572 assertEquals(3, list.size());
1573 assertEquals("a", list.get(0));
1574 assertEquals("b", list.get(1));
1575 assertEquals("c", list.get(2));
1576
1577
1578 ArrayList<String> empty = al();
1579 assertNotNull(empty);
1580 assertEquals(0, empty.size());
1581
1582
1583 list.add("d");
1584 assertEquals(4, list.size());
1585 }
1586
1587
1588
1589
1590 @Test
1591 void a093_ll() {
1592 LinkedList<String> list = ll("a", "b", "c");
1593 assertNotNull(list);
1594 assertEquals(3, list.size());
1595 assertEquals("a", list.get(0));
1596 assertEquals("b", list.get(1));
1597 assertEquals("c", list.get(2));
1598
1599
1600 LinkedList<String> empty = ll();
1601 assertNotNull(empty);
1602 assertEquals(0, empty.size());
1603
1604
1605 list.add("d");
1606 assertEquals(4, list.size());
1607 }
1608
1609
1610
1611
1612 @Test
1613 void a094_hs() {
1614 HashSet<String> set = hs("a", "b", "c");
1615 assertNotNull(set);
1616 assertEquals(3, set.size());
1617 assertTrue(set.contains("a"));
1618 assertTrue(set.contains("b"));
1619 assertTrue(set.contains("c"));
1620
1621
1622 HashSet<String> empty = hs();
1623 assertNotNull(empty);
1624 assertEquals(0, empty.size());
1625
1626
1627 set.add("d");
1628 assertEquals(4, set.size());
1629
1630
1631 set.add("a");
1632 assertEquals(4, set.size());
1633 }
1634
1635
1636
1637
1638 @Test
1639 void a095_ts() {
1640 TreeSet<String> set = ts("c", "a", "b");
1641 assertNotNull(set);
1642 assertEquals(3, set.size());
1643
1644 assertEquals("a", set.first());
1645 assertEquals("c", set.last());
1646
1647
1648 TreeSet<String> empty = ts();
1649 assertNotNull(empty);
1650 assertEquals(0, empty.size());
1651
1652
1653 set.add("d");
1654 assertEquals(4, set.size());
1655 assertEquals("d", set.last());
1656
1657
1658 set.add("a");
1659 assertEquals(4, set.size());
1660
1661
1662 TreeSet<Integer> intSet = ts(3, 1, 2);
1663 assertEquals(1, intSet.first());
1664 assertEquals(3, intSet.last());
1665 }
1666 }