View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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   * Tests for CollectionUtils.
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       * Collection of {@link Integer}s
73       */
74      private List<Integer> collectionA;
75  
76      /**
77       * Collection of {@link Long}s
78       */
79      private List<Long> collectionB;
80  
81      /**
82       * Collection of {@link Integer}s that are equivalent to the Longs in
83       * collectionB.
84       */
85      private Collection<Integer> collectionC;
86  
87      /**
88       * Sorted Collection of {@link Integer}s
89       */
90      private Collection<Integer> collectionD;
91  
92      /**
93       * Sorted Collection of {@link Integer}s
94       */
95      private Collection<Integer> collectionE;
96  
97      /**
98       * Collection of {@link Integer}s, bound as {@link Number}s
99       */
100     private Collection<Number> collectionA2;
101 
102     /**
103      * Collection of {@link Long}s, bound as {@link Number}s
104      */
105     private Collection<Number> collectionB2;
106 
107     /**
108      * Collection of {@link Integer}s (cast as {@link Number}s) that are
109      * equivalent to the Longs in collectionB.
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         // Ensure that generic bounds accept valid parameters, but return
148         // expected results
149         // for example no longs in the "int" Iterable<Number>, and vice versa.
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)); // do not remove cast
293         assertNull(CollectionUtils.forAllButLastDo((Collection<String>) null, (Closure<String>) null)); // do not remove cast
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)); // do not remove cast
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         // fix for various java 1.6 versions: keep the cast
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         // null should be OK
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         // fix for various java 1.6 versions: keep the cast
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         // null should be OK
357         CollectionUtils.forAllDo(col.iterator(), testClosure);
358     }
359 
360     @Test
361     @Deprecated
362     public void getFromEnumeration() throws Exception {
363         // Enumeration, entry exists
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         // Enumerator, non-existent entry
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         // Collection, entry exists
384         final Bag<String> bag = new HashBag<>();
385         bag.add("element", 1);
386         assertEquals("element", CollectionUtils.get(bag, 0));
387 
388         // Collection, non-existent entry
389         assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(bag, 1));
390     }
391 
392     @Test
393     @Deprecated
394     public void getFromIterator() throws Exception {
395         // Iterator, entry exists
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         // Iterator, non-existent entry
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      * Records the next object returned for a mock iterator
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      * This test ensures that {@link Iterable}s are supported by {@link CollectionUtils}.
493      * Specifically, it uses mocks to ensure that if the passed in
494      * {@link Iterable} is a {@link Collection} then
495      * {@link Collection#addAll(Collection)} is called instead of iterating.
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         // Check that the collection is added using
514         // Collection.addAll(Collection)
515         expect(c.addAll(inputCollection)).andReturn(true);
516 
517         // Ensure the method returns false if nothing is added
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     //Up to here
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         // Test assumes a defined iteration order so convert to a LinkedHashMap
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         // Unordered map, entries exist
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         // Map index out of range
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         // Ordered map, entries exist
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      * Tests that {@link List}s are handled correctly - for example using
1035      * {@link List#get(int)}.
1036      */
1037     @Test
1038     public void testGetFromList() throws Exception {
1039         // List, entry exists
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         // list, non-existent entry -- IndexOutOfBoundsException
1048         assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(new ArrayList<>(), 2));
1049     }
1050 
1051     @Test
1052     public void testGetFromMapIndexOutOfRange() {
1053         // Ordered map, entries exist
1054         final Map<String, String> expected = new LinkedHashMap<>();
1055         expected.put("zeroKey", "zero");
1056         expected.put("oneKey", "one");
1057         // Map index out of range
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         // Invalid object
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         // Object array, entry exists
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         // Object array, non-existent entry --
1079         // ArrayIndexOutOfBoundsException
1080         assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(objArray, 2));
1081     }
1082 
1083     @Test
1084     public void testGetFromPrimitiveArray() throws Exception {
1085         // Primitive array, entry exists
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         // Object array, non-existent entry --
1093         // ArrayIndexOutOfBoundsException
1094         assertThrows(IndexOutOfBoundsException.class, () -> CollectionUtils.get(array, 2));
1095     }
1096 
1097     @Test
1098     public void testGetFromTreeMap() {
1099         // Ordered map, entries exist
1100         final Map<String, String> expected = new LinkedHashMap<>();
1101         expected.put("zeroKey", "zero");
1102         expected.put("oneKey", "one");
1103 
1104         // Sorted map, entries exist, should respect order
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         // Let elta and eltb be objects...
1217         final Integer elta = 17;
1218         final Integer eltb = 17;
1219 
1220         // ...which are the same (==)
1221         assertSame(elta, eltb);
1222 
1223         // Let cola and colb be collections...
1224         final Collection<Number> cola = new ArrayList<>();
1225         final Collection<Integer> colb = new ArrayList<>();
1226 
1227         // ...which contain elta and eltb,
1228         // respectively.
1229         cola.add(elta);
1230         colb.add(eltb);
1231 
1232         // Then the intersection of the two
1233         // should contain one element.
1234         final Collection<Number> intersection = CollectionUtils.intersection(cola, colb);
1235         assertEquals(1, intersection.size());
1236 
1237         // In practice, this element will be the same (==) as elta
1238         // or eltb, although this isn't strictly part of the
1239         // contract.
1240         final Object eltc = intersection.iterator().next();
1241         assertTrue(eltc == elta && eltc == eltb);
1242 
1243         // In any event, this element remains equal,
1244         // to both elta and eltb.
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         // odd / even equator
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         // remove an extra '2', and add a 5.  This will increase the size of the cardinality
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         // result size = n!
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         // use an equator which compares the second letter only
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         // use an equator which compares the second letter only
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         // assume our implementation is correct if it returns the same order as the Java function
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         // Ensure that the collection is the input type or a super type
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         // output contains 2
1961         assertEquals(1, output.size());
1962         assertEquals(2, CollectionUtils.extractSingleton(output).intValue());
1963 
1964         // rejected contains 1, 3, and 4
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         // greater than 3
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")); // untransformed
2230         assertTrue(result.contains("2")); // untransformed
2231         assertTrue(result.contains("3")); // untransformed
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 }