1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections4;
18
19 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
20 import static org.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertFalse;
22 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
23 import static org.junit.jupiter.api.Assertions.assertNull;
24 import static org.junit.jupiter.api.Assertions.assertSame;
25 import static org.junit.jupiter.api.Assertions.assertThrows;
26 import static org.junit.jupiter.api.Assertions.assertTrue;
27
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.Comparator;
33 import java.util.Enumeration;
34 import java.util.HashMap;
35 import java.util.HashSet;
36 import java.util.Hashtable;
37 import java.util.Iterator;
38 import java.util.LinkedHashMap;
39 import java.util.LinkedList;
40 import java.util.List;
41 import java.util.Map;
42 import java.util.Objects;
43 import java.util.Queue;
44 import java.util.Set;
45 import java.util.SortedMap;
46 import java.util.TreeMap;
47 import java.util.Vector;
48
49 import org.apache.commons.collections4.bag.HashBag;
50 import org.apache.commons.collections4.collection.PredicatedCollection;
51 import org.apache.commons.collections4.collection.SynchronizedCollection;
52 import org.apache.commons.collections4.collection.TransformedCollection;
53 import org.apache.commons.collections4.collection.UnmodifiableCollection;
54 import org.apache.commons.collections4.functors.DefaultEquator;
55 import org.apache.commons.collections4.functors.EqualPredicate;
56 import org.apache.commons.collections4.functors.InstanceofPredicate;
57 import org.apache.commons.collections4.functors.UniquePredicate;
58 import org.apache.commons.collections4.queue.CircularFifoQueue;
59 import org.apache.commons.lang3.ArrayUtils;
60 import org.junit.jupiter.api.BeforeEach;
61 import org.junit.jupiter.api.Test;
62
63
64
65
66 @SuppressWarnings("boxing")
67 public class CollectionUtilsTest extends MockTestCase {
68
69 private static final Predicate<Number> EQUALS_TWO = input -> input.intValue() == 2;
70
71
72
73
74 private List<Integer> collectionA;
75
76
77
78
79 private List<Long> collectionB;
80
81
82
83
84
85 private Collection<Integer> collectionC;
86
87
88
89
90 private Collection<Integer> collectionD;
91
92
93
94
95 private Collection<Integer> collectionE;
96
97
98
99
100 private Collection<Number> collectionA2;
101
102
103
104
105 private Collection<Number> collectionB2;
106
107
108
109
110
111 private Collection<Number> collectionC2;
112
113 private Iterable<Integer> iterableA;
114
115 private Iterable<Long> iterableB;
116
117 private Iterable<Integer> iterableC;
118
119 private Iterable<Number> iterableA2;
120
121 private Iterable<Number> iterableB2;
122
123 private final Collection<Integer> emptyCollection = new ArrayList<>(1);
124
125 Transformer<Object, Integer> TRANSFORM_TO_INTEGER = input -> Integer.valueOf(((Long) input).intValue());
126
127 private void assertCollectResult(final Collection<Number> collection) {
128 assertTrue(collectionA.contains(1) && !collectionA.contains(2L));
129 assertTrue(collection.contains(2L) && !collection.contains(1));
130 }
131
132 @Test
133 @Deprecated
134 public void cardinality() {
135 assertEquals(1, CollectionUtils.cardinality(1, iterableA));
136 assertEquals(2, CollectionUtils.cardinality(2, iterableA));
137 assertEquals(3, CollectionUtils.cardinality(3, iterableA));
138 assertEquals(4, CollectionUtils.cardinality(4, iterableA));
139 assertEquals(0, CollectionUtils.cardinality(5, iterableA));
140
141 assertEquals(0, CollectionUtils.cardinality(1L, iterableB));
142 assertEquals(4, CollectionUtils.cardinality(2L, iterableB));
143 assertEquals(3, CollectionUtils.cardinality(3L, iterableB));
144 assertEquals(2, CollectionUtils.cardinality(4L, iterableB));
145 assertEquals(1, CollectionUtils.cardinality(5L, iterableB));
146
147
148
149
150 assertEquals(0, CollectionUtils.cardinality(2L, iterableA2));
151 assertEquals(0, CollectionUtils.cardinality(2, iterableB2));
152
153 final Set<String> set = new HashSet<>();
154 set.add("A");
155 set.add("C");
156 set.add("E");
157 set.add("E");
158 assertEquals(1, CollectionUtils.cardinality("A", set));
159 assertEquals(0, CollectionUtils.cardinality("B", set));
160 assertEquals(1, CollectionUtils.cardinality("C", set));
161 assertEquals(0, CollectionUtils.cardinality("D", set));
162 assertEquals(1, CollectionUtils.cardinality("E", set));
163
164 final Bag<String> bag = new HashBag<>();
165 bag.add("A", 3);
166 bag.add("C");
167 bag.add("E");
168 bag.add("E");
169 assertEquals(3, CollectionUtils.cardinality("A", bag));
170 assertEquals(0, CollectionUtils.cardinality("B", bag));
171 assertEquals(1, CollectionUtils.cardinality("C", bag));
172 assertEquals(0, CollectionUtils.cardinality("D", bag));
173 assertEquals(2, CollectionUtils.cardinality("E", bag));
174 }
175
176 @Test
177 @Deprecated
178 public void cardinalityOfNull() {
179 final List<String> list = new ArrayList<>();
180 assertEquals(0, CollectionUtils.cardinality(null, list));
181 {
182 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
183 assertNull(freq.get(null));
184 }
185 list.add("A");
186 assertEquals(0, CollectionUtils.cardinality(null, list));
187 {
188 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
189 assertNull(freq.get(null));
190 }
191 list.add(null);
192 assertEquals(1, CollectionUtils.cardinality(null, list));
193 {
194 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
195 assertEquals(Integer.valueOf(1), freq.get(null));
196 }
197 list.add("B");
198 assertEquals(1, CollectionUtils.cardinality(null, list));
199 {
200 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
201 assertEquals(Integer.valueOf(1), freq.get(null));
202 }
203 list.add(null);
204 assertEquals(2, CollectionUtils.cardinality(null, list));
205 {
206 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
207 assertEquals(Integer.valueOf(2), freq.get(null));
208 }
209 list.add("B");
210 assertEquals(2, CollectionUtils.cardinality(null, list));
211 {
212 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
213 assertEquals(Integer.valueOf(2), freq.get(null));
214 }
215 list.add(null);
216 assertEquals(3, CollectionUtils.cardinality(null, list));
217 {
218 final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
219 assertEquals(Integer.valueOf(3), freq.get(null));
220 }
221 }
222
223 @Test
224 @Deprecated
225 public void countMatches() {
226 assertEquals(4, CollectionUtils.countMatches(iterableB, EQUALS_TWO));
227 assertEquals(0, CollectionUtils.countMatches(iterableA, null));
228 assertEquals(0, CollectionUtils.countMatches(null, EQUALS_TWO));
229 assertEquals(0, CollectionUtils.countMatches(null, null));
230 }
231
232 @Test
233 @Deprecated
234 public void exists() {
235 final List<Integer> list = new ArrayList<>();
236 assertFalse(CollectionUtils.exists(null, null));
237 assertFalse(CollectionUtils.exists(list, null));
238 assertFalse(CollectionUtils.exists(null, EQUALS_TWO));
239 assertFalse(CollectionUtils.exists(list, EQUALS_TWO));
240 list.add(1);
241 list.add(3);
242 list.add(4);
243 assertFalse(CollectionUtils.exists(list, EQUALS_TWO));
244
245 list.add(2);
246 assertTrue(CollectionUtils.exists(list, EQUALS_TWO));
247 }
248
249 @Test
250 @Deprecated
251 public void find() {
252 Predicate<Number> testPredicate = EqualPredicate.equalPredicate((Number) 4);
253 Integer test = CollectionUtils.find(collectionA, testPredicate);
254 assertEquals(4, (int) test);
255 testPredicate = EqualPredicate.equalPredicate((Number) 45);
256 test = CollectionUtils.find(collectionA, testPredicate);
257 assertNull(test);
258 assertNull(CollectionUtils.find(null, testPredicate));
259 assertNull(CollectionUtils.find(collectionA, null));
260 }
261
262 @Test
263 @Deprecated
264 public void forAllButLastDoCollection() {
265 final Closure<List<? extends Number>> testClosure = ClosureUtils.invokerClosure("clear");
266 final Collection<List<? extends Number>> col = new ArrayList<>();
267 col.add(collectionA);
268 col.add(collectionB);
269 List<? extends Number> lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
270 assertSame(lastElement, collectionB);
271 assertTrue(collectionA.isEmpty() && !collectionB.isEmpty());
272
273 col.clear();
274 col.add(collectionB);
275 lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
276 assertSame(lastElement, collectionB);
277 assertFalse(collectionB.isEmpty());
278
279 col.clear();
280 lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
281 assertNull(lastElement);
282
283 final Collection<String> strings = Arrays.asList("a", "b", "c");
284 final StringBuilder result = new StringBuilder();
285 result.append(CollectionUtils.forAllButLastDo(strings, (Closure<String>) input -> result.append(input + ";")));
286 assertEquals("a;b;c", result.toString());
287
288 final Collection<String> oneString = Arrays.asList("a");
289 final StringBuilder resultOne = new StringBuilder();
290 resultOne.append(CollectionUtils.forAllButLastDo(oneString, (Closure<String>) input -> resultOne.append(input + ";")));
291 assertEquals("a", resultOne.toString());
292 assertNull(CollectionUtils.forAllButLastDo(strings, (Closure<String>) null));
293 assertNull(CollectionUtils.forAllButLastDo((Collection<String>) null, (Closure<String>) null));
294 }
295
296 @Test
297 @Deprecated
298 public void forAllButLastDoIterator() {
299 final Closure<List<? extends Number>> testClosure = ClosureUtils.invokerClosure("clear");
300 final Collection<List<? extends Number>> col = new ArrayList<>();
301 col.add(collectionA);
302 col.add(collectionB);
303 final List<? extends Number> lastElement = CollectionUtils.forAllButLastDo(col.iterator(), testClosure);
304 assertSame(lastElement, collectionB);
305 assertTrue(collectionA.isEmpty() && !collectionB.isEmpty());
306
307 assertNull(CollectionUtils.forAllButLastDo(col.iterator(), (Closure<List<? extends Number>>) null));
308 assertNull(CollectionUtils.forAllButLastDo((Iterator<String>) null, (Closure<String>) null));
309 }
310
311 @Test
312 @Deprecated
313 public void forAllDoCollection() {
314 final Closure<Collection<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
315 final Collection<Collection<Integer>> col = new ArrayList<>();
316 col.add(collectionA);
317 col.add(collectionC);
318 Closure<Collection<Integer>> resultClosure = CollectionUtils.forAllDo(col, testClosure);
319 assertSame(testClosure, resultClosure);
320 assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
321
322 resultClosure = CollectionUtils.forAllDo(col, (Closure<Collection<Integer>>) null);
323 assertNull(resultClosure);
324 assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
325 resultClosure = CollectionUtils.forAllDo((Collection<Collection<Integer>>) null, testClosure);
326 col.add(null);
327
328 CollectionUtils.forAllDo(col, testClosure);
329 }
330
331 @Test
332 @Deprecated
333 public void forAllDoFailure() {
334 final Closure<String> testClosure = ClosureUtils.invokerClosure("clear");
335 final Collection<String> col = new ArrayList<>();
336 col.add("x");
337 assertThrows(FunctorException.class, () -> CollectionUtils.forAllDo(col, testClosure));
338 }
339
340 @Test
341 @Deprecated
342 public void forAllDoIterator() {
343 final Closure<Collection<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
344 final Collection<Collection<Integer>> col = new ArrayList<>();
345 col.add(collectionA);
346 col.add(collectionC);
347 Closure<Collection<Integer>> resultClosure = CollectionUtils.forAllDo(col.iterator(), testClosure);
348 assertSame(testClosure, resultClosure);
349 assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
350
351 resultClosure = CollectionUtils.forAllDo(col.iterator(), (Closure<Collection<Integer>>) null);
352 assertNull(resultClosure);
353 assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
354 resultClosure = CollectionUtils.forAllDo((Iterator<Collection<Integer>>) null, testClosure);
355 col.add(null);
356
357 CollectionUtils.forAllDo(col.iterator(), testClosure);
358 }
359
360 @Test
361 @Deprecated
362 public void getFromEnumeration() throws Exception {
363
364 final Vector<String> vector = new Vector<>();
365 vector.addElement("zero");
366 vector.addElement("one");
367 Enumeration<String> en = vector.elements();
368 assertEquals("zero", CollectionUtils.get(en, 0));
369 en = vector.elements();
370 assertEquals("one", CollectionUtils.get(en, 1));
371
372
373 final Enumeration<String> finalEn = en;
374 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(finalEn, 3),
375 "Expecting IndexOutOfBoundsException.");
376
377 assertFalse(en.hasMoreElements());
378 }
379
380 @Test
381 @Deprecated
382 public void getFromIterable() throws Exception {
383
384 final Bag<String> bag = new HashBag<>();
385 bag.add("element", 1);
386 assertEquals("element", CollectionUtils.get(bag, 0));
387
388
389 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(bag, 1));
390 }
391
392 @Test
393 @Deprecated
394 public void getFromIterator() throws Exception {
395
396 Iterator<Integer> iterator = iterableA.iterator();
397 assertEquals(1, (int) CollectionUtils.get(iterator, 0));
398 iterator = iterableA.iterator();
399 assertEquals(2, (int) CollectionUtils.get(iterator, 1));
400
401
402 final Iterator<Integer> finalIterator = iterator;
403 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(finalIterator, 10),
404 "Expecting IndexOutOfBoundsException.");
405
406 assertFalse(iterator.hasNext());
407 }
408
409
410
411
412 private <T> void next(final Iterator<T> iterator, final T t) {
413 expect(iterator.hasNext()).andReturn(true);
414 expect(iterator.next()).andReturn(t);
415 }
416
417 @BeforeEach
418 public void setUp() {
419 collectionA = new ArrayList<>();
420 collectionA.add(1);
421 collectionA.add(2);
422 collectionA.add(2);
423 collectionA.add(3);
424 collectionA.add(3);
425 collectionA.add(3);
426 collectionA.add(4);
427 collectionA.add(4);
428 collectionA.add(4);
429 collectionA.add(4);
430 collectionB = new LinkedList<>();
431 collectionB.add(5L);
432 collectionB.add(4L);
433 collectionB.add(4L);
434 collectionB.add(3L);
435 collectionB.add(3L);
436 collectionB.add(3L);
437 collectionB.add(2L);
438 collectionB.add(2L);
439 collectionB.add(2L);
440 collectionB.add(2L);
441
442 collectionC = new ArrayList<>();
443 for (final Long l : collectionB) {
444 collectionC.add(l.intValue());
445 }
446
447 iterableA = collectionA;
448 iterableB = collectionB;
449 iterableC = collectionC;
450 collectionA2 = new ArrayList<>(collectionA);
451 collectionB2 = new LinkedList<>(collectionB);
452 collectionC2 = new LinkedList<>(collectionC);
453 iterableA2 = collectionA2;
454 iterableB2 = collectionB2;
455
456 collectionD = new ArrayList<>();
457 collectionD.add(1);
458 collectionD.add(3);
459 collectionD.add(3);
460 collectionD.add(3);
461 collectionD.add(5);
462 collectionD.add(7);
463 collectionD.add(7);
464 collectionD.add(10);
465
466 collectionE = new ArrayList<>();
467 collectionE.add(2);
468 collectionE.add(4);
469 collectionE.add(4);
470 collectionE.add(5);
471 collectionE.add(6);
472 collectionE.add(6);
473 collectionE.add(9);
474 }
475
476 @Test
477 public void testAddAllForElements() {
478 CollectionUtils.addAll(collectionA, 5);
479 assertTrue(collectionA.contains(5));
480 }
481
482 @Test
483 public void testAddAllForEnumeration() {
484 final Hashtable<Integer, Integer> h = new Hashtable<>();
485 h.put(5, 5);
486 final Enumeration<? extends Integer> enumeration = h.keys();
487 CollectionUtils.addAll(collectionA, enumeration);
488 assertTrue(collectionA.contains(5));
489 }
490
491
492
493
494
495
496
497 @Test
498 public void testAddAllForIterable() {
499 final Collection<Integer> inputCollection = createMock(Collection.class);
500 final Iterable<Integer> inputIterable = inputCollection;
501 final Iterable<Long> iterable = createMock(Iterable.class);
502 final Iterator<Long> iterator = createMock(Iterator.class);
503 final Collection<Number> c = createMock(Collection.class);
504
505 expect(iterable.iterator()).andReturn(iterator);
506 next(iterator, 1L);
507 next(iterator, 2L);
508 next(iterator, 3L);
509 expect(iterator.hasNext()).andReturn(false);
510 expect(c.add(1L)).andReturn(true);
511 expect(c.add(2L)).andReturn(true);
512 expect(c.add(3L)).andReturn(true);
513
514
515 expect(c.addAll(inputCollection)).andReturn(true);
516
517
518 expect(iterable.iterator()).andReturn(iterator);
519 next(iterator, 1L);
520 expect(iterator.hasNext()).andReturn(false);
521 expect(c.add(1L)).andReturn(false);
522 expect(c.addAll(inputCollection)).andReturn(false);
523
524 replay();
525 assertTrue(CollectionUtils.addAll(c, iterable));
526 assertTrue(CollectionUtils.addAll(c, inputIterable));
527
528 assertFalse(CollectionUtils.addAll(c, iterable));
529 assertFalse(CollectionUtils.addAll(c, inputIterable));
530 verify();
531 }
532
533 @Test
534 public void testaddAllNullColl1() {
535 final List<Integer> list = new ArrayList<>();
536 assertThrows(NullPointerException.class, () -> CollectionUtils.addAll(null, list));
537 }
538
539 @Test
540 public void testAddAllNullColl2() {
541 final List<Integer> list = new ArrayList<>();
542 final Iterable<Integer> list2 = null;
543 assertThrows(NullPointerException.class, () -> CollectionUtils.addAll(list, list2));
544 }
545
546 @Test
547 public void testAddAllNullColl3() {
548 final List<Integer> list = new ArrayList<>();
549 final Iterator<Integer> list2 = null;
550 assertThrows(NullPointerException.class, () -> CollectionUtils.addAll(list, list2));
551 }
552
553 @Test
554 public void testAddAllNullColl4() {
555 final List<Integer> list = new ArrayList<>();
556 final Enumeration<Integer> enumArray = null;
557 assertThrows(NullPointerException.class, () -> CollectionUtils.addAll(list, enumArray));
558 }
559
560 @Test
561 public void testAddAllNullColl5() {
562 final List<Integer> list = new ArrayList<>();
563 final Integer[] array = null;
564 assertThrows(NullPointerException.class, () -> CollectionUtils.addAll(list, array));
565 }
566
567 @Test
568 public void testAddIgnoreNull() {
569 final Set<String> set = new HashSet<>();
570 set.add("1");
571 set.add("2");
572 set.add("3");
573 assertFalse(CollectionUtils.addIgnoreNull(set, null));
574 assertEquals(3, set.size());
575 assertFalse(CollectionUtils.addIgnoreNull(set, "1"));
576 assertEquals(3, set.size());
577 assertTrue(CollectionUtils.addIgnoreNull(set, "4"));
578 assertEquals(4, set.size());
579 assertTrue(set.contains("4"));
580 }
581
582 @Test
583 public void testAddIgnoreNullNullColl() {
584 assertThrows(NullPointerException.class, () -> CollectionUtils.addIgnoreNull(null, "1"));
585 }
586
587 @Test
588 public void testCollate() {
589 List<Integer> result = CollectionUtils.collate(emptyCollection, emptyCollection);
590 assertEquals(0, result.size(), "Merge empty with empty");
591
592 result = CollectionUtils.collate(collectionA, emptyCollection);
593 assertEquals(collectionA, result, "Merge empty with non-empty");
594
595 List<Integer> result1 = CollectionUtils.collate(collectionD, collectionE);
596 List<Integer> result2 = CollectionUtils.collate(collectionE, collectionD);
597 assertEquals(result1, result2, "Merge two lists 1");
598
599 final List<Integer> combinedList = new ArrayList<>(collectionD);
600 combinedList.addAll(collectionE);
601 Collections.sort(combinedList);
602
603 assertEquals(combinedList, result2, "Merge two lists 2");
604
605 final Comparator<Integer> reverseComparator =
606 ComparatorUtils.reversedComparator(ComparatorUtils.<Integer>naturalComparator());
607
608 result = CollectionUtils.collate(emptyCollection, emptyCollection, reverseComparator);
609 assertEquals(0, result.size(), "Comparator Merge empty with empty");
610
611 Collections.reverse((List<Integer>) collectionD);
612 Collections.reverse((List<Integer>) collectionE);
613 Collections.reverse(combinedList);
614
615 result1 = CollectionUtils.collate(collectionD, collectionE, reverseComparator);
616 result2 = CollectionUtils.collate(collectionE, collectionD, reverseComparator);
617 assertEquals(result1, result2, "Comparator Merge two lists 1");
618 assertEquals(combinedList, result2, "Comparator Merge two lists 2");
619 }
620
621 @Test
622 public void testCollateException0() {
623 assertThrows(NullPointerException.class, () -> CollectionUtils.collate(null, collectionC));
624 }
625
626 @Test
627 public void testCollateException1() {
628 assertThrows(NullPointerException.class, () -> CollectionUtils.collate(collectionA, null));
629 }
630
631 @Test
632 public void testCollateException2() {
633 assertThrows(NullPointerException.class, () -> CollectionUtils.collate(collectionA, collectionC, null));
634 }
635
636 @Test
637 public void testCollateIgnoreDuplicates() {
638 final List<Integer> result1 = CollectionUtils.collate(collectionD, collectionE, false);
639 final List<Integer> result2 = CollectionUtils.collate(collectionE, collectionD, false);
640 assertEquals(result1, result2, "Merge two lists 1 - ignore duplicates");
641
642 final Set<Integer> combinedSet = new HashSet<>(collectionD);
643 combinedSet.addAll(collectionE);
644 final List<Integer> combinedList = new ArrayList<>(combinedSet);
645 Collections.sort(combinedList);
646
647 assertEquals(combinedList, result2, "Merge two lists 2 - ignore duplicates");
648 }
649
650 @Test
651 public void testCollect() {
652 final Transformer<Number, Long> transformer = TransformerUtils.constantTransformer(2L);
653 Collection<Number> collection = CollectionUtils.<Integer, Number>collect(iterableA, transformer);
654 assertEquals(collection.size(), collectionA.size());
655 assertCollectResult(collection);
656
657 ArrayList<Number> list;
658 list = CollectionUtils.collect(collectionA, transformer, new ArrayList<>());
659 assertEquals(list.size(), collectionA.size());
660 assertCollectResult(list);
661
662 Iterator<Integer> iterator = null;
663 list = CollectionUtils.collect(iterator, transformer, new ArrayList<>());
664
665 iterator = iterableA.iterator();
666 list = CollectionUtils.collect(iterator, transformer, list);
667 assertEquals(collection.size(), collectionA.size());
668 assertCollectResult(collection);
669
670 iterator = collectionA.iterator();
671 collection = CollectionUtils.<Integer, Number>collect(iterator, transformer);
672 assertEquals(collection.size(), collectionA.size());
673 assertTrue(collection.contains(2L) && !collection.contains(1));
674 collection = CollectionUtils.collect((Iterator<Integer>) null, (Transformer<Integer, Number>) null);
675 assertTrue(collection.isEmpty());
676
677 final int size = collectionA.size();
678 collectionB = CollectionUtils.collect((Collection<Integer>) null, transformer, collectionB);
679 assertTrue(collectionA.size() == size && collectionA.contains(1));
680 CollectionUtils.collect(collectionB, null, collectionA);
681 assertTrue(collectionA.size() == size && collectionA.contains(1));
682 }
683
684 @Test
685 public void testContainsAll() {
686 final Collection<String> empty = new ArrayList<>(0);
687 final Collection<String> one = new ArrayList<>(1);
688 one.add("1");
689 final Collection<String> two = new ArrayList<>(1);
690 two.add("2");
691 final Collection<String> three = new ArrayList<>(1);
692 three.add("3");
693 final Collection<String> odds = new ArrayList<>(2);
694 odds.add("1");
695 odds.add("3");
696 final Collection<String> multiples = new ArrayList<>(3);
697 multiples.add("1");
698 multiples.add("3");
699 multiples.add("1");
700
701 assertFalse(CollectionUtils.containsAll(one, odds), "containsAll({1},{1,3}) should return false.");
702 assertTrue(CollectionUtils.containsAll(odds, one), "containsAll({1,3},{1}) should return true.");
703 assertFalse(CollectionUtils.containsAll(three, odds), "containsAll({3},{1,3}) should return false.");
704 assertTrue(CollectionUtils.containsAll(odds, three), "containsAll({1,3},{3}) should return true.");
705 assertTrue(CollectionUtils.containsAll(two, two), "containsAll({2},{2}) should return true.");
706 assertTrue(CollectionUtils.containsAll(odds, odds), "containsAll({1,3},{1,3}) should return true.");
707
708 assertFalse(CollectionUtils.containsAll(two, odds), "containsAll({2},{1,3}) should return false.");
709 assertFalse(CollectionUtils.containsAll(odds, two), "containsAll({1,3},{2}) should return false.");
710 assertFalse(CollectionUtils.containsAll(one, three), "containsAll({1},{3}) should return false.");
711 assertFalse(CollectionUtils.containsAll(three, one), "containsAll({3},{1}) should return false.");
712 assertTrue(CollectionUtils.containsAll(odds, empty), "containsAll({1,3},{}) should return true.");
713 assertFalse(CollectionUtils.containsAll(empty, odds), "containsAll({},{1,3}) should return false.");
714 assertTrue(CollectionUtils.containsAll(empty, empty), "containsAll({},{}) should return true.");
715
716 assertTrue(CollectionUtils.containsAll(odds, multiples), "containsAll({1,3},{1,3,1}) should return true.");
717 assertTrue(CollectionUtils.containsAll(odds, odds), "containsAll({1,3,1},{1,3,1}) should return true.");
718 }
719
720 @Test
721 public void testContainsAnyInArray() {
722 final Collection<String> empty = new ArrayList<>(0);
723 final String[] emptyArr = {};
724 final Collection<String> one = new ArrayList<>(1);
725 one.add("1");
726 final String[] oneArr = {"1"};
727 final Collection<String> two = new ArrayList<>(1);
728 two.add("2");
729 final String[] twoArr = {"2"};
730 final Collection<String> three = new ArrayList<>(1);
731 three.add("3");
732 final String[] threeArr = {"3"};
733 final Collection<String> odds = new ArrayList<>(2);
734 odds.add("1");
735 odds.add("3");
736 final String[] oddsArr = {"1", "3"};
737
738 assertTrue(CollectionUtils.containsAny(one, oddsArr), "containsAny({1},{1,3}) should return true.");
739 assertTrue(CollectionUtils.containsAny(odds, oneArr), "containsAny({1,3},{1}) should return true.");
740 assertTrue(CollectionUtils.containsAny(three, oddsArr), "containsAny({3},{1,3}) should return true.");
741 assertTrue(CollectionUtils.containsAny(odds, threeArr), "containsAny({1,3},{3}) should return true.");
742 assertTrue(CollectionUtils.containsAny(two, twoArr), "containsAny({2},{2}) should return true.");
743 assertTrue(CollectionUtils.containsAny(odds, oddsArr), "containsAny({1,3},{1,3}) should return true.");
744
745 assertFalse(CollectionUtils.containsAny(two, oddsArr), "containsAny({2},{1,3}) should return false.");
746 assertFalse(CollectionUtils.containsAny(odds, twoArr), "containsAny({1,3},{2}) should return false.");
747 assertFalse(CollectionUtils.containsAny(one, threeArr), "containsAny({1},{3}) should return false.");
748 assertFalse(CollectionUtils.containsAny(three, oneArr), "containsAny({3},{1}) should return false.");
749 assertFalse(CollectionUtils.containsAny(odds, emptyArr), "containsAny({1,3},{}) should return false.");
750 assertFalse(CollectionUtils.containsAny(empty, oddsArr), "containsAny({},{1,3}) should return false.");
751 assertFalse(CollectionUtils.containsAny(empty, emptyArr), "containsAny({},{}) should return false.");
752 }
753
754 @Test
755 public void testContainsAnyInArrayNullArray() {
756 final Collection<String> list = new ArrayList<>(1);
757 list.add("1");
758 final String[] array = null;
759 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(list, array));
760 }
761
762 @Test
763 public void testContainsAnyInArrayNullColl1() {
764 final String[] oneArr = {"1"};
765 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(null, oneArr));
766 }
767
768 @Test
769 public void testContainsAnyInArrayNullColl2() {
770 final Collection<String> list = new ArrayList<>(1);
771 list.add("1");
772 final Collection<String> list2 = null;
773 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(list, list2));
774 }
775
776 @Test
777 public void testContainsAnyInCollection() {
778 final Collection<String> empty = new ArrayList<>(0);
779 final Collection<String> one = new ArrayList<>(1);
780 one.add("1");
781 final Collection<String> two = new ArrayList<>(1);
782 two.add("2");
783 final Collection<String> three = new ArrayList<>(1);
784 three.add("3");
785 final Collection<String> odds = new ArrayList<>(2);
786 odds.add("1");
787 odds.add("3");
788
789 assertTrue(CollectionUtils.containsAny(one, odds), "containsAny({1},{1,3}) should return true.");
790 assertTrue(CollectionUtils.containsAny(odds, one), "containsAny({1,3},{1}) should return true.");
791 assertTrue(CollectionUtils.containsAny(three, odds), "containsAny({3},{1,3}) should return true.");
792 assertTrue(CollectionUtils.containsAny(odds, three), "containsAny({1,3},{3}) should return true.");
793 assertTrue(CollectionUtils.containsAny(two, two), "containsAny({2},{2}) should return true.");
794 assertTrue(CollectionUtils.containsAny(odds, odds), "containsAny({1,3},{1,3}) should return true.");
795
796 assertFalse(CollectionUtils.containsAny(two, odds), "containsAny({2},{1,3}) should return false.");
797 assertFalse(CollectionUtils.containsAny(odds, two), "containsAny({1,3},{2}) should return false.");
798 assertFalse(CollectionUtils.containsAny(one, three), "containsAny({1},{3}) should return false.");
799 assertFalse(CollectionUtils.containsAny(three, one), "containsAny({3},{1}) should return false.");
800 assertFalse(CollectionUtils.containsAny(odds, empty), "containsAny({1,3},{}) should return false.");
801 assertFalse(CollectionUtils.containsAny(empty, odds), "containsAny({},{1,3}) should return false.");
802 assertFalse(CollectionUtils.containsAny(empty, empty), "containsAny({},{}) should return false.");
803 }
804
805 @Test
806 public void testContainsAnyNullColl1() {
807 final Collection<String> list = new ArrayList<>(1);
808 list.add("1");
809 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(null, list));
810 }
811
812 @Test
813 public void testContainsAnyNullColl2() {
814 final Collection<String> list = new ArrayList<>(1);
815 list.add("1");
816 final Collection<String> list2 = null;
817 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(list, list2));
818 }
819
820 @Test
821 public void testContainsAnyNullColl3() {
822 final Collection<String> list = new ArrayList<>(1);
823 list.add("1");
824 final String[] array = null;
825 assertThrows(NullPointerException.class, () -> CollectionUtils.containsAny(list, array));
826 }
827
828 @Test
829 public void testDisjunction() {
830 final Collection<Integer> col = CollectionUtils.disjunction(iterableA, iterableC);
831 final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
832 assertEquals(Integer.valueOf(1), freq.get(1));
833 assertEquals(Integer.valueOf(2), freq.get(2));
834 assertNull(freq.get(3));
835 assertEquals(Integer.valueOf(2), freq.get(4));
836 assertEquals(Integer.valueOf(1), freq.get(5));
837
838 final Collection<Number> col2 = CollectionUtils.disjunction(collectionC2, collectionA);
839 final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
840 assertEquals(Integer.valueOf(1), freq2.get(1));
841 assertEquals(Integer.valueOf(2), freq2.get(2));
842 assertNull(freq2.get(3));
843 assertEquals(Integer.valueOf(2), freq2.get(4));
844 assertEquals(Integer.valueOf(1), freq2.get(5));
845 }
846
847 @Test
848 public void testDisjunctionAsSymmetricDifference() {
849 final Collection<Number> dis = CollectionUtils.<Number>disjunction(collectionA, collectionC);
850 final Collection<Number> amb = CollectionUtils.<Number>subtract(collectionA, collectionC);
851 final Collection<Number> bma = CollectionUtils.<Number>subtract(collectionC, collectionA);
852 assertTrue(CollectionUtils.isEqualCollection(dis, CollectionUtils.union(amb, bma)));
853 }
854
855 @Test
856 public void testDisjunctionAsUnionMinusIntersection() {
857 final Collection<Number> dis = CollectionUtils.<Number>disjunction(collectionA, collectionC);
858 final Collection<Number> un = CollectionUtils.<Number>union(collectionA, collectionC);
859 final Collection<Number> inter = CollectionUtils.<Number>intersection(collectionA, collectionC);
860 assertTrue(CollectionUtils.isEqualCollection(dis, CollectionUtils.subtract(un, inter)));
861 }
862
863 @Test
864 public void testDisjunctionNullColl1() {
865 final Collection<String> list = new ArrayList<>(1);
866 list.add("1");
867 assertThrows(NullPointerException.class, () -> CollectionUtils.disjunction(null, list));
868 }
869
870 @Test
871 public void testDisjunctionNullColl2() {
872 final Collection<String> list = new ArrayList<>(1);
873 list.add("1");
874 assertThrows(NullPointerException.class, () -> CollectionUtils.disjunction(list, null));
875 }
876
877 @Test
878 public void testEmptyCollection() throws Exception {
879 final Collection<Number> coll = CollectionUtils.emptyCollection();
880 assertEquals(CollectionUtils.EMPTY_COLLECTION, coll);
881 }
882
883 @Test
884 public void testEmptyIfNull() {
885 assertTrue(CollectionUtils.emptyIfNull(null).isEmpty());
886 final Collection<Object> collection = new ArrayList<>();
887 assertSame(collection, CollectionUtils.emptyIfNull(collection));
888 }
889
890 @Test
891 public void testExtractSingleton() {
892 final ArrayList<String> collNull = null;
893 assertThrows(NullPointerException.class, () -> CollectionUtils.extractSingleton(collNull), "expected NullPointerException from extractSingleton(null)");
894 final ArrayList<String> collEmpty = new ArrayList<>();
895 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.extractSingleton(collEmpty),
896 "expected IllegalArgumentException from extractSingleton(empty)");
897 final ArrayList<String> coll = new ArrayList<>();
898 coll.add("foo");
899 assertEquals("foo", CollectionUtils.extractSingleton(coll));
900 coll.add("bar");
901 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.extractSingleton(coll),
902 "expected IllegalArgumentException from extractSingleton(size == 2)");
903 }
904
905
906 @Test
907 public void testFilter() {
908 final List<Integer> ints = new ArrayList<>();
909 ints.add(1);
910 ints.add(2);
911 ints.add(3);
912 ints.add(3);
913 final Iterable<Integer> iterable = ints;
914 assertTrue(CollectionUtils.filter(iterable, EQUALS_TWO));
915 assertEquals(1, ints.size());
916 assertEquals(2, (int) ints.get(0));
917 }
918
919 @Test
920 public void testFilterInverse() {
921 final List<Integer> ints = new ArrayList<>();
922 ints.add(1);
923 ints.add(2);
924 ints.add(3);
925 ints.add(3);
926 final Iterable<Integer> iterable = ints;
927 assertTrue(CollectionUtils.filterInverse(iterable, EQUALS_TWO));
928 assertEquals(3, ints.size());
929 assertEquals(1, (int) ints.get(0));
930 assertEquals(3, (int) ints.get(1));
931 assertEquals(3, (int) ints.get(2));
932 }
933
934 @Test
935 public void testFilterInverseNullParameters() throws Exception {
936 final List<Long> longs = Collections.nCopies(4, 10L);
937 assertFalse(CollectionUtils.filterInverse(longs, null));
938 assertEquals(4, longs.size());
939 assertFalse(CollectionUtils.filterInverse(null, EQUALS_TWO));
940 assertEquals(4, longs.size());
941 assertFalse(CollectionUtils.filterInverse(null, null));
942 assertEquals(4, longs.size());
943 }
944
945 @Test
946 public void testFilterNullParameters() throws Exception {
947 final List<Long> longs = Collections.nCopies(4, 10L);
948 assertFalse(CollectionUtils.filter(longs, null));
949 assertEquals(4, longs.size());
950 assertFalse(CollectionUtils.filter(null, EQUALS_TWO));
951 assertEquals(4, longs.size());
952 assertFalse(CollectionUtils.filter(null, null));
953 assertEquals(4, longs.size());
954 }
955
956 @Test
957 public void testGet() {
958 assertEquals(2, CollectionUtils.get(collectionA, 2));
959 assertEquals(2, CollectionUtils.get(collectionA.iterator(), 2));
960 final Map<Integer, Integer> map = CollectionUtils.getCardinalityMap(collectionA);
961
962 final Map<Integer, Integer> linkedMap = new LinkedHashMap<>(map);
963 assertEquals(linkedMap.entrySet().iterator().next(), CollectionUtils.get(linkedMap, 0));
964 }
965
966 @Test
967 public void testGet1() {
968 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.get((Object) null, 0));
969 }
970
971 @Test
972 public void testGetCardinalityMap() {
973 final Map<Number, Integer> freqA = CollectionUtils.<Number>getCardinalityMap(iterableA);
974 assertEquals(1, (int) freqA.get(1));
975 assertEquals(2, (int) freqA.get(2));
976 assertEquals(3, (int) freqA.get(3));
977 assertEquals(4, (int) freqA.get(4));
978 assertNull(freqA.get(5));
979
980 final Map<Long, Integer> freqB = CollectionUtils.getCardinalityMap(iterableB);
981 assertNull(freqB.get(1L));
982 assertEquals(4, (int) freqB.get(2L));
983 assertEquals(3, (int) freqB.get(3L));
984 assertEquals(2, (int) freqB.get(4L));
985 assertEquals(1, (int) freqB.get(5L));
986 }
987
988 @Test
989 public void testGetCardinalityMapNull() {
990 assertThrows(NullPointerException.class, () -> CollectionUtils.getCardinalityMap(null));
991 }
992
993 @Test
994 public void testGetEnumeration() {
995 final Vector<Integer> vectorA = new Vector<>(collectionA);
996 final Enumeration<Integer> e = vectorA.elements();
997 assertEquals(Integer.valueOf(2), CollectionUtils.get(e, 2));
998 assertTrue(e.hasMoreElements());
999 assertEquals(Integer.valueOf(4), CollectionUtils.get(e, 6));
1000 assertFalse(e.hasMoreElements());
1001 }
1002
1003 @Test
1004 public void testGetFromHashMap() {
1005
1006 final Map<String, String> expected = new HashMap<>();
1007 expected.put("zeroKey", "zero");
1008 expected.put("oneKey", "one");
1009 Map.Entry<String, String> entry = CollectionUtils.get(expected, 0);
1010 assertTrue(entry.toString().equals("zeroKey=zero") || entry.toString().equals("oneKey=one"));
1011 entry = CollectionUtils.get(expected, 1);
1012 assertTrue(entry.toString().equals("zeroKey=zero") || entry.toString().equals("oneKey=one"));
1013
1014 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(expected, 2));
1015 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(expected, -2));
1016 }
1017
1018 @Test
1019 public void testGetFromLinkedHashMap() {
1020
1021 final Map<String, String> expected = new LinkedHashMap<>();
1022 expected.put("zeroKey", "zero");
1023 expected.put("oneKey", "one");
1024
1025 final Map<String, String> found = new LinkedHashMap<>();
1026 Map.Entry<String, String> entry = CollectionUtils.get(expected, 0);
1027 found.put(entry.getKey(), entry.getValue());
1028 entry = CollectionUtils.get(expected, 1);
1029 found.put(entry.getKey(), entry.getValue());
1030 assertEquals(expected, found);
1031 }
1032
1033
1034
1035
1036
1037 @Test
1038 public void testGetFromList() throws Exception {
1039
1040 final List<String> list = createMock(List.class);
1041 expect(list.get(0)).andReturn("zero");
1042 expect(list.get(1)).andReturn("one");
1043 replay();
1044 final String string = CollectionUtils.get(list, 0);
1045 assertEquals("zero", string);
1046 assertEquals("one", CollectionUtils.get(list, 1));
1047
1048 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(new ArrayList<>(), 2));
1049 }
1050
1051 @Test
1052 public void testGetFromMapIndexOutOfRange() {
1053
1054 final Map<String, String> expected = new LinkedHashMap<>();
1055 expected.put("zeroKey", "zero");
1056 expected.put("oneKey", "one");
1057
1058 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(expected, 2));
1059 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(expected, -2));
1060 }
1061
1062 @Test
1063 public void testGetFromObject() throws Exception {
1064
1065 final Object obj = new Object();
1066 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.get(obj, 0));
1067 }
1068
1069 @Test
1070 public void testGetFromObjectArray() throws Exception {
1071
1072 final Object[] objArray = new Object[2];
1073 objArray[0] = "zero";
1074 objArray[1] = "one";
1075 assertEquals("zero", CollectionUtils.get(objArray, 0));
1076 assertEquals("one", CollectionUtils.get(objArray, 1));
1077
1078
1079
1080 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(objArray, 2));
1081 }
1082
1083 @Test
1084 public void testGetFromPrimitiveArray() throws Exception {
1085
1086 final int[] array = new int[2];
1087 array[0] = 10;
1088 array[1] = 20;
1089 assertEquals(10, CollectionUtils.get(array, 0));
1090 assertEquals(20, CollectionUtils.get(array, 1));
1091
1092
1093
1094 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(array, 2));
1095 }
1096
1097 @Test
1098 public void testGetFromTreeMap() {
1099
1100 final Map<String, String> expected = new LinkedHashMap<>();
1101 expected.put("zeroKey", "zero");
1102 expected.put("oneKey", "one");
1103
1104
1105 final SortedMap<String, String> map = new TreeMap<>();
1106 map.put("zeroKey", "zero");
1107 map.put("oneKey", "one");
1108 Map.Entry<String, String> test = CollectionUtils.get(map, 1);
1109 assertEquals("zeroKey", test.getKey());
1110 assertEquals("zero", test.getValue());
1111 test = CollectionUtils.get(map, 0);
1112 assertEquals("oneKey", test.getKey());
1113 assertEquals("one", test.getValue());
1114 }
1115
1116 @Test
1117 public void testGetIterator() {
1118 final Iterator<Integer> it = collectionA.iterator();
1119 assertEquals(Integer.valueOf(2), CollectionUtils.get(it, 2));
1120 assertTrue(it.hasNext());
1121 assertEquals(Integer.valueOf(4), CollectionUtils.get(it, 6));
1122 assertFalse(it.hasNext());
1123 }
1124
1125 @Test
1126 public void testGetNegative() {
1127 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(collectionA, -3));
1128 }
1129
1130 @Test
1131 public void testGetPositiveOutOfBounds() {
1132 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(collectionA.iterator(), 30));
1133 }
1134
1135 @Test
1136 public void testHashCode() {
1137 final Equator<Integer> e = new Equator<Integer>() {
1138 @Override
1139 public boolean equate(final Integer o1, final Integer o2) {
1140 if (o1 % 2 == 0 ^ o2 % 2 == 0) {
1141 return false;
1142 }
1143 return true;
1144 }
1145
1146 @Override
1147 public int hash(final Integer o) {
1148 return o == null ? 0 : Objects.hashCode(o);
1149 }
1150 };
1151
1152 assertEquals(collectionA.hashCode(), CollectionUtils.hashCode(collectionA, e));
1153 }
1154
1155 @Test
1156 public void testHashCodeNullCollection() {
1157 final Equator<Integer> e = new Equator<Integer>() {
1158 @Override
1159 public boolean equate(final Integer o1, final Integer o2) {
1160 if (o1 % 2 == 0 ^ o2 % 2 == 0) {
1161 return false;
1162 }
1163 return true;
1164 }
1165
1166 @Override
1167 public int hash(final Integer o) {
1168 return o == null ? 0 : Objects.hashCode(o);
1169 }
1170 };
1171
1172 final Collection<Integer> collection = null;
1173 assertEquals(0, CollectionUtils.hashCode(collection, e));
1174 }
1175
1176 @Test
1177 public void testHashCodeNullEquator() {
1178 assertThrows(NullPointerException.class, () -> CollectionUtils.hashCode(collectionB, null));
1179 }
1180
1181 @Test
1182 public void testIntersection() {
1183 final Collection<Integer> col = CollectionUtils.intersection(iterableA, iterableC);
1184 final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
1185 assertNull(freq.get(1));
1186 assertEquals(Integer.valueOf(2), freq.get(2));
1187 assertEquals(Integer.valueOf(3), freq.get(3));
1188 assertEquals(Integer.valueOf(2), freq.get(4));
1189 assertNull(freq.get(5));
1190
1191 final Collection<Number> col2 = CollectionUtils.intersection(collectionC2, collectionA);
1192 final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
1193 assertNull(freq2.get(1));
1194 assertEquals(Integer.valueOf(2), freq2.get(2));
1195 assertEquals(Integer.valueOf(3), freq2.get(3));
1196 assertEquals(Integer.valueOf(2), freq2.get(4));
1197 assertNull(freq2.get(5));
1198 }
1199
1200 @Test
1201 public void testIntersectionNullColl1() {
1202 final Collection<String> list = new ArrayList<>(1);
1203 list.add("1");
1204 assertThrows(NullPointerException.class, () -> CollectionUtils.intersection(null, list));
1205 }
1206
1207 @Test
1208 public void testIntersectionNullColl2() {
1209 final Collection<String> list = new ArrayList<>(1);
1210 list.add("1");
1211 assertThrows(NullPointerException.class, () -> CollectionUtils.intersection(list, null));
1212 }
1213
1214 @Test
1215 public void testIntersectionUsesMethodEquals() {
1216
1217 final Integer elta = 17;
1218 final Integer eltb = 17;
1219
1220
1221 assertSame(elta, eltb);
1222
1223
1224 final Collection<Number> cola = new ArrayList<>();
1225 final Collection<Integer> colb = new ArrayList<>();
1226
1227
1228
1229 cola.add(elta);
1230 colb.add(eltb);
1231
1232
1233
1234 final Collection<Number> intersection = CollectionUtils.intersection(cola, colb);
1235 assertEquals(1, intersection.size());
1236
1237
1238
1239
1240 final Object eltc = intersection.iterator().next();
1241 assertTrue(eltc == elta && eltc == eltb);
1242
1243
1244
1245 assertEquals(elta, eltc);
1246 assertEquals(eltc, elta);
1247 assertEquals(eltb, eltc);
1248 assertEquals(eltc, eltb);
1249 }
1250
1251 @Test
1252 public void testIsEmpty() {
1253 assertFalse(CollectionUtils.isNotEmpty(null));
1254 assertTrue(CollectionUtils.isNotEmpty(collectionA));
1255 }
1256
1257 @Test
1258 public void testIsEmptyWithEmptyCollection() {
1259 assertTrue(CollectionUtils.isEmpty(new ArrayList<>()));
1260 }
1261
1262 @Test
1263 public void testIsEmptyWithNonEmptyCollection() {
1264 assertFalse(CollectionUtils.isEmpty(Collections.singletonList("item")));
1265 }
1266
1267 @Test
1268 public void testIsEmptyWithNull() {
1269 assertTrue(CollectionUtils.isEmpty(null));
1270 }
1271
1272 @Test
1273 public void testIsEqualCollection() {
1274 assertFalse(CollectionUtils.isEqualCollection(collectionA, collectionC));
1275 assertFalse(CollectionUtils.isEqualCollection(collectionC, collectionA));
1276 }
1277
1278 @Test
1279 public void testIsEqualCollection2() {
1280 final Collection<String> a = new ArrayList<>();
1281 final Collection<String> b = new ArrayList<>();
1282 assertTrue(CollectionUtils.isEqualCollection(a, b));
1283 assertTrue(CollectionUtils.isEqualCollection(b, a));
1284 a.add("1");
1285 assertFalse(CollectionUtils.isEqualCollection(a, b));
1286 assertFalse(CollectionUtils.isEqualCollection(b, a));
1287 b.add("1");
1288 assertTrue(CollectionUtils.isEqualCollection(a, b));
1289 assertTrue(CollectionUtils.isEqualCollection(b, a));
1290 a.add("2");
1291 assertFalse(CollectionUtils.isEqualCollection(a, b));
1292 assertFalse(CollectionUtils.isEqualCollection(b, a));
1293 b.add("2");
1294 assertTrue(CollectionUtils.isEqualCollection(a, b));
1295 assertTrue(CollectionUtils.isEqualCollection(b, a));
1296 a.add("1");
1297 assertFalse(CollectionUtils.isEqualCollection(a, b));
1298 assertFalse(CollectionUtils.isEqualCollection(b, a));
1299 b.add("1");
1300 assertTrue(CollectionUtils.isEqualCollection(a, b));
1301 assertTrue(CollectionUtils.isEqualCollection(b, a));
1302 }
1303
1304 @Test
1305 public void testIsEqualCollectionEquator() {
1306 final Collection<Integer> collB = CollectionUtils.collect(collectionB, TRANSFORM_TO_INTEGER);
1307
1308
1309 final Equator<Integer> e = new Equator<Integer>() {
1310 @Override
1311 public boolean equate(final Integer o1, final Integer o2) {
1312 if (o1.intValue() % 2 == 0 ^ o2.intValue() % 2 == 0) {
1313 return false;
1314 }
1315 return true;
1316 }
1317
1318 @Override
1319 public int hash(final Integer o) {
1320 return o.intValue() % 2 == 0 ? Integer.valueOf(0).hashCode() : Integer.valueOf(1).hashCode();
1321 }
1322 };
1323
1324 assertTrue(CollectionUtils.isEqualCollection(collectionA, collectionA, e));
1325 assertTrue(CollectionUtils.isEqualCollection(collectionA, collB, e));
1326 assertTrue(CollectionUtils.isEqualCollection(collB, collectionA, e));
1327
1328 final Equator<Number> defaultEquator = DefaultEquator.defaultEquator();
1329 assertFalse(CollectionUtils.isEqualCollection(collectionA, collectionB, defaultEquator));
1330 assertFalse(CollectionUtils.isEqualCollection(collectionA, collB, defaultEquator));
1331 }
1332
1333 @Test
1334 public void testIsEqualCollectionNullColl1() {
1335 final Collection<Integer> list = new ArrayList<>(1);
1336 list.add(1);
1337
1338 final Equator<Integer> e = new Equator<Integer>() {
1339 @Override
1340 public boolean equate(final Integer o1, final Integer o2) {
1341 if (o1.intValue() % 2 == 0 ^ o2.intValue() % 2 == 0) {
1342 return false;
1343 }
1344 return true;
1345 }
1346
1347 @Override
1348 public int hash(final Integer o) {
1349 return o.intValue() % 2 == 0 ? Integer.valueOf(0).hashCode() : Integer.valueOf(1).hashCode();
1350 }
1351 };
1352 assertThrows(NullPointerException.class, () -> CollectionUtils.isEqualCollection(null, list, e));
1353 }
1354
1355 @Test
1356 public void testIsEqualCollectionNullColl2() {
1357 final Collection<Integer> list = new ArrayList<>(1);
1358 list.add(1);
1359
1360 final Equator<Integer> e = new Equator<Integer>() {
1361 @Override
1362 public boolean equate(final Integer o1, final Integer o2) {
1363 if (o1.intValue() % 2 == 0 ^ o2.intValue() % 2 == 0) {
1364 return false;
1365 }
1366 return true;
1367 }
1368
1369 @Override
1370 public int hash(final Integer o) {
1371 return o.intValue() % 2 == 0 ? Integer.valueOf(0).hashCode() : Integer.valueOf(1).hashCode();
1372 }
1373 };
1374 assertThrows(NullPointerException.class, () -> CollectionUtils.isEqualCollection(list, null, e));
1375 }
1376
1377 @Test
1378 public void testIsEqualCollectionNullEquator() {
1379 assertThrows(NullPointerException.class, () -> CollectionUtils.isEqualCollection(collectionA, collectionA, null));
1380 }
1381
1382 @Test
1383 public void testIsEqualCollectionReturnsFalse() {
1384 final List<Integer> b = new ArrayList<>(collectionA);
1385
1386 b.remove(1);
1387 b.add(5);
1388 assertFalse(CollectionUtils.isEqualCollection(collectionA, b));
1389 assertFalse(CollectionUtils.isEqualCollection(b, collectionA));
1390 }
1391
1392 @Test
1393 public void testIsEqualCollectionToSelf() {
1394 assertTrue(CollectionUtils.isEqualCollection(collectionA, collectionA));
1395 assertTrue(CollectionUtils.isEqualCollection(collectionB, collectionB));
1396 }
1397
1398 @Test
1399 public void testIsFull() {
1400 final Set<String> set = new HashSet<>();
1401 set.add("1");
1402 set.add("2");
1403 set.add("3");
1404 assertFalse(CollectionUtils.isFull(set));
1405
1406 final CircularFifoQueue<String> buf = new CircularFifoQueue<>(set);
1407 assertFalse(CollectionUtils.isFull(buf));
1408 buf.remove("2");
1409 assertFalse(CollectionUtils.isFull(buf));
1410 buf.add("2");
1411 assertFalse(CollectionUtils.isFull(buf));
1412 }
1413
1414 @Test
1415 public void testIsFullNullColl() {
1416 assertThrows(NullPointerException.class, () -> CollectionUtils.isFull(null));
1417 }
1418
1419 @Test
1420 public void testIsNotEmptyWithEmptyCollection() {
1421 assertFalse(CollectionUtils.isNotEmpty(new ArrayList<>()));
1422 }
1423
1424 @Test
1425 public void testIsNotEmptyWithNonEmptyCollection() {
1426 assertTrue(CollectionUtils.isNotEmpty(Collections.singletonList("item")));
1427 }
1428
1429 @Test
1430 public void testIsNotEmptyWithNull() {
1431 assertFalse(CollectionUtils.isNotEmpty(null));
1432 }
1433
1434 @Test
1435 public void testIsProperSubCollection() {
1436 final Collection<String> a = new ArrayList<>();
1437 final Collection<String> b = new ArrayList<>();
1438 assertFalse(CollectionUtils.isProperSubCollection(a, b));
1439 b.add("1");
1440 assertTrue(CollectionUtils.isProperSubCollection(a, b));
1441 assertFalse(CollectionUtils.isProperSubCollection(b, a));
1442 assertFalse(CollectionUtils.isProperSubCollection(b, b));
1443 assertFalse(CollectionUtils.isProperSubCollection(a, a));
1444 a.add("1");
1445 a.add("2");
1446 b.add("2");
1447 assertFalse(CollectionUtils.isProperSubCollection(b, a));
1448 assertFalse(CollectionUtils.isProperSubCollection(a, b));
1449 a.add("1");
1450 assertTrue(CollectionUtils.isProperSubCollection(b, a));
1451 assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.intersection(collectionA, collectionC), collectionA));
1452 assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.subtract(a, b), a));
1453 assertFalse(CollectionUtils.isProperSubCollection(a, CollectionUtils.subtract(a, b)));
1454 }
1455
1456 @Test
1457 public void testIsProperSubCollectionNullColl1() {
1458 final Collection<String> list = new ArrayList<>(1);
1459 list.add("1");
1460 assertThrows(NullPointerException.class, () -> CollectionUtils.isProperSubCollection(null, list));
1461 }
1462
1463 @Test
1464 public void testIsProperSubCollectionNullColl2() {
1465 final Collection<String> list = new ArrayList<>(1);
1466 list.add("1");
1467 assertThrows(NullPointerException.class, () -> CollectionUtils.isProperSubCollection(list, null));
1468 }
1469
1470 @Test
1471 public void testIsSubCollection() {
1472 assertFalse(CollectionUtils.isSubCollection(collectionA, collectionC));
1473 assertFalse(CollectionUtils.isSubCollection(collectionC, collectionA));
1474 }
1475
1476 @Test
1477 public void testIsSubCollection2() {
1478 final Collection<Integer> c = new ArrayList<>();
1479 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1480 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1481 c.add(1);
1482 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1483 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1484 c.add(2);
1485 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1486 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1487 c.add(2);
1488 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1489 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1490 c.add(3);
1491 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1492 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1493 c.add(3);
1494 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1495 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1496 c.add(3);
1497 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1498 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1499 c.add(4);
1500 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1501 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1502 c.add(4);
1503 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1504 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1505 c.add(4);
1506 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1507 assertFalse(CollectionUtils.isSubCollection(collectionA, c));
1508 c.add(4);
1509 assertTrue(CollectionUtils.isSubCollection(c, collectionA));
1510 assertTrue(CollectionUtils.isSubCollection(collectionA, c));
1511 c.add(5);
1512 assertFalse(CollectionUtils.isSubCollection(c, collectionA));
1513 assertTrue(CollectionUtils.isSubCollection(collectionA, c));
1514 }
1515
1516 @Test
1517 public void testIsSubCollectionNullColl1() {
1518 final Collection<String> list = new ArrayList<>(1);
1519 list.add("1");
1520 assertThrows(NullPointerException.class, () -> CollectionUtils.isSubCollection(null, list));
1521 }
1522
1523 @Test
1524 public void testIsSubCollectionNullColl2() {
1525 final Collection<String> list = new ArrayList<>(1);
1526 list.add("1");
1527 assertThrows(NullPointerException.class, () -> CollectionUtils.isSubCollection(list, null));
1528 }
1529
1530 @Test
1531 public void testIsSubCollectionOfSelf() {
1532 assertTrue(CollectionUtils.isSubCollection(collectionA, collectionA));
1533 assertTrue(CollectionUtils.isSubCollection(collectionB, collectionB));
1534 }
1535
1536 @Test
1537 @Deprecated
1538 public void testMatchesAll() {
1539 assertFalse(CollectionUtils.matchesAll(null, null));
1540 assertFalse(CollectionUtils.matchesAll(collectionA, null));
1541
1542 final Predicate<Integer> lessThanFive = object -> object < 5;
1543 assertTrue(CollectionUtils.matchesAll(collectionA, lessThanFive));
1544
1545 final Predicate<Integer> lessThanFour = object -> object < 4;
1546 assertFalse(CollectionUtils.matchesAll(collectionA, lessThanFour));
1547
1548 assertTrue(CollectionUtils.matchesAll(null, lessThanFour));
1549 assertTrue(CollectionUtils.matchesAll(emptyCollection, lessThanFour));
1550 }
1551
1552 @Test
1553 public void testMaxSize() {
1554 final Set<String> set = new HashSet<>();
1555 set.add("1");
1556 set.add("2");
1557 set.add("3");
1558 assertEquals(-1, CollectionUtils.maxSize(set));
1559
1560 final Queue<String> buf = new CircularFifoQueue<>(set);
1561 assertEquals(3, CollectionUtils.maxSize(buf));
1562 buf.remove("2");
1563 assertEquals(3, CollectionUtils.maxSize(buf));
1564 buf.add("2");
1565 assertEquals(3, CollectionUtils.maxSize(buf));
1566 }
1567
1568 @Test
1569 public void testMaxSizeNullColl() {
1570 assertThrows(NullPointerException.class, () -> CollectionUtils.maxSize(null));
1571 }
1572
1573 @Test
1574 public void testPermutations() {
1575 final List<Integer> sample = collectionA.subList(0, 5);
1576 final Collection<List<Integer>> permutations = CollectionUtils.permutations(sample);
1577
1578
1579 final int collSize = sample.size();
1580 int factorial = 1;
1581 for (int i = 1; i <= collSize; i++) {
1582 factorial *= i;
1583 }
1584 assertEquals(factorial, permutations.size());
1585 }
1586
1587 @Test
1588 public void testPermutationsWithNullCollection() {
1589 assertThrows(NullPointerException.class, () -> CollectionUtils.permutations(null));
1590 }
1591
1592 @Test
1593 public void testPredicatedCollection() {
1594 final Predicate<Object> predicate = PredicateUtils.instanceofPredicate(Integer.class);
1595 final Collection<Number> collection = CollectionUtils.predicatedCollection(new ArrayList<>(), predicate);
1596 assertInstanceOf(PredicatedCollection.class, collection, "returned object should be a PredicatedCollection");
1597 }
1598
1599 @Test
1600 public void testPredicatedCollectionNullColl() {
1601 final Predicate<Object> predicate = PredicateUtils.instanceofPredicate(Integer.class);
1602 assertThrows(NullPointerException.class, () -> CollectionUtils.predicatedCollection(null, predicate));
1603 }
1604
1605 @Test
1606 public void testPredicatedCollectionNullPredicate() {
1607 final Collection<Integer> list = new ArrayList<>();
1608 assertThrows(NullPointerException.class, () -> CollectionUtils.predicatedCollection(list, null));
1609 }
1610
1611 @Test
1612 public void testRemoveAll() {
1613 final List<String> base = new ArrayList<>();
1614 base.add("A");
1615 base.add("B");
1616 base.add("C");
1617 final List<String> sub = new ArrayList<>();
1618 sub.add("A");
1619 sub.add("C");
1620 sub.add("X");
1621
1622 final Collection<String> result = CollectionUtils.removeAll(base, sub);
1623 assertEquals(1, result.size());
1624 assertFalse(result.contains("A"));
1625 assertTrue(result.contains("B"));
1626 assertFalse(result.contains("C"));
1627 assertEquals(3, base.size());
1628 assertTrue(base.contains("A"));
1629 assertTrue(base.contains("B"));
1630 assertTrue(base.contains("C"));
1631 assertEquals(3, sub.size());
1632 assertTrue(sub.contains("A"));
1633 assertTrue(sub.contains("C"));
1634 assertTrue(sub.contains("X"));
1635 }
1636
1637 @Test
1638 public void testRemoveAllNullBaseColl() {
1639 final List<String> sub = new ArrayList<>();
1640 sub.add("A");
1641 assertThrows(NullPointerException.class, () -> CollectionUtils.removeAll(null, sub));
1642 }
1643
1644 @Test
1645 public void testRemoveAllNullSubColl() {
1646 final List<String> base = new ArrayList<>();
1647 base.add("A");
1648 assertThrows(NullPointerException.class, () -> CollectionUtils.removeAll(base, null));
1649 }
1650
1651 @Test
1652 public void testRemoveAllWithEquator() {
1653 final List<String> base = new ArrayList<>();
1654 base.add("AC");
1655 base.add("BB");
1656 base.add("CA");
1657
1658 final List<String> remove = new ArrayList<>();
1659 remove.add("AA");
1660 remove.add("CX");
1661 remove.add("XZ");
1662
1663
1664 final Collection<String> result = CollectionUtils.removeAll(base, remove, new Equator<String>() {
1665
1666 @Override
1667 public boolean equate(final String o1, final String o2) {
1668 return o1.charAt(1) == o2.charAt(1);
1669 }
1670
1671 @Override
1672 public int hash(final String o) {
1673 return o.charAt(1);
1674 }
1675 });
1676
1677 assertEquals(2, result.size());
1678 assertTrue(result.contains("AC"));
1679 assertTrue(result.contains("BB"));
1680 assertFalse(result.contains("CA"));
1681 assertEquals(3, base.size());
1682 assertTrue(base.contains("AC"));
1683 assertTrue(base.contains("BB"));
1684 assertTrue(base.contains("CA"));
1685 assertEquals(3, remove.size());
1686 assertTrue(remove.contains("AA"));
1687 assertTrue(remove.contains("CX"));
1688 assertTrue(remove.contains("XZ"));
1689
1690 assertThrows(NullPointerException.class, () -> CollectionUtils.removeAll(null, null, DefaultEquator.defaultEquator()));
1691 assertThrows(NullPointerException.class, () -> CollectionUtils.removeAll(base, remove, null));
1692 }
1693
1694 @Test
1695 public void testRemoveCount() {
1696 final List<Integer> list = new ArrayList<>();
1697 list.add(1);
1698 list.add(2);
1699 list.add(3);
1700 list.add(4);
1701
1702 Collection<Integer> result = CollectionUtils.removeCount(list, 0, 0);
1703 assertEquals(4, list.size());
1704 assertEquals(0, result.size());
1705
1706 result = CollectionUtils.removeCount(list, 0, 1);
1707 assertEquals(3, list.size());
1708 assertEquals(2, (int) list.get(0));
1709 assertEquals(1, result.size());
1710 assertTrue(result.contains(1));
1711
1712 list.add(5);
1713 list.add(6);
1714 result = CollectionUtils.removeCount(list, 1, 3);
1715
1716 assertEquals(2, list.size());
1717 assertEquals(2, (int) list.get(0));
1718 assertEquals(6, (int) list.get(1));
1719 assertEquals(3, result.size());
1720 assertTrue(result.contains(3));
1721 assertTrue(result.contains(4));
1722 assertTrue(result.contains(5));
1723 }
1724
1725 @Test
1726 public void testRemoveCountNegative() {
1727 final Collection<Integer> list = new ArrayList<>();
1728 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.removeCount(list, 0, -1));
1729 }
1730
1731 @Test
1732 public void testRemoveCountStartNegative() {
1733 final Collection<Integer> list = new ArrayList<>();
1734 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.removeCount(list, -1, 1));
1735 }
1736
1737 @Test
1738 public void testRemoveCountWithNull() {
1739 final Collection<Integer> list = null;
1740 assertThrows(NullPointerException.class, () -> CollectionUtils.removeCount(list, 0, 1));
1741 }
1742
1743 @Test
1744 public void testRemoveCountWrongCount() {
1745 final Collection<Integer> list = new ArrayList<>();
1746 list.add(1);
1747 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.removeCount(list, 0, 2));
1748 }
1749
1750 @Test
1751 public void testRemoveRange() {
1752 final List<Integer> list = new ArrayList<>();
1753 list.add(1);
1754 Collection<Integer> result = CollectionUtils.removeRange(list, 0, 0);
1755 assertEquals(1, list.size());
1756 assertEquals(0, result.size());
1757
1758 list.add(2);
1759 list.add(3);
1760 result = CollectionUtils.removeRange(list, 1, 3);
1761 assertEquals(1, list.size());
1762 assertEquals(1, (int) list.get(0));
1763 assertEquals(2, result.size());
1764 assertTrue(result.contains(2));
1765 assertTrue(result.contains(3));
1766 }
1767
1768 @Test
1769 public void testRemoveRangeEndIndexNegative() {
1770 final Collection<Integer> list = new ArrayList<>();
1771 list.add(1);
1772 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.removeRange(list, 0, -1));
1773 }
1774
1775 @Test
1776 public void testRemoveRangeEndLowStart() {
1777 final Collection<Integer> list = new ArrayList<>();
1778 list.add(1);
1779 list.add(2);
1780 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.removeRange(list, 1, 0));
1781 }
1782
1783 @Test
1784 public void testRemoveRangeNull() {
1785 final Collection<Integer> list = null;
1786 assertThrows(NullPointerException.class, () -> CollectionUtils.removeRange(list, 0, 0));
1787 }
1788
1789 @Test
1790 public void testRemoveRangeStartIndexNegative() {
1791 final Collection<Integer> list = new ArrayList<>();
1792 list.add(1);
1793 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.removeRange(list, -1, 1));
1794 }
1795
1796 @Test
1797 public void testRemoveRangeWrongEndIndex() {
1798 final Collection<Integer> list = new ArrayList<>();
1799 list.add(1);
1800 assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.removeRange(list, 0, 2));
1801 }
1802
1803 @Test
1804 public void testRetainAll() {
1805 final List<String> base = new ArrayList<>();
1806 base.add("A");
1807 base.add("B");
1808 base.add("C");
1809 final List<Object> sub = new ArrayList<>();
1810 sub.add("A");
1811 sub.add("C");
1812 sub.add("X");
1813
1814 final Collection<String> result = CollectionUtils.retainAll(base, sub);
1815 assertEquals(2, result.size());
1816 assertTrue(result.contains("A"));
1817 assertFalse(result.contains("B"));
1818 assertTrue(result.contains("C"));
1819 assertEquals(3, base.size());
1820 assertTrue(base.contains("A"));
1821 assertTrue(base.contains("B"));
1822 assertTrue(base.contains("C"));
1823 assertEquals(3, sub.size());
1824 assertTrue(sub.contains("A"));
1825 assertTrue(sub.contains("C"));
1826 assertTrue(sub.contains("X"));
1827 }
1828
1829 @Test
1830 public void testRetainAllNullBaseColl() {
1831 final List<Object> sub = new ArrayList<>();
1832 sub.add("A");
1833 assertThrows(NullPointerException.class, () -> CollectionUtils.retainAll(null, sub));
1834 }
1835
1836 @Test
1837 public void testRetainAllNullSubColl() {
1838 final List<String> base = new ArrayList<>();
1839 base.add("A");
1840 assertThrows(NullPointerException.class, () -> CollectionUtils.retainAll(base, null));
1841 }
1842
1843 @Test
1844 public void testRetainAllWithEquator() {
1845 final List<String> base = new ArrayList<>();
1846 base.add("AC");
1847 base.add("BB");
1848 base.add("CA");
1849
1850 final List<String> retain = new ArrayList<>();
1851 retain.add("AA");
1852 retain.add("CX");
1853 retain.add("XZ");
1854
1855
1856 final Collection<String> result = CollectionUtils.retainAll(base, retain, new Equator<String>() {
1857
1858 @Override
1859 public boolean equate(final String o1, final String o2) {
1860 return o1.charAt(1) == o2.charAt(1);
1861 }
1862
1863 @Override
1864 public int hash(final String o) {
1865 return o.charAt(1);
1866 }
1867 });
1868 assertEquals(1, result.size());
1869 assertTrue(result.contains("CA"));
1870 assertFalse(result.contains("BB"));
1871 assertFalse(result.contains("AC"));
1872
1873 assertEquals(3, base.size());
1874 assertTrue(base.contains("AC"));
1875 assertTrue(base.contains("BB"));
1876 assertTrue(base.contains("CA"));
1877
1878 assertEquals(3, retain.size());
1879 assertTrue(retain.contains("AA"));
1880 assertTrue(retain.contains("CX"));
1881 assertTrue(retain.contains("XZ"));
1882
1883 assertThrows(NullPointerException.class, () -> CollectionUtils.retainAll(null, null, null));
1884 assertThrows(NullPointerException.class, () -> CollectionUtils.retainAll(base, retain, null));
1885 }
1886
1887 @Test
1888 public void testReverse() {
1889 CollectionUtils.reverseArray(new Object[] {});
1890 final Integer[] a = collectionA.toArray(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY);
1891 CollectionUtils.reverseArray(a);
1892
1893 Collections.reverse(collectionA);
1894 assertEquals(collectionA, Arrays.asList(a));
1895 }
1896
1897 @Test
1898 public void testReverseArrayNull() {
1899 assertThrows(NullPointerException.class, () -> CollectionUtils.reverseArray(null));
1900 }
1901
1902 @Test
1903 public void testSelect() {
1904 final List<Integer> list = new ArrayList<>();
1905 list.add(1);
1906 list.add(2);
1907 list.add(3);
1908 list.add(4);
1909
1910 final Collection<Integer> output1 = CollectionUtils.select(list, EQUALS_TWO);
1911 final Collection<Number> output2 = CollectionUtils.<Number>select(list, EQUALS_TWO);
1912 final HashSet<Number> output3 = CollectionUtils.select(list, EQUALS_TWO, new HashSet<>());
1913 assertTrue(CollectionUtils.isEqualCollection(output1, output3));
1914 assertEquals(4, list.size());
1915 assertEquals(1, output1.size());
1916 assertEquals(2, output2.iterator().next());
1917 }
1918
1919 @Test
1920 public void testSelect_Iterable_Predicate_Collection_JiraCollections864() {
1921 final UniquePredicate<Object> uniquePredicate0 = new UniquePredicate<>();
1922 final LinkedList<InstanceofPredicate> linkedList0 = new LinkedList<>();
1923 final Class<InstanceofPredicate> class0 = InstanceofPredicate.class;
1924 final InstanceofPredicate instanceofPredicate0 = new InstanceofPredicate(class0);
1925 CollectionUtils.select((Iterable<? extends InstanceofPredicate>) linkedList0, (Predicate<? super InstanceofPredicate>) uniquePredicate0, linkedList0);
1926 }
1927
1928 @Test
1929 public void testSelectRejected() {
1930 final List<Long> list = new ArrayList<>();
1931 list.add(1L);
1932 list.add(2L);
1933 list.add(3L);
1934 list.add(4L);
1935 final Collection<Long> output1 = CollectionUtils.selectRejected(list, EQUALS_TWO);
1936 final Collection<? extends Number> output2 = CollectionUtils.selectRejected(list, EQUALS_TWO);
1937 final HashSet<Number> output3 = CollectionUtils.selectRejected(list, EQUALS_TWO, new HashSet<>());
1938 assertTrue(CollectionUtils.isEqualCollection(output1, output2));
1939 assertTrue(CollectionUtils.isEqualCollection(output1, output3));
1940 assertEquals(4, list.size());
1941 assertEquals(3, output1.size());
1942 assertTrue(output1.contains(1L));
1943 assertTrue(output1.contains(3L));
1944 assertTrue(output1.contains(4L));
1945 }
1946
1947 @Test
1948 public void testSelectWithOutputCollections() {
1949 final List<Integer> input = new ArrayList<>();
1950 input.add(1);
1951 input.add(2);
1952 input.add(3);
1953 input.add(4);
1954
1955 final List<Integer> output = new ArrayList<>();
1956 final List<Integer> rejected = new ArrayList<>();
1957
1958 CollectionUtils.select(input, EQUALS_TWO, output, rejected);
1959
1960
1961 assertEquals(1, output.size());
1962 assertEquals(2, CollectionUtils.extractSingleton(output).intValue());
1963
1964
1965 final Integer[] expected = {1, 3, 4};
1966 assertArrayEquals(expected, rejected.toArray());
1967
1968 output.clear();
1969 rejected.clear();
1970 CollectionUtils.select((List<Integer>) null, EQUALS_TWO, output, rejected);
1971 assertTrue(output.isEmpty());
1972 assertTrue(rejected.isEmpty());
1973 }
1974
1975 @Test
1976 public void testSize_Array() {
1977 final Object[] objectArray = {};
1978 assertEquals(0, CollectionUtils.size(objectArray));
1979
1980 final String[] stringArray = new String[3];
1981 assertEquals(3, CollectionUtils.size(stringArray));
1982 stringArray[0] = "a";
1983 stringArray[1] = "b";
1984 stringArray[2] = "c";
1985 assertEquals(3, CollectionUtils.size(stringArray));
1986 }
1987
1988 @Test
1989 public void testSize_Enumeration() {
1990 final Vector<String> list = new Vector<>();
1991 assertEquals(0, CollectionUtils.size(list.elements()));
1992 list.add("a");
1993 assertEquals(1, CollectionUtils.size(list.elements()));
1994 list.add("b");
1995 assertEquals(2, CollectionUtils.size(list.elements()));
1996 }
1997
1998 @Test
1999 public void testSize_Iterator() {
2000 final List<String> list = new ArrayList<>();
2001 assertEquals(0, CollectionUtils.size(list.iterator()));
2002 list.add("a");
2003 assertEquals(1, CollectionUtils.size(list.iterator()));
2004 list.add("b");
2005 assertEquals(2, CollectionUtils.size(list.iterator()));
2006 }
2007
2008 @Test
2009 public void testSize_List() {
2010 List<String> list = null;
2011 assertEquals(0, CollectionUtils.size(list));
2012 list = new ArrayList<>();
2013 assertEquals(0, CollectionUtils.size(list));
2014 list.add("a");
2015 assertEquals(1, CollectionUtils.size(list));
2016 list.add("b");
2017 assertEquals(2, CollectionUtils.size(list));
2018 }
2019
2020 @Test
2021 public void testSize_Map() {
2022 final Map<String, String> map = new HashMap<>();
2023 assertEquals(0, CollectionUtils.size(map));
2024 map.put("1", "a");
2025 assertEquals(1, CollectionUtils.size(map));
2026 map.put("2", "b");
2027 assertEquals(2, CollectionUtils.size(map));
2028 }
2029
2030 @Test
2031 public void testSize_Other() {
2032 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.size("not a list"));
2033 }
2034
2035 @Test
2036 public void testSize_PrimitiveArray() {
2037 final int[] intArray = {};
2038 assertEquals(0, CollectionUtils.size(intArray));
2039
2040 final double[] doubleArray = new double[3];
2041 assertEquals(3, CollectionUtils.size(doubleArray));
2042 doubleArray[0] = 0.0d;
2043 doubleArray[1] = 1.0d;
2044 doubleArray[2] = 2.5d;
2045 assertEquals(3, CollectionUtils.size(doubleArray));
2046 }
2047
2048 @Test
2049 public void testSizeIsEmpty_Array() {
2050 final Object[] objectArray = {};
2051 assertTrue(CollectionUtils.sizeIsEmpty(objectArray));
2052
2053 final String[] stringArray = new String[3];
2054 assertFalse(CollectionUtils.sizeIsEmpty(stringArray));
2055 stringArray[0] = "a";
2056 stringArray[1] = "b";
2057 stringArray[2] = "c";
2058 assertFalse(CollectionUtils.sizeIsEmpty(stringArray));
2059 }
2060
2061 @Test
2062 public void testSizeIsEmpty_Enumeration() {
2063 final Vector<String> list = new Vector<>();
2064 assertTrue(CollectionUtils.sizeIsEmpty(list.elements()));
2065 list.add("a");
2066 assertFalse(CollectionUtils.sizeIsEmpty(list.elements()));
2067 final Enumeration<String> en = list.elements();
2068 en.nextElement();
2069 assertTrue(CollectionUtils.sizeIsEmpty(en));
2070 }
2071
2072 @Test
2073 public void testSizeIsEmpty_Iterator() {
2074 final List<String> list = new ArrayList<>();
2075 assertTrue(CollectionUtils.sizeIsEmpty(list.iterator()));
2076 list.add("a");
2077 assertFalse(CollectionUtils.sizeIsEmpty(list.iterator()));
2078 final Iterator<String> it = list.iterator();
2079 it.next();
2080 assertTrue(CollectionUtils.sizeIsEmpty(it));
2081 }
2082
2083 @Test
2084 public void testSizeIsEmpty_List() {
2085 final List<String> list = new ArrayList<>();
2086 assertTrue(CollectionUtils.sizeIsEmpty(list));
2087 list.add("a");
2088 assertFalse(CollectionUtils.sizeIsEmpty(list));
2089 }
2090
2091 @Test
2092 public void testSizeIsEmpty_Map() {
2093 final Map<String, String> map = new HashMap<>();
2094 assertTrue(CollectionUtils.sizeIsEmpty(map));
2095 map.put("1", "a");
2096 assertFalse(CollectionUtils.sizeIsEmpty(map));
2097 }
2098
2099 @Test
2100 public void testSizeIsEmpty_Null() {
2101 assertTrue(CollectionUtils.sizeIsEmpty(null));
2102 }
2103
2104 @Test
2105 public void testSizeIsEmpty_Other() {
2106 assertThrows(IllegalArgumentException.class, () -> CollectionUtils.sizeIsEmpty("not a list"),
2107 "Expecting IllegalArgumentException");
2108 }
2109
2110 @Test
2111 public void testSizeIsEmpty_PrimitiveArray() {
2112 final int[] intArray = {};
2113 assertTrue(CollectionUtils.sizeIsEmpty(intArray));
2114
2115 final double[] doubleArray = new double[3];
2116 assertFalse(CollectionUtils.sizeIsEmpty(doubleArray));
2117 doubleArray[0] = 0.0d;
2118 doubleArray[1] = 1.0d;
2119 doubleArray[2] = 2.5d;
2120 assertFalse(CollectionUtils.sizeIsEmpty(doubleArray));
2121 }
2122
2123 @Test
2124 public void testSubtract() {
2125 final Collection<Integer> col = CollectionUtils.subtract(iterableA, iterableC);
2126 final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
2127 assertEquals(Integer.valueOf(1), freq.get(1));
2128 assertNull(freq.get(2));
2129 assertNull(freq.get(3));
2130 assertEquals(Integer.valueOf(2), freq.get(4));
2131 assertNull(freq.get(5));
2132
2133 final Collection<Number> col2 = CollectionUtils.subtract(collectionC2, collectionA);
2134 final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
2135 assertEquals(Integer.valueOf(1), freq2.get(5));
2136 assertNull(freq2.get(4));
2137 assertNull(freq2.get(3));
2138 assertEquals(Integer.valueOf(2), freq2.get(2));
2139 assertNull(freq2.get(1));
2140 }
2141
2142 @Test
2143 public void testSubtractNullColl1() {
2144 final Collection<String> list = new ArrayList<>(1);
2145 list.add("1");
2146 assertThrows(NullPointerException.class, () -> CollectionUtils.subtract(null, list));
2147 }
2148
2149 @Test
2150 public void testSubtractNullColl2() {
2151 final Collection<String> list = new ArrayList<>(1);
2152 list.add("1");
2153 assertThrows(NullPointerException.class, () -> CollectionUtils.subtract(list, null));
2154 }
2155
2156 @Test
2157 public void testSubtractWithPredicate() {
2158
2159 final Predicate<Number> predicate = n -> n.longValue() > 3L;
2160
2161 final Collection<Number> col = CollectionUtils.subtract(iterableA, collectionC, predicate);
2162 final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col);
2163 assertEquals(Integer.valueOf(1), freq2.get(1));
2164 assertEquals(Integer.valueOf(2), freq2.get(2));
2165 assertEquals(Integer.valueOf(3), freq2.get(3));
2166 assertEquals(Integer.valueOf(2), freq2.get(4));
2167 assertNull(freq2.get(5));
2168 }
2169
2170 @Test
2171 @Deprecated
2172 public void testSynchronizedCollection() {
2173 final Collection<Object> col = CollectionUtils.synchronizedCollection(new ArrayList<>());
2174 assertInstanceOf(SynchronizedCollection.class, col, "Returned object should be a SynchronizedCollection.");
2175
2176 assertThrows(NullPointerException.class, () -> CollectionUtils.synchronizedCollection(null),
2177 "Expecting NullPointerException for null collection.");
2178 }
2179
2180 @Test
2181 public void testTransform1() {
2182 List<Number> list = new ArrayList<>();
2183 list.add(1L);
2184 list.add(2L);
2185 list.add(3L);
2186 CollectionUtils.transform(list, TRANSFORM_TO_INTEGER);
2187 assertEquals(3, list.size());
2188 assertEquals(1, list.get(0));
2189 assertEquals(2, list.get(1));
2190 assertEquals(3, list.get(2));
2191
2192 list = new ArrayList<>();
2193 list.add(1L);
2194 list.add(2L);
2195 list.add(3L);
2196 CollectionUtils.transform(null, TRANSFORM_TO_INTEGER);
2197 assertEquals(3, list.size());
2198 CollectionUtils.transform(list, null);
2199 assertEquals(3, list.size());
2200 CollectionUtils.transform(null, null);
2201 assertEquals(3, list.size());
2202 }
2203
2204 @Test
2205 public void testTransform2() {
2206 final Set<Number> set = new HashSet<>();
2207 set.add(1L);
2208 set.add(2L);
2209 set.add(3L);
2210 CollectionUtils.transform(set, input -> 4);
2211 assertEquals(1, set.size());
2212 assertEquals(4, set.iterator().next());
2213 }
2214
2215 @Test
2216 public void testTransformedCollection() {
2217 final Transformer<Object, Object> transformer = TransformerUtils.nopTransformer();
2218 final Collection<Object> collection = CollectionUtils.transformingCollection(new ArrayList<>(), transformer);
2219 assertInstanceOf(TransformedCollection.class, collection, "returned object should be a TransformedCollection");
2220 }
2221
2222 @Test
2223 public void testTransformedCollection_2() {
2224 final List<Object> list = new ArrayList<>();
2225 list.add("1");
2226 list.add("2");
2227 list.add("3");
2228 final Collection<Object> result = CollectionUtils.transformingCollection(list, TRANSFORM_TO_INTEGER);
2229 assertTrue(result.contains("1"));
2230 assertTrue(result.contains("2"));
2231 assertTrue(result.contains("3"));
2232 }
2233
2234 @Test
2235 public void testTransformingCollectionNullColl() {
2236 final Transformer<Object, Object> transformer = TransformerUtils.nopTransformer();
2237 assertThrows(NullPointerException.class, () -> CollectionUtils.transformingCollection(null, transformer));
2238 }
2239
2240 @Test
2241 public void testTransformingCollectionNullTransformer() {
2242 final List<String> list = new ArrayList<>();
2243 assertThrows(NullPointerException.class, () -> CollectionUtils.transformingCollection(list, null));
2244 }
2245
2246 @Test
2247 public void testUnion() {
2248 final Collection<Integer> col = CollectionUtils.union(iterableA, iterableC);
2249 final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
2250 assertEquals(Integer.valueOf(1), freq.get(1));
2251 assertEquals(Integer.valueOf(4), freq.get(2));
2252 assertEquals(Integer.valueOf(3), freq.get(3));
2253 assertEquals(Integer.valueOf(4), freq.get(4));
2254 assertEquals(Integer.valueOf(1), freq.get(5));
2255
2256 final Collection<Number> col2 = CollectionUtils.union(collectionC2, iterableA);
2257 final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
2258 assertEquals(Integer.valueOf(1), freq2.get(1));
2259 assertEquals(Integer.valueOf(4), freq2.get(2));
2260 assertEquals(Integer.valueOf(3), freq2.get(3));
2261 assertEquals(Integer.valueOf(4), freq2.get(4));
2262 assertEquals(Integer.valueOf(1), freq2.get(5));
2263 }
2264
2265 @Test
2266 public void testUnionNullColl1() {
2267 final Collection<String> list = new ArrayList<>(1);
2268 list.add("1");
2269 assertThrows(NullPointerException.class, () -> CollectionUtils.union(null, list));
2270 }
2271
2272 @Test
2273 public void testUnionNullColl2() {
2274 final Collection<String> list = new ArrayList<>(1);
2275 list.add("1");
2276 assertThrows(NullPointerException.class, () -> CollectionUtils.union(list, null));
2277 }
2278
2279 @Test
2280 @Deprecated
2281 public void testUnmodifiableCollection() {
2282 final Collection<Object> col = CollectionUtils.unmodifiableCollection(new ArrayList<>());
2283 assertInstanceOf(UnmodifiableCollection.class, col, "Returned object should be a UnmodifiableCollection.");
2284
2285 assertThrows(NullPointerException.class, () -> CollectionUtils.unmodifiableCollection(null),
2286 "Expecting NullPointerException for null collection.");
2287 }
2288
2289 }