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.apache.commons.collections4.functors.EqualPredicate.equalPredicate;
20  import static org.junit.Assert.assertEquals;
21  import static org.junit.Assert.assertFalse;
22  import static org.junit.Assert.assertNull;
23  import static org.junit.Assert.assertSame;
24  import static org.junit.Assert.assertTrue;
25  import static org.junit.Assert.fail;
26  
27  import java.util.ArrayList;
28  import java.util.Arrays;
29  import java.util.Collection;
30  import java.util.Collections;
31  import java.util.Comparator;
32  import java.util.Enumeration;
33  import java.util.HashMap;
34  import java.util.HashSet;
35  import java.util.Hashtable;
36  import java.util.Iterator;
37  import java.util.LinkedList;
38  import java.util.List;
39  import java.util.Map;
40  import java.util.Queue;
41  import java.util.Set;
42  import java.util.SortedMap;
43  import java.util.TreeMap;
44  import java.util.Vector;
45  
46  import org.apache.commons.collections4.bag.HashBag;
47  import org.apache.commons.collections4.collection.PredicatedCollection;
48  import org.apache.commons.collections4.collection.SynchronizedCollection;
49  import org.apache.commons.collections4.collection.TransformedCollection;
50  import org.apache.commons.collections4.collection.UnmodifiableCollection;
51  import org.apache.commons.collections4.functors.DefaultEquator;
52  import org.apache.commons.collections4.queue.CircularFifoQueue;
53  import org.junit.Assert;
54  import org.junit.Before;
55  import org.junit.Test;
56  
57  /**
58   * Tests for CollectionUtils.
59   *
60   */
61  @SuppressWarnings("boxing")
62  public class CollectionUtilsTest extends MockTestCase {
63  
64      /**
65       * Collection of {@link Integer}s
66       */
67      private List<Integer> collectionA = null;
68  
69      /**
70       * Collection of {@link Long}s
71       */
72      private List<Long> collectionB = null;
73  
74      /**
75       * Collection of {@link Integer}s that are equivalent to the Longs in
76       * collectionB.
77       */
78      private Collection<Integer> collectionC = null;
79  
80      /**
81       * Sorted Collection of {@link Integer}s
82       */
83      private Collection<Integer> collectionD = null;
84  
85      /**
86       * Sorted Collection of {@link Integer}s
87       */
88      private Collection<Integer> collectionE = null;
89  
90      /**
91       * Collection of {@link Integer}s, bound as {@link Number}s
92       */
93      private Collection<Number> collectionA2 = null;
94  
95      /**
96       * Collection of {@link Long}s, bound as {@link Number}s
97       */
98      private Collection<Number> collectionB2 = null;
99  
100     /**
101      * Collection of {@link Integer}s (cast as {@link Number}s) that are
102      * equivalent to the Longs in collectionB.
103      */
104     private Collection<Number> collectionC2 = null;
105 
106     private Iterable<Integer> iterableA = null;
107 
108     private Iterable<Long> iterableB = null;
109 
110     private Iterable<Integer> iterableC = null;
111 
112     private Iterable<Number> iterableA2 = null;
113 
114     private Iterable<Number> iterableB2 = null;
115 
116     private final Collection<Integer> emptyCollection = new ArrayList<>(1);
117 
118     @Before
119     public void setUp() {
120         collectionA = new ArrayList<>();
121         collectionA.add(1);
122         collectionA.add(2);
123         collectionA.add(2);
124         collectionA.add(3);
125         collectionA.add(3);
126         collectionA.add(3);
127         collectionA.add(4);
128         collectionA.add(4);
129         collectionA.add(4);
130         collectionA.add(4);
131         collectionB = new LinkedList<>();
132         collectionB.add(5L);
133         collectionB.add(4L);
134         collectionB.add(4L);
135         collectionB.add(3L);
136         collectionB.add(3L);
137         collectionB.add(3L);
138         collectionB.add(2L);
139         collectionB.add(2L);
140         collectionB.add(2L);
141         collectionB.add(2L);
142 
143         collectionC = new ArrayList<>();
144         for (final Long l : collectionB) {
145             collectionC.add(l.intValue());
146         }
147 
148         iterableA = collectionA;
149         iterableB = collectionB;
150         iterableC = collectionC;
151         collectionA2 = new ArrayList<>(collectionA);
152         collectionB2 = new LinkedList<>(collectionB);
153         collectionC2 = new LinkedList<>(collectionC);
154         iterableA2 = collectionA2;
155         iterableB2 = collectionB2;
156 
157         collectionD = new ArrayList<>();
158         collectionD.add(1);
159         collectionD.add(3);
160         collectionD.add(3);
161         collectionD.add(3);
162         collectionD.add(5);
163         collectionD.add(7);
164         collectionD.add(7);
165         collectionD.add(10);
166 
167         collectionE = new ArrayList<>();
168         collectionE.add(2);
169         collectionE.add(4);
170         collectionE.add(4);
171         collectionE.add(5);
172         collectionE.add(6);
173         collectionE.add(6);
174         collectionE.add(9);
175     }
176 
177     @Test
178     public void getCardinalityMap() {
179         final Map<Number, Integer> freqA = CollectionUtils.<Number>getCardinalityMap(iterableA);
180         assertEquals(1, (int) freqA.get(1));
181         assertEquals(2, (int) freqA.get(2));
182         assertEquals(3, (int) freqA.get(3));
183         assertEquals(4, (int) freqA.get(4));
184         assertNull(freqA.get(5));
185 
186         final Map<Long, Integer> freqB = CollectionUtils.getCardinalityMap(iterableB);
187         assertNull(freqB.get(1L));
188         assertEquals(4, (int) freqB.get(2L));
189         assertEquals(3, (int) freqB.get(3L));
190         assertEquals(2, (int) freqB.get(4L));
191         assertEquals(1, (int) freqB.get(5L));
192     }
193 
194     @Test
195     @Deprecated
196     public void cardinality() {
197         assertEquals(1, CollectionUtils.cardinality(1, iterableA));
198         assertEquals(2, CollectionUtils.cardinality(2, iterableA));
199         assertEquals(3, CollectionUtils.cardinality(3, iterableA));
200         assertEquals(4, CollectionUtils.cardinality(4, iterableA));
201         assertEquals(0, CollectionUtils.cardinality(5, iterableA));
202 
203         assertEquals(0, CollectionUtils.cardinality(1L, iterableB));
204         assertEquals(4, CollectionUtils.cardinality(2L, iterableB));
205         assertEquals(3, CollectionUtils.cardinality(3L, iterableB));
206         assertEquals(2, CollectionUtils.cardinality(4L, iterableB));
207         assertEquals(1, CollectionUtils.cardinality(5L, iterableB));
208 
209         // Ensure that generic bounds accept valid parameters, but return
210         // expected results
211         // e.g. no longs in the "int" Iterable<Number>, and vice versa.
212         assertEquals(0, CollectionUtils.cardinality(2L, iterableA2));
213         assertEquals(0, CollectionUtils.cardinality(2, iterableB2));
214 
215         final Set<String> set = new HashSet<>();
216         set.add("A");
217         set.add("C");
218         set.add("E");
219         set.add("E");
220         assertEquals(1, CollectionUtils.cardinality("A", set));
221         assertEquals(0, CollectionUtils.cardinality("B", set));
222         assertEquals(1, CollectionUtils.cardinality("C", set));
223         assertEquals(0, CollectionUtils.cardinality("D", set));
224         assertEquals(1, CollectionUtils.cardinality("E", set));
225 
226         final Bag<String> bag = new HashBag<>();
227         bag.add("A", 3);
228         bag.add("C");
229         bag.add("E");
230         bag.add("E");
231         assertEquals(3, CollectionUtils.cardinality("A", bag));
232         assertEquals(0, CollectionUtils.cardinality("B", bag));
233         assertEquals(1, CollectionUtils.cardinality("C", bag));
234         assertEquals(0, CollectionUtils.cardinality("D", bag));
235         assertEquals(2, CollectionUtils.cardinality("E", bag));
236     }
237 
238     @Test
239     @Deprecated
240     public void cardinalityOfNull() {
241         final List<String> list = new ArrayList<>();
242         assertEquals(0, CollectionUtils.cardinality(null, list));
243         {
244             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
245             assertNull(freq.get(null));
246         }
247         list.add("A");
248         assertEquals(0, CollectionUtils.cardinality(null, list));
249         {
250             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
251             assertNull(freq.get(null));
252         }
253         list.add(null);
254         assertEquals(1, CollectionUtils.cardinality(null, list));
255         {
256             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
257             assertEquals(Integer.valueOf(1), freq.get(null));
258         }
259         list.add("B");
260         assertEquals(1, CollectionUtils.cardinality(null, list));
261         {
262             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
263             assertEquals(Integer.valueOf(1), freq.get(null));
264         }
265         list.add(null);
266         assertEquals(2, CollectionUtils.cardinality(null, list));
267         {
268             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
269             assertEquals(Integer.valueOf(2), freq.get(null));
270         }
271         list.add("B");
272         assertEquals(2, CollectionUtils.cardinality(null, list));
273         {
274             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
275             assertEquals(Integer.valueOf(2), freq.get(null));
276         }
277         list.add(null);
278         assertEquals(3, CollectionUtils.cardinality(null, list));
279         {
280             final Map<String, Integer> freq = CollectionUtils.getCardinalityMap(list);
281             assertEquals(Integer.valueOf(3), freq.get(null));
282         }
283     }
284 
285     @Test
286     public void containsAll() {
287         final Collection<String> empty = new ArrayList<>(0);
288         final Collection<String> one = new ArrayList<>(1);
289         one.add("1");
290         final Collection<String> two = new ArrayList<>(1);
291         two.add("2");
292         final Collection<String> three = new ArrayList<>(1);
293         three.add("3");
294         final Collection<String> odds = new ArrayList<>(2);
295         odds.add("1");
296         odds.add("3");
297         final Collection<String> multiples = new ArrayList<>(3);
298         multiples.add("1");
299         multiples.add("3");
300         multiples.add("1");
301 
302         assertTrue("containsAll({1},{1,3}) should return false.", !CollectionUtils.containsAll(one, odds));
303         assertTrue("containsAll({1,3},{1}) should return true.", CollectionUtils.containsAll(odds, one));
304         assertTrue("containsAll({3},{1,3}) should return false.", !CollectionUtils.containsAll(three, odds));
305         assertTrue("containsAll({1,3},{3}) should return true.", CollectionUtils.containsAll(odds, three));
306         assertTrue("containsAll({2},{2}) should return true.", CollectionUtils.containsAll(two, two));
307         assertTrue("containsAll({1,3},{1,3}) should return true.", CollectionUtils.containsAll(odds, odds));
308 
309         assertTrue("containsAll({2},{1,3}) should return false.", !CollectionUtils.containsAll(two, odds));
310         assertTrue("containsAll({1,3},{2}) should return false.", !CollectionUtils.containsAll(odds, two));
311         assertTrue("containsAll({1},{3}) should return false.", !CollectionUtils.containsAll(one, three));
312         assertTrue("containsAll({3},{1}) should return false.", !CollectionUtils.containsAll(three, one));
313         assertTrue("containsAll({1,3},{}) should return true.", CollectionUtils.containsAll(odds, empty));
314         assertTrue("containsAll({},{1,3}) should return false.", !CollectionUtils.containsAll(empty, odds));
315         assertTrue("containsAll({},{}) should return true.", CollectionUtils.containsAll(empty, empty));
316 
317         assertTrue("containsAll({1,3},{1,3,1}) should return true.", CollectionUtils.containsAll(odds, multiples));
318         assertTrue("containsAll({1,3,1},{1,3,1}) should return true.", CollectionUtils.containsAll(odds, odds));
319     }
320 
321     @Test
322     public void containsAnyInCollection() {
323         final Collection<String> empty = new ArrayList<>(0);
324         final Collection<String> one = new ArrayList<>(1);
325         one.add("1");
326         final Collection<String> two = new ArrayList<>(1);
327         two.add("2");
328         final Collection<String> three = new ArrayList<>(1);
329         three.add("3");
330         final Collection<String> odds = new ArrayList<>(2);
331         odds.add("1");
332         odds.add("3");
333 
334         assertTrue("containsAny({1},{1,3}) should return true.", CollectionUtils.containsAny(one, odds));
335         assertTrue("containsAny({1,3},{1}) should return true.", CollectionUtils.containsAny(odds, one));
336         assertTrue("containsAny({3},{1,3}) should return true.", CollectionUtils.containsAny(three, odds));
337         assertTrue("containsAny({1,3},{3}) should return true.", CollectionUtils.containsAny(odds, three));
338         assertTrue("containsAny({2},{2}) should return true.", CollectionUtils.containsAny(two, two));
339         assertTrue("containsAny({1,3},{1,3}) should return true.", CollectionUtils.containsAny(odds, odds));
340 
341         assertTrue("containsAny({2},{1,3}) should return false.", !CollectionUtils.containsAny(two, odds));
342         assertTrue("containsAny({1,3},{2}) should return false.", !CollectionUtils.containsAny(odds, two));
343         assertTrue("containsAny({1},{3}) should return false.", !CollectionUtils.containsAny(one, three));
344         assertTrue("containsAny({3},{1}) should return false.", !CollectionUtils.containsAny(three, one));
345         assertTrue("containsAny({1,3},{}) should return false.", !CollectionUtils.containsAny(odds, empty));
346         assertTrue("containsAny({},{1,3}) should return false.", !CollectionUtils.containsAny(empty, odds));
347         assertTrue("containsAny({},{}) should return false.", !CollectionUtils.containsAny(empty, empty));
348     }
349 
350     @Test
351     public void containsAnyInArray() {
352         final Collection<String> empty = new ArrayList<>(0);
353         final String[] emptyArr = {};
354         final Collection<String> one = new ArrayList<>(1);
355         one.add("1");
356         final String[] oneArr = {"1"};
357         final Collection<String> two = new ArrayList<>(1);
358         two.add("2");
359         final String[] twoArr = {"2"};
360         final Collection<String> three = new ArrayList<>(1);
361         three.add("3");
362         final String[] threeArr = {"3"};
363         final Collection<String> odds = new ArrayList<>(2);
364         odds.add("1");
365         odds.add("3");
366         final String[] oddsArr = {"1", "3"};
367 
368         assertTrue("containsAny({1},{1,3}) should return true.", CollectionUtils.containsAny(one, oddsArr));
369         assertTrue("containsAny({1,3},{1}) should return true.", CollectionUtils.containsAny(odds, oneArr));
370         assertTrue("containsAny({3},{1,3}) should return true.", CollectionUtils.containsAny(three, oddsArr));
371         assertTrue("containsAny({1,3},{3}) should return true.", CollectionUtils.containsAny(odds, threeArr));
372         assertTrue("containsAny({2},{2}) should return true.", CollectionUtils.containsAny(two, twoArr));
373         assertTrue("containsAny({1,3},{1,3}) should return true.", CollectionUtils.containsAny(odds, oddsArr));
374 
375         assertTrue("containsAny({2},{1,3}) should return false.", !CollectionUtils.containsAny(two, oddsArr));
376         assertTrue("containsAny({1,3},{2}) should return false.", !CollectionUtils.containsAny(odds, twoArr));
377         assertTrue("containsAny({1},{3}) should return false.", !CollectionUtils.containsAny(one, threeArr));
378         assertTrue("containsAny({3},{1}) should return false.", !CollectionUtils.containsAny(three, oneArr));
379         assertTrue("containsAny({1,3},{}) should return false.", !CollectionUtils.containsAny(odds, emptyArr));
380         assertTrue("containsAny({},{1,3}) should return false.", !CollectionUtils.containsAny(empty, oddsArr));
381         assertTrue("containsAny({},{}) should return false.", !CollectionUtils.containsAny(empty, emptyArr));
382     }
383 
384     @Test
385     public void union() {
386         final Collection<Integer> col = CollectionUtils.union(iterableA, iterableC);
387         final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
388         assertEquals(Integer.valueOf(1), freq.get(1));
389         assertEquals(Integer.valueOf(4), freq.get(2));
390         assertEquals(Integer.valueOf(3), freq.get(3));
391         assertEquals(Integer.valueOf(4), freq.get(4));
392         assertEquals(Integer.valueOf(1), freq.get(5));
393 
394         final Collection<Number> col2 = CollectionUtils.union(collectionC2, iterableA);
395         final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
396         assertEquals(Integer.valueOf(1), freq2.get(1));
397         assertEquals(Integer.valueOf(4), freq2.get(2));
398         assertEquals(Integer.valueOf(3), freq2.get(3));
399         assertEquals(Integer.valueOf(4), freq2.get(4));
400         assertEquals(Integer.valueOf(1), freq2.get(5));
401     }
402 
403     @Test
404     public void intersection() {
405         final Collection<Integer> col = CollectionUtils.intersection(iterableA, iterableC);
406         final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
407         assertNull(freq.get(1));
408         assertEquals(Integer.valueOf(2), freq.get(2));
409         assertEquals(Integer.valueOf(3), freq.get(3));
410         assertEquals(Integer.valueOf(2), freq.get(4));
411         assertNull(freq.get(5));
412 
413         final Collection<Number> col2 = CollectionUtils.intersection(collectionC2, collectionA);
414         final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
415         assertNull(freq2.get(1));
416         assertEquals(Integer.valueOf(2), freq2.get(2));
417         assertEquals(Integer.valueOf(3), freq2.get(3));
418         assertEquals(Integer.valueOf(2), freq2.get(4));
419         assertNull(freq2.get(5));
420     }
421 
422     @Test
423     public void disjunction() {
424         final Collection<Integer> col = CollectionUtils.disjunction(iterableA, iterableC);
425         final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
426         assertEquals(Integer.valueOf(1), freq.get(1));
427         assertEquals(Integer.valueOf(2), freq.get(2));
428         assertNull(freq.get(3));
429         assertEquals(Integer.valueOf(2), freq.get(4));
430         assertEquals(Integer.valueOf(1), freq.get(5));
431 
432         final Collection<Number> col2 = CollectionUtils.disjunction(collectionC2, collectionA);
433         final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
434         assertEquals(Integer.valueOf(1), freq2.get(1));
435         assertEquals(Integer.valueOf(2), freq2.get(2));
436         assertNull(freq2.get(3));
437         assertEquals(Integer.valueOf(2), freq2.get(4));
438         assertEquals(Integer.valueOf(1), freq2.get(5));
439     }
440 
441     @Test
442     public void testDisjunctionAsUnionMinusIntersection() {
443         final Collection<Number> dis = CollectionUtils.<Number>disjunction(collectionA, collectionC);
444         final Collection<Number> un = CollectionUtils.<Number>union(collectionA, collectionC);
445         final Collection<Number> inter = CollectionUtils.<Number>intersection(collectionA, collectionC);
446         assertTrue(CollectionUtils.isEqualCollection(dis, CollectionUtils.subtract(un, inter)));
447     }
448 
449     @Test
450     public void testDisjunctionAsSymmetricDifference() {
451         final Collection<Number> dis = CollectionUtils.<Number>disjunction(collectionA, collectionC);
452         final Collection<Number> amb = CollectionUtils.<Number>subtract(collectionA, collectionC);
453         final Collection<Number> bma = CollectionUtils.<Number>subtract(collectionC, collectionA);
454         assertTrue(CollectionUtils.isEqualCollection(dis, CollectionUtils.union(amb, bma)));
455     }
456 
457     @Test
458     public void testSubtract() {
459         final Collection<Integer> col = CollectionUtils.subtract(iterableA, iterableC);
460         final Map<Integer, Integer> freq = CollectionUtils.getCardinalityMap(col);
461         assertEquals(Integer.valueOf(1), freq.get(1));
462         assertNull(freq.get(2));
463         assertNull(freq.get(3));
464         assertEquals(Integer.valueOf(2), freq.get(4));
465         assertNull(freq.get(5));
466 
467         final Collection<Number> col2 = CollectionUtils.subtract(collectionC2, collectionA);
468         final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col2);
469         assertEquals(Integer.valueOf(1), freq2.get(5));
470         assertNull(freq2.get(4));
471         assertNull(freq2.get(3));
472         assertEquals(Integer.valueOf(2), freq2.get(2));
473         assertNull(freq2.get(1));
474     }
475 
476     @Test
477     public void testSubtractWithPredicate() {
478         // greater than 3
479         final Predicate<Number> predicate = new Predicate<Number>() {
480             @Override
481             public boolean evaluate(final Number n) {
482                 return n.longValue() > 3L;
483             }
484         };
485 
486         final Collection<Number> col = CollectionUtils.subtract(iterableA, collectionC, predicate);
487         final Map<Number, Integer> freq2 = CollectionUtils.getCardinalityMap(col);
488         assertEquals(Integer.valueOf(1), freq2.get(1));
489         assertEquals(Integer.valueOf(2), freq2.get(2));
490         assertEquals(Integer.valueOf(3), freq2.get(3));
491         assertEquals(Integer.valueOf(2), freq2.get(4));
492         assertNull(freq2.get(5));
493     }
494 
495     @Test
496     public void testIsSubCollectionOfSelf() {
497         assertTrue(CollectionUtils.isSubCollection(collectionA, collectionA));
498         assertTrue(CollectionUtils.isSubCollection(collectionB, collectionB));
499     }
500 
501     @Test
502     public void testIsSubCollection() {
503         assertTrue(!CollectionUtils.isSubCollection(collectionA, collectionC));
504         assertTrue(!CollectionUtils.isSubCollection(collectionC, collectionA));
505     }
506 
507     @Test
508     public void testIsSubCollection2() {
509         final Collection<Integer> c = new ArrayList<>();
510         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
511         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
512         c.add(1);
513         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
514         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
515         c.add(2);
516         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
517         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
518         c.add(2);
519         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
520         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
521         c.add(3);
522         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
523         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
524         c.add(3);
525         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
526         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
527         c.add(3);
528         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
529         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
530         c.add(4);
531         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
532         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
533         c.add(4);
534         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
535         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
536         c.add(4);
537         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
538         assertTrue(!CollectionUtils.isSubCollection(collectionA, c));
539         c.add(4);
540         assertTrue(CollectionUtils.isSubCollection(c, collectionA));
541         assertTrue(CollectionUtils.isSubCollection(collectionA, c));
542         c.add(5);
543         assertTrue(!CollectionUtils.isSubCollection(c, collectionA));
544         assertTrue(CollectionUtils.isSubCollection(collectionA, c));
545     }
546 
547     @Test
548     public void testIsEqualCollectionToSelf() {
549         assertTrue(CollectionUtils.isEqualCollection(collectionA, collectionA));
550         assertTrue(CollectionUtils.isEqualCollection(collectionB, collectionB));
551     }
552 
553     @Test
554     public void testIsEqualCollection() {
555         assertTrue(!CollectionUtils.isEqualCollection(collectionA, collectionC));
556         assertTrue(!CollectionUtils.isEqualCollection(collectionC, collectionA));
557     }
558 
559     @Test
560     public void testIsEqualCollectionReturnsFalse() {
561         final List<Integer> b = new ArrayList<>(collectionA);
562         // remove an extra '2', and add a 5.  This will increase the size of the cardinality
563         b.remove(1);
564         b.add(5);
565         assertFalse(CollectionUtils.isEqualCollection(collectionA, b));
566         assertFalse(CollectionUtils.isEqualCollection(b, collectionA));
567     }
568 
569     @Test
570     public void testIsEqualCollection2() {
571         final Collection<String> a = new ArrayList<>();
572         final Collection<String> b = new ArrayList<>();
573         assertTrue(CollectionUtils.isEqualCollection(a, b));
574         assertTrue(CollectionUtils.isEqualCollection(b, a));
575         a.add("1");
576         assertTrue(!CollectionUtils.isEqualCollection(a, b));
577         assertTrue(!CollectionUtils.isEqualCollection(b, a));
578         b.add("1");
579         assertTrue(CollectionUtils.isEqualCollection(a, b));
580         assertTrue(CollectionUtils.isEqualCollection(b, a));
581         a.add("2");
582         assertTrue(!CollectionUtils.isEqualCollection(a, b));
583         assertTrue(!CollectionUtils.isEqualCollection(b, a));
584         b.add("2");
585         assertTrue(CollectionUtils.isEqualCollection(a, b));
586         assertTrue(CollectionUtils.isEqualCollection(b, a));
587         a.add("1");
588         assertTrue(!CollectionUtils.isEqualCollection(a, b));
589         assertTrue(!CollectionUtils.isEqualCollection(b, a));
590         b.add("1");
591         assertTrue(CollectionUtils.isEqualCollection(a, b));
592         assertTrue(CollectionUtils.isEqualCollection(b, a));
593     }
594 
595     @Test
596     public void testIsEqualCollectionEquator() {
597         final Collection<Integer> collB = CollectionUtils.collect(collectionB, TRANSFORM_TO_INTEGER);
598 
599         // odd / even equator
600         final Equator<Integer> e = new Equator<Integer>() {
601             @Override
602             public boolean equate(final Integer o1, final Integer o2) {
603                 if (o1.intValue() % 2 == 0 ^ o2.intValue() % 2 == 0) {
604                     return false;
605                 }
606                 return true;
607             }
608 
609             @Override
610             public int hash(final Integer o) {
611                 return o.intValue() % 2 == 0 ? Integer.valueOf(0).hashCode() : Integer.valueOf(1).hashCode();
612             }
613         };
614 
615         assertTrue(CollectionUtils.isEqualCollection(collectionA, collectionA, e));
616         assertTrue(CollectionUtils.isEqualCollection(collectionA, collB, e));
617         assertTrue(CollectionUtils.isEqualCollection(collB, collectionA, e));
618 
619         final Equator<Number> defaultEquator = DefaultEquator.defaultEquator();
620         assertFalse(CollectionUtils.isEqualCollection(collectionA, collectionB, defaultEquator));
621         assertFalse(CollectionUtils.isEqualCollection(collectionA, collB, defaultEquator));
622     }
623 
624     @Test(expected=NullPointerException.class)
625     public void testIsEqualCollectionNullEquator() {
626         CollectionUtils.isEqualCollection(collectionA, collectionA, null);
627     }
628 
629     @Test
630     public void testIsProperSubCollection() {
631         final Collection<String> a = new ArrayList<>();
632         final Collection<String> b = new ArrayList<>();
633         assertTrue(!CollectionUtils.isProperSubCollection(a, b));
634         b.add("1");
635         assertTrue(CollectionUtils.isProperSubCollection(a, b));
636         assertTrue(!CollectionUtils.isProperSubCollection(b, a));
637         assertTrue(!CollectionUtils.isProperSubCollection(b, b));
638         assertTrue(!CollectionUtils.isProperSubCollection(a, a));
639         a.add("1");
640         a.add("2");
641         b.add("2");
642         assertTrue(!CollectionUtils.isProperSubCollection(b, a));
643         assertTrue(!CollectionUtils.isProperSubCollection(a, b));
644         a.add("1");
645         assertTrue(CollectionUtils.isProperSubCollection(b, a));
646         assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.intersection(collectionA, collectionC), collectionA));
647         assertTrue(CollectionUtils.isProperSubCollection(CollectionUtils.subtract(a, b), a));
648         assertTrue(!CollectionUtils.isProperSubCollection(a, CollectionUtils.subtract(a, b)));
649     }
650 
651     @Test
652     @Deprecated
653     public void find() {
654         Predicate<Number> testPredicate = equalPredicate((Number) 4);
655         Integer test = CollectionUtils.find(collectionA, testPredicate);
656         assertTrue(test.equals(4));
657         testPredicate = equalPredicate((Number) 45);
658         test = CollectionUtils.find(collectionA, testPredicate);
659         assertTrue(test == null);
660         assertNull(CollectionUtils.find(null,testPredicate));
661         assertNull(CollectionUtils.find(collectionA, null));
662     }
663 
664     @Test
665     @Deprecated
666     public void forAllDoCollection() {
667         final Closure<Collection<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
668         final Collection<Collection<Integer>> col = new ArrayList<>();
669         col.add(collectionA);
670         col.add(collectionC);
671         Closure<Collection<Integer>> resultClosure = CollectionUtils.forAllDo(col, testClosure);
672         assertSame(testClosure, resultClosure);
673         assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
674         // fix for various java 1.6 versions: keep the cast
675         resultClosure = CollectionUtils.forAllDo(col, (Closure<Collection<Integer>>) null);
676         assertNull(resultClosure);
677         assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
678         resultClosure = CollectionUtils.forAllDo((Collection<Collection<Integer>>) null, testClosure);
679         col.add(null);
680         // null should be OK
681         CollectionUtils.forAllDo(col, testClosure);
682     }
683 
684     @Test
685     @Deprecated
686     public void forAllDoIterator() {
687         final Closure<Collection<Integer>> testClosure = ClosureUtils.invokerClosure("clear");
688         final Collection<Collection<Integer>> col = new ArrayList<>();
689         col.add(collectionA);
690         col.add(collectionC);
691         Closure<Collection<Integer>> resultClosure = CollectionUtils.forAllDo(col.iterator(), testClosure);
692         assertSame(testClosure, resultClosure);
693         assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
694         // fix for various java 1.6 versions: keep the cast
695         resultClosure = CollectionUtils.forAllDo(col.iterator(), (Closure<Collection<Integer>>) null);
696         assertNull(resultClosure);
697         assertTrue(collectionA.isEmpty() && collectionC.isEmpty());
698         resultClosure = CollectionUtils.forAllDo((Iterator<Collection<Integer>>) null, testClosure);
699         col.add(null);
700         // null should be OK
701         CollectionUtils.forAllDo(col.iterator(), testClosure);
702     }
703 
704     @Test(expected = FunctorException.class)
705     @Deprecated
706     public void forAllDoFailure() {
707         final Closure<String> testClosure = ClosureUtils.invokerClosure("clear");
708         final Collection<String> col = new ArrayList<>();
709         col.add("x");
710         CollectionUtils.forAllDo(col, testClosure);
711     }
712 
713     @Test
714     @Deprecated
715     public void forAllButLastDoCollection() {
716         final Closure<List<? extends Number>> testClosure = ClosureUtils.invokerClosure("clear");
717         final Collection<List<? extends Number>> col = new ArrayList<>();
718         col.add(collectionA);
719         col.add(collectionB);
720         List<? extends Number> lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
721         assertSame(lastElement, collectionB);
722         assertTrue(collectionA.isEmpty() && !collectionB.isEmpty());
723 
724         col.clear();
725         col.add(collectionB);
726         lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
727         assertSame(lastElement, collectionB);
728         assertTrue(!collectionB.isEmpty() );
729 
730         col.clear();
731         lastElement = CollectionUtils.forAllButLastDo(col, testClosure);
732         assertNull(lastElement);
733 
734         final Collection<String> strings = Arrays.asList("a", "b", "c");
735         final StringBuffer result = new StringBuffer();
736         result.append(CollectionUtils.forAllButLastDo(strings, new Closure<String>() {
737             @Override
738             public void execute(final String input) {
739                 result.append(input+";");
740             }
741         }));
742         assertEquals("a;b;c", result.toString());
743 
744         final Collection<String> oneString = Arrays.asList("a");
745         final StringBuffer resultOne = new StringBuffer();
746         resultOne.append(CollectionUtils.forAllButLastDo(oneString, new Closure<String>() {
747             @Override
748             public void execute(final String input) {
749                 resultOne.append(input+";");
750             }
751         }));
752         assertEquals("a", resultOne.toString());
753         assertNull(CollectionUtils.forAllButLastDo(strings, (Closure<String>) null)); // do not remove cast
754         assertNull(CollectionUtils.forAllButLastDo((Collection<String>) null, (Closure<String>) null)); // do not remove cast
755     }
756 
757     @Test
758     @Deprecated
759     public void forAllButLastDoIterator() {
760         final Closure<List<? extends Number>> testClosure = ClosureUtils.invokerClosure("clear");
761         final Collection<List<? extends Number>> col = new ArrayList<>();
762         col.add(collectionA);
763         col.add(collectionB);
764         final List<? extends Number> lastElement = CollectionUtils.forAllButLastDo(col.iterator(), testClosure);
765         assertSame(lastElement, collectionB);
766         assertTrue(collectionA.isEmpty() && !collectionB.isEmpty());
767 
768         assertNull(CollectionUtils.forAllButLastDo(col.iterator(), (Closure<List<? extends Number>>) null));
769         assertNull(CollectionUtils.forAllButLastDo((Iterator<String>) null, (Closure<String>) null)); // do not remove cast
770     }
771 
772     @Test
773     public void getFromMap() {
774         // Unordered map, entries exist
775         final Map<String, String> expected = new HashMap<>();
776         expected.put("zeroKey", "zero");
777         expected.put("oneKey", "one");
778 
779         final Map<String, String> found = new HashMap<>();
780         Map.Entry<String, String> entry = CollectionUtils.get(expected, 0);
781         found.put(entry.getKey(), entry.getValue());
782         entry = CollectionUtils.get(expected, 1);
783         found.put(entry.getKey(), entry.getValue());
784         assertEquals(expected, found);
785 
786         // Map index out of range
787         try {
788             CollectionUtils.get(expected, 2);
789             fail("Expecting IndexOutOfBoundsException.");
790         } catch (final IndexOutOfBoundsException e) {
791             // expected
792         }
793         try {
794             CollectionUtils.get(expected, -2);
795             fail("Expecting IndexOutOfBoundsException.");
796         } catch (final IndexOutOfBoundsException e) {
797             // expected
798         }
799 
800         // Sorted map, entries exist, should respect order
801         final SortedMap<String, String> map = new TreeMap<>();
802         map.put("zeroKey", "zero");
803         map.put("oneKey", "one");
804         Map.Entry<String, String> test = CollectionUtils.get(map, 1);
805         assertEquals("zeroKey", test.getKey());
806         assertEquals("zero", test.getValue());
807         test = CollectionUtils.get(map, 0);
808         assertEquals("oneKey", test.getKey());
809         assertEquals("one", test.getValue());
810     }
811 
812     /**
813      * Tests that {@link List}s are handled correctly - e.g. using
814      * {@link List#get(int)}.
815      */
816     @Test(expected=IndexOutOfBoundsException.class)
817     public void getFromList() throws Exception {
818         // List, entry exists
819         final List<String> list = createMock(List.class);
820         expect(list.get(0)).andReturn("zero");
821         expect(list.get(1)).andReturn("one");
822         replay();
823         final String string = CollectionUtils.get(list, 0);
824         assertEquals("zero", string);
825         assertEquals("one", CollectionUtils.get(list, 1));
826         // list, non-existent entry -- IndexOutOfBoundsException
827         CollectionUtils.get(new ArrayList<>(), 2);
828     }
829 
830     @Test
831     @Deprecated
832     public void getFromIterator() throws Exception {
833         // Iterator, entry exists
834         Iterator<Integer> iterator = iterableA.iterator();
835         assertEquals(1, (int) CollectionUtils.get(iterator, 0));
836         iterator = iterableA.iterator();
837         assertEquals(2, (int) CollectionUtils.get(iterator, 1));
838 
839         // Iterator, non-existent entry
840         try {
841             CollectionUtils.get(iterator, 10);
842             fail("Expecting IndexOutOfBoundsException.");
843         } catch (final IndexOutOfBoundsException e) {
844             // expected
845         }
846         assertTrue(!iterator.hasNext());
847     }
848 
849     @Test
850     @Deprecated
851     public void getFromEnumeration() throws Exception {
852         // Enumeration, entry exists
853         final Vector<String> vector = new Vector<>();
854         vector.addElement("zero");
855         vector.addElement("one");
856         Enumeration<String> en = vector.elements();
857         assertEquals("zero", CollectionUtils.get(en, 0));
858         en = vector.elements();
859         assertEquals("one", CollectionUtils.get(en, 1));
860 
861         // Enumerator, non-existent entry
862         try {
863             CollectionUtils.get(en, 3);
864             fail("Expecting IndexOutOfBoundsException.");
865         } catch (final IndexOutOfBoundsException e) {
866             // expected
867         }
868         assertTrue(!en.hasMoreElements());
869     }
870 
871     @Test(expected = IndexOutOfBoundsException.class)
872     @Deprecated
873     public void getFromIterable() throws Exception {
874         // Collection, entry exists
875         final Bag<String> bag = new HashBag<>();
876         bag.add("element", 1);
877         assertEquals("element", CollectionUtils.get(bag, 0));
878 
879         // Collection, non-existent entry
880         CollectionUtils.get(bag, 1);
881     }
882 
883     @Test(expected = IndexOutOfBoundsException.class)
884     public void getFromObjectArray() throws Exception {
885         // Object array, entry exists
886         final Object[] objArray = new Object[2];
887         objArray[0] = "zero";
888         objArray[1] = "one";
889         assertEquals("zero", CollectionUtils.get(objArray, 0));
890         assertEquals("one", CollectionUtils.get(objArray, 1));
891 
892         // Object array, non-existent entry --
893         // ArrayIndexOutOfBoundsException
894         CollectionUtils.get(objArray, 2);
895     }
896 
897     @Test(expected = IndexOutOfBoundsException.class)
898     public void getFromPrimitiveArray() throws Exception {
899         // Primitive array, entry exists
900         final int[] array = new int[2];
901         array[0] = 10;
902         array[1] = 20;
903         assertEquals(10, CollectionUtils.get(array, 0));
904         assertEquals(20, CollectionUtils.get(array, 1));
905 
906         // Object array, non-existent entry --
907         // ArrayIndexOutOfBoundsException
908         CollectionUtils.get(array, 2);
909     }
910 
911     @Test(expected=IllegalArgumentException.class)
912     public void getFromObject() throws Exception {
913         // Invalid object
914         final Object obj = new Object();
915         CollectionUtils.get(obj, 0);
916     }
917 
918     // -----------------------------------------------------------------------
919     @Test
920     public void testSize_List() {
921         List<String> list = null;
922         assertEquals(0, CollectionUtils.size(list));
923         list = new ArrayList<>();
924         assertEquals(0, CollectionUtils.size(list));
925         list.add("a");
926         assertEquals(1, CollectionUtils.size(list));
927         list.add("b");
928         assertEquals(2, CollectionUtils.size(list));
929     }
930 
931     @Test
932     public void testSize_Map() {
933         final Map<String, String> map = new HashMap<>();
934         assertEquals(0, CollectionUtils.size(map));
935         map.put("1", "a");
936         assertEquals(1, CollectionUtils.size(map));
937         map.put("2", "b");
938         assertEquals(2, CollectionUtils.size(map));
939     }
940 
941     @Test
942     public void testSize_Array() {
943         final Object[] objectArray = new Object[0];
944         assertEquals(0, CollectionUtils.size(objectArray));
945 
946         final String[] stringArray = new String[3];
947         assertEquals(3, CollectionUtils.size(stringArray));
948         stringArray[0] = "a";
949         stringArray[1] = "b";
950         stringArray[2] = "c";
951         assertEquals(3, CollectionUtils.size(stringArray));
952     }
953 
954     @Test
955     public void testSize_PrimitiveArray() {
956         final int[] intArray = new int[0];
957         assertEquals(0, CollectionUtils.size(intArray));
958 
959         final double[] doubleArray = new double[3];
960         assertEquals(3, CollectionUtils.size(doubleArray));
961         doubleArray[0] = 0.0d;
962         doubleArray[1] = 1.0d;
963         doubleArray[2] = 2.5d;
964         assertEquals(3, CollectionUtils.size(doubleArray));
965     }
966 
967     @Test
968     public void testSize_Enumeration() {
969         final Vector<String> list = new Vector<>();
970         assertEquals(0, CollectionUtils.size(list.elements()));
971         list.add("a");
972         assertEquals(1, CollectionUtils.size(list.elements()));
973         list.add("b");
974         assertEquals(2, CollectionUtils.size(list.elements()));
975     }
976 
977     @Test
978     public void testSize_Iterator() {
979         final List<String> list = new ArrayList<>();
980         assertEquals(0, CollectionUtils.size(list.iterator()));
981         list.add("a");
982         assertEquals(1, CollectionUtils.size(list.iterator()));
983         list.add("b");
984         assertEquals(2, CollectionUtils.size(list.iterator()));
985     }
986 
987     @Test(expected=IllegalArgumentException.class)
988     public void testSize_Other() {
989         CollectionUtils.size("not a list");
990     }
991 
992     // -----------------------------------------------------------------------
993     @Test
994     public void testSizeIsEmpty_Null() {
995         assertEquals(true, CollectionUtils.sizeIsEmpty(null));
996     }
997 
998     @Test
999     public void testSizeIsEmpty_List() {
1000         final List<String> list = new ArrayList<>();
1001         assertEquals(true, CollectionUtils.sizeIsEmpty(list));
1002         list.add("a");
1003         assertEquals(false, CollectionUtils.sizeIsEmpty(list));
1004     }
1005 
1006     @Test
1007     public void testSizeIsEmpty_Map() {
1008         final Map<String, String> map = new HashMap<>();
1009         assertEquals(true, CollectionUtils.sizeIsEmpty(map));
1010         map.put("1", "a");
1011         assertEquals(false, CollectionUtils.sizeIsEmpty(map));
1012     }
1013 
1014     @Test
1015     public void testSizeIsEmpty_Array() {
1016         final Object[] objectArray = new Object[0];
1017         assertEquals(true, CollectionUtils.sizeIsEmpty(objectArray));
1018 
1019         final String[] stringArray = new String[3];
1020         assertEquals(false, CollectionUtils.sizeIsEmpty(stringArray));
1021         stringArray[0] = "a";
1022         stringArray[1] = "b";
1023         stringArray[2] = "c";
1024         assertEquals(false, CollectionUtils.sizeIsEmpty(stringArray));
1025     }
1026 
1027     @Test
1028     public void testSizeIsEmpty_PrimitiveArray() {
1029         final int[] intArray = new int[0];
1030         assertEquals(true, CollectionUtils.sizeIsEmpty(intArray));
1031 
1032         final double[] doubleArray = new double[3];
1033         assertEquals(false, CollectionUtils.sizeIsEmpty(doubleArray));
1034         doubleArray[0] = 0.0d;
1035         doubleArray[1] = 1.0d;
1036         doubleArray[2] = 2.5d;
1037         assertEquals(false, CollectionUtils.sizeIsEmpty(doubleArray));
1038     }
1039 
1040     @Test
1041     public void testSizeIsEmpty_Enumeration() {
1042         final Vector<String> list = new Vector<>();
1043         assertEquals(true, CollectionUtils.sizeIsEmpty(list.elements()));
1044         list.add("a");
1045         assertEquals(false, CollectionUtils.sizeIsEmpty(list.elements()));
1046         final Enumeration<String> en = list.elements();
1047         en.nextElement();
1048         assertEquals(true, CollectionUtils.sizeIsEmpty(en));
1049     }
1050 
1051     @Test
1052     public void testSizeIsEmpty_Iterator() {
1053         final List<String> list = new ArrayList<>();
1054         assertEquals(true, CollectionUtils.sizeIsEmpty(list.iterator()));
1055         list.add("a");
1056         assertEquals(false, CollectionUtils.sizeIsEmpty(list.iterator()));
1057         final Iterator<String> it = list.iterator();
1058         it.next();
1059         assertEquals(true, CollectionUtils.sizeIsEmpty(it));
1060     }
1061 
1062     @Test
1063     public void testSizeIsEmpty_Other() {
1064         try {
1065             CollectionUtils.sizeIsEmpty("not a list");
1066             fail("Expecting IllegalArgumentException");
1067         } catch (final IllegalArgumentException ex) {
1068         }
1069     }
1070 
1071     // -----------------------------------------------------------------------
1072     @Test
1073     public void testIsEmptyWithEmptyCollection() {
1074         final Collection<Object> coll = new ArrayList<>();
1075         assertEquals(true, CollectionUtils.isEmpty(coll));
1076     }
1077 
1078     @Test
1079     public void testIsEmptyWithNonEmptyCollection() {
1080         final Collection<String> coll = new ArrayList<>();
1081         coll.add("item");
1082         assertEquals(false, CollectionUtils.isEmpty(coll));
1083     }
1084 
1085     @Test
1086     public void testIsEmptyWithNull() {
1087         final Collection<?> coll = null;
1088         assertEquals(true, CollectionUtils.isEmpty(coll));
1089     }
1090 
1091     @Test
1092     public void testIsNotEmptyWithEmptyCollection() {
1093         final Collection<Object> coll = new ArrayList<>();
1094         assertEquals(false, CollectionUtils.isNotEmpty(coll));
1095     }
1096 
1097     @Test
1098     public void testIsNotEmptyWithNonEmptyCollection() {
1099         final Collection<String> coll = new ArrayList<>();
1100         coll.add("item");
1101         assertEquals(true, CollectionUtils.isNotEmpty(coll));
1102     }
1103 
1104     @Test
1105     public void testIsNotEmptyWithNull() {
1106         final Collection<?> coll = null;
1107         assertEquals(false, CollectionUtils.isNotEmpty(coll));
1108     }
1109 
1110     // -----------------------------------------------------------------------
1111     private static Predicate<Number> EQUALS_TWO = new Predicate<Number>() {
1112         @Override
1113         public boolean evaluate(final Number input) {
1114             return input.intValue() == 2;
1115         }
1116     };
1117 
1118 //Up to here
1119     @Test
1120     public void filter() {
1121         final List<Integer> ints = new ArrayList<>();
1122         ints.add(1);
1123         ints.add(2);
1124         ints.add(3);
1125         ints.add(3);
1126         final Iterable<Integer> iterable = ints;
1127         assertTrue(CollectionUtils.filter(iterable, EQUALS_TWO));
1128         assertEquals(1, ints.size());
1129         assertEquals(2, (int) ints.get(0));
1130     }
1131 
1132     @Test
1133     public void filterNullParameters() throws Exception {
1134         final List<Long> longs = Collections.nCopies(4, 10L);
1135         assertFalse(CollectionUtils.filter(longs, null));
1136         assertEquals(4, longs.size());
1137         assertFalse(CollectionUtils.filter(null, EQUALS_TWO));
1138         assertEquals(4, longs.size());
1139         assertFalse(CollectionUtils.filter(null, null));
1140         assertEquals(4, longs.size());
1141     }
1142 
1143     @Test
1144     public void filterInverse() {
1145         final List<Integer> ints = new ArrayList<>();
1146         ints.add(1);
1147         ints.add(2);
1148         ints.add(3);
1149         ints.add(3);
1150         final Iterable<Integer> iterable = ints;
1151         assertTrue(CollectionUtils.filterInverse(iterable, EQUALS_TWO));
1152         assertEquals(3, ints.size());
1153         assertEquals(1, (int) ints.get(0));
1154         assertEquals(3, (int) ints.get(1));
1155         assertEquals(3, (int) ints.get(2));
1156     }
1157 
1158     @Test
1159     public void filterInverseNullParameters() throws Exception {
1160         final List<Long> longs = Collections.nCopies(4, 10L);
1161         assertFalse(CollectionUtils.filterInverse(longs, null));
1162         assertEquals(4, longs.size());
1163         assertFalse(CollectionUtils.filterInverse(null, EQUALS_TWO));
1164         assertEquals(4, longs.size());
1165         assertFalse(CollectionUtils.filterInverse(null, null));
1166         assertEquals(4, longs.size());
1167     }
1168 
1169     @Test
1170     @Deprecated
1171     public void countMatches() {
1172         assertEquals(4, CollectionUtils.countMatches(iterableB, EQUALS_TWO));
1173         assertEquals(0, CollectionUtils.countMatches(iterableA, null));
1174         assertEquals(0, CollectionUtils.countMatches(null, EQUALS_TWO));
1175         assertEquals(0, CollectionUtils.countMatches(null, null));
1176     }
1177 
1178     @Test
1179     @Deprecated
1180     public void exists() {
1181         final List<Integer> list = new ArrayList<>();
1182         assertFalse(CollectionUtils.exists(null, null));
1183         assertFalse(CollectionUtils.exists(list, null));
1184         assertFalse(CollectionUtils.exists(null, EQUALS_TWO));
1185         assertFalse(CollectionUtils.exists(list, EQUALS_TWO));
1186         list.add(1);
1187         list.add(3);
1188         list.add(4);
1189         assertFalse(CollectionUtils.exists(list, EQUALS_TWO));
1190 
1191         list.add(2);
1192         assertEquals(true, CollectionUtils.exists(list, EQUALS_TWO));
1193     }
1194 
1195     @Test
1196     public void select() {
1197         final List<Integer> list = new ArrayList<>();
1198         list.add(1);
1199         list.add(2);
1200         list.add(3);
1201         list.add(4);
1202         // Ensure that the collection is the input type or a super type
1203         final Collection<Integer> output1 = CollectionUtils.select(list, EQUALS_TWO);
1204         final Collection<Number> output2 = CollectionUtils.<Number>select(list, EQUALS_TWO);
1205         final HashSet<Number> output3 = CollectionUtils.select(list, EQUALS_TWO, new HashSet<Number>());
1206         assertTrue(CollectionUtils.isEqualCollection(output1, output3));
1207         assertEquals(4, list.size());
1208         assertEquals(1, output1.size());
1209         assertEquals(2, output2.iterator().next());
1210     }
1211 
1212     @Test
1213     public void selectWithOutputCollections() {
1214         final List<Integer> input = new ArrayList<>();
1215         input.add(1);
1216         input.add(2);
1217         input.add(3);
1218         input.add(4);
1219 
1220         final List<Integer> output = new ArrayList<>();
1221         final List<Integer> rejected = new ArrayList<>();
1222 
1223         CollectionUtils.select(input, EQUALS_TWO, output, rejected);
1224 
1225         // output contains 2
1226         assertEquals(1, output.size());
1227         assertEquals(2, CollectionUtils.extractSingleton(output).intValue());
1228 
1229         // rejected contains 1, 3, and 4
1230         final Integer[] expected = {1, 3, 4};
1231         Assert.assertArrayEquals(expected, rejected.toArray());
1232 
1233         output.clear();
1234         rejected.clear();
1235         CollectionUtils.select((List<Integer>) null, EQUALS_TWO, output, rejected);
1236         assertTrue(output.isEmpty());
1237         assertTrue(rejected.isEmpty());
1238     }
1239 
1240     @Test
1241     public void selectRejected() {
1242         final List<Long> list = new ArrayList<>();
1243         list.add(1L);
1244         list.add(2L);
1245         list.add(3L);
1246         list.add(4L);
1247         final Collection<Long> output1 = CollectionUtils.selectRejected(list, EQUALS_TWO);
1248         final Collection<? extends Number> output2 = CollectionUtils.selectRejected(list, EQUALS_TWO);
1249         final HashSet<Number> output3 = CollectionUtils.selectRejected(list, EQUALS_TWO, new HashSet<Number>());
1250         assertTrue(CollectionUtils.isEqualCollection(output1, output2));
1251         assertTrue(CollectionUtils.isEqualCollection(output1, output3));
1252         assertEquals(4, list.size());
1253         assertEquals(3, output1.size());
1254         assertTrue(output1.contains(1L));
1255         assertTrue(output1.contains(3L));
1256         assertTrue(output1.contains(4L));
1257     }
1258 
1259     @Test
1260     public void collect() {
1261         final Transformer<Number, Long> transformer = TransformerUtils.constantTransformer(2L);
1262         Collection<Number> collection = CollectionUtils.<Integer, Number>collect(iterableA, transformer);
1263         assertTrue(collection.size() == collectionA.size());
1264         assertCollectResult(collection);
1265 
1266         ArrayList<Number> list;
1267         list = CollectionUtils.collect(collectionA, transformer, new ArrayList<Number>());
1268         assertTrue(list.size() == collectionA.size());
1269         assertCollectResult(list);
1270 
1271         Iterator<Integer> iterator = null;
1272         list = CollectionUtils.collect(iterator, transformer, new ArrayList<Number>());
1273 
1274         iterator = iterableA.iterator();
1275         list = CollectionUtils.collect(iterator, transformer, list);
1276         assertTrue(collection.size() == collectionA.size());
1277         assertCollectResult(collection);
1278 
1279         iterator = collectionA.iterator();
1280         collection = CollectionUtils.<Integer, Number>collect(iterator, transformer);
1281         assertTrue(collection.size() == collectionA.size());
1282         assertTrue(collection.contains(2L) && !collection.contains(1));
1283         collection = CollectionUtils.collect((Iterator<Integer>) null, (Transformer<Integer, Number>) null);
1284         assertTrue(collection.size() == 0);
1285 
1286         final int size = collectionA.size();
1287         collectionB = CollectionUtils.collect((Collection<Integer>) null, transformer, collectionB);
1288         assertTrue(collectionA.size() == size && collectionA.contains(1));
1289         CollectionUtils.collect(collectionB, null, collectionA);
1290         assertTrue(collectionA.size() == size && collectionA.contains(1));
1291 
1292     }
1293 
1294     private void assertCollectResult(final Collection<Number> collection) {
1295         assertTrue(collectionA.contains(1) && !collectionA.contains(2L));
1296         assertTrue(collection.contains(2L) && !collection.contains(1));
1297     }
1298 
1299     Transformer<Object, Integer> TRANSFORM_TO_INTEGER = new Transformer<Object, Integer>() {
1300         @Override
1301         public Integer transform(final Object input) {
1302             return Integer.valueOf(((Long)input).intValue());
1303         }
1304     };
1305 
1306     @Test
1307     public void transform1() {
1308         List<Number> list = new ArrayList<>();
1309         list.add(1L);
1310         list.add(2L);
1311         list.add(3L);
1312         CollectionUtils.transform(list, TRANSFORM_TO_INTEGER);
1313         assertEquals(3, list.size());
1314         assertEquals(1, list.get(0));
1315         assertEquals(2, list.get(1));
1316         assertEquals(3, list.get(2));
1317 
1318         list = new ArrayList<>();
1319         list.add(1L);
1320         list.add(2L);
1321         list.add(3L);
1322         CollectionUtils.transform(null, TRANSFORM_TO_INTEGER);
1323         assertEquals(3, list.size());
1324         CollectionUtils.transform(list, null);
1325         assertEquals(3, list.size());
1326         CollectionUtils.transform(null, null);
1327         assertEquals(3, list.size());
1328     }
1329 
1330     @Test
1331     public void transform2() {
1332         final Set<Number> set = new HashSet<>();
1333         set.add(1L);
1334         set.add(2L);
1335         set.add(3L);
1336         CollectionUtils.transform(set, new Transformer<Object, Integer>() {
1337             @Override
1338             public Integer transform(final Object input) {
1339                 return 4;
1340             }
1341         });
1342         assertEquals(1, set.size());
1343         assertEquals(4, set.iterator().next());
1344     }
1345 
1346     // -----------------------------------------------------------------------
1347     @Test
1348     public void addIgnoreNull() {
1349         final Set<String> set = new HashSet<>();
1350         set.add("1");
1351         set.add("2");
1352         set.add("3");
1353         assertFalse(CollectionUtils.addIgnoreNull(set, null));
1354         assertEquals(3, set.size());
1355         assertFalse(CollectionUtils.addIgnoreNull(set, "1"));
1356         assertEquals(3, set.size());
1357         assertEquals(true, CollectionUtils.addIgnoreNull(set, "4"));
1358         assertEquals(4, set.size());
1359         assertEquals(true, set.contains("4"));
1360     }
1361 
1362     // -----------------------------------------------------------------------
1363     @Test
1364     public void predicatedCollection() {
1365         final Predicate<Object> predicate = PredicateUtils.instanceofPredicate(Integer.class);
1366         final Collection<Number> collection = CollectionUtils.predicatedCollection(new ArrayList<Number>(), predicate);
1367         assertTrue("returned object should be a PredicatedCollection", collection instanceof PredicatedCollection);
1368         try {
1369             CollectionUtils.predicatedCollection(new ArrayList<Number>(), null);
1370             fail("Expecting NullPointerException for null predicate.");
1371         } catch (final NullPointerException ex) {
1372             // expected
1373         }
1374         try {
1375             CollectionUtils.predicatedCollection(null, predicate);
1376             fail("Expecting NullPointerException for null collection.");
1377         } catch (final NullPointerException ex) {
1378             // expected
1379         }
1380     }
1381 
1382     @Test
1383     public void isFull() {
1384         final Set<String> set = new HashSet<>();
1385         set.add("1");
1386         set.add("2");
1387         set.add("3");
1388         try {
1389             CollectionUtils.isFull(null);
1390             fail();
1391         } catch (final NullPointerException ex) {
1392         }
1393         assertFalse(CollectionUtils.isFull(set));
1394 
1395         final CircularFifoQueue<String> buf = new CircularFifoQueue<>(set);
1396         assertEquals(false, CollectionUtils.isFull(buf));
1397         buf.remove("2");
1398         assertFalse(CollectionUtils.isFull(buf));
1399         buf.add("2");
1400         assertEquals(false, CollectionUtils.isFull(buf));
1401     }
1402 
1403     @Test
1404     public void isEmpty() {
1405         assertFalse(CollectionUtils.isNotEmpty(null));
1406         assertTrue(CollectionUtils.isNotEmpty(collectionA));
1407     }
1408 
1409     @Test
1410     public void maxSize() {
1411         final Set<String> set = new HashSet<>();
1412         set.add("1");
1413         set.add("2");
1414         set.add("3");
1415         try {
1416             CollectionUtils.maxSize(null);
1417             fail();
1418         } catch (final NullPointerException ex) {
1419         }
1420         assertEquals(-1, CollectionUtils.maxSize(set));
1421 
1422         final Queue<String> buf = new CircularFifoQueue<>(set);
1423         assertEquals(3, CollectionUtils.maxSize(buf));
1424         buf.remove("2");
1425         assertEquals(3, CollectionUtils.maxSize(buf));
1426         buf.add("2");
1427         assertEquals(3, CollectionUtils.maxSize(buf));
1428     }
1429 
1430     @Test
1431     public void intersectionUsesMethodEquals() {
1432         // Let elta and eltb be objects...
1433         final Integer elta = new Integer(17); // Cannot use valueOf here
1434         final Integer eltb = new Integer(17);
1435 
1436         // ...which are equal...
1437         assertEquals(elta, eltb);
1438         assertEquals(eltb, elta);
1439 
1440         // ...but not the same (==).
1441         assertTrue(elta != eltb);
1442 
1443         // Let cola and colb be collections...
1444         final Collection<Number> cola = new ArrayList<>();
1445         final Collection<Integer> colb = new ArrayList<>();
1446 
1447         // ...which contain elta and eltb,
1448         // respectively.
1449         cola.add(elta);
1450         colb.add(eltb);
1451 
1452         // Then the intersection of the two
1453         // should contain one element.
1454         final Collection<Number> intersection = CollectionUtils.intersection(cola, colb);
1455         assertEquals(1, intersection.size());
1456 
1457         // In practice, this element will be the same (==) as elta
1458         // or eltb, although this isn't strictly part of the
1459         // contract.
1460         final Object eltc = intersection.iterator().next();
1461         assertTrue(eltc == elta && eltc != eltb || eltc != elta && eltc == eltb);
1462 
1463         // In any event, this element remains equal,
1464         // to both elta and eltb.
1465         assertEquals(elta, eltc);
1466         assertEquals(eltc, elta);
1467         assertEquals(eltb, eltc);
1468         assertEquals(eltc, eltb);
1469     }
1470 
1471     // -----------------------------------------------------------------------
1472     //Up to here
1473     @Test
1474     public void testRetainAll() {
1475         final List<String> base = new ArrayList<>();
1476         base.add("A");
1477         base.add("B");
1478         base.add("C");
1479         final List<Object> sub = new ArrayList<>();
1480         sub.add("A");
1481         sub.add("C");
1482         sub.add("X");
1483 
1484         final Collection<String> result = CollectionUtils.retainAll(base, sub);
1485         assertEquals(2, result.size());
1486         assertEquals(true, result.contains("A"));
1487         assertFalse(result.contains("B"));
1488         assertEquals(true, result.contains("C"));
1489         assertEquals(3, base.size());
1490         assertEquals(true, base.contains("A"));
1491         assertEquals(true, base.contains("B"));
1492         assertEquals(true, base.contains("C"));
1493         assertEquals(3, sub.size());
1494         assertEquals(true, sub.contains("A"));
1495         assertEquals(true, sub.contains("C"));
1496         assertEquals(true, sub.contains("X"));
1497 
1498         try {
1499             CollectionUtils.retainAll(null, null);
1500             fail("expecting NullPointerException");
1501         } catch (final NullPointerException npe) {
1502         } // this is what we want
1503     }
1504 
1505     @Test
1506     public void testRemoveAll() {
1507         final List<String> base = new ArrayList<>();
1508         base.add("A");
1509         base.add("B");
1510         base.add("C");
1511         final List<String> sub = new ArrayList<>();
1512         sub.add("A");
1513         sub.add("C");
1514         sub.add("X");
1515 
1516         final Collection<String> result = CollectionUtils.removeAll(base, sub);
1517         assertEquals(1, result.size());
1518         assertFalse(result.contains("A"));
1519         assertEquals(true, result.contains("B"));
1520         assertFalse(result.contains("C"));
1521         assertEquals(3, base.size());
1522         assertEquals(true, base.contains("A"));
1523         assertEquals(true, base.contains("B"));
1524         assertEquals(true, base.contains("C"));
1525         assertEquals(3, sub.size());
1526         assertEquals(true, sub.contains("A"));
1527         assertEquals(true, sub.contains("C"));
1528         assertEquals(true, sub.contains("X"));
1529 
1530         try {
1531             CollectionUtils.removeAll(null, null);
1532             fail("expecting NullPointerException");
1533         } catch (final NullPointerException npe) {
1534         } // this is what we want
1535     }
1536 
1537     // -----------------------------------------------------------------------
1538     @Test
1539     public void testTransformedCollection() {
1540         final Transformer<Object, Object> transformer = TransformerUtils.nopTransformer();
1541         final Collection<Object> collection = CollectionUtils.transformingCollection(new ArrayList<>(), transformer);
1542         assertTrue("returned object should be a TransformedCollection", collection instanceof TransformedCollection);
1543         try {
1544             CollectionUtils.transformingCollection(new ArrayList<>(), null);
1545             fail("Expecting NullPointerException for null transformer.");
1546         } catch (final NullPointerException ex) {
1547             // expected
1548         }
1549         try {
1550             CollectionUtils.transformingCollection(null, transformer);
1551             fail("Expecting NullPointerException for null collection.");
1552         } catch (final NullPointerException ex) {
1553             // expected
1554         }
1555     }
1556 
1557     @Test
1558     public void testTransformedCollection_2() {
1559         final List<Object> list = new ArrayList<>();
1560         list.add("1");
1561         list.add("2");
1562         list.add("3");
1563         final Collection<Object> result = CollectionUtils.transformingCollection(list, TRANSFORM_TO_INTEGER);
1564         assertEquals(true, result.contains("1")); // untransformed
1565         assertEquals(true, result.contains("2")); // untransformed
1566         assertEquals(true, result.contains("3")); // untransformed
1567     }
1568 
1569     @Test
1570     @Deprecated
1571     public void testSynchronizedCollection() {
1572         final Collection<Object> col = CollectionUtils.synchronizedCollection(new ArrayList<>());
1573         assertTrue("Returned object should be a SynchronizedCollection.", col instanceof SynchronizedCollection);
1574         try {
1575             CollectionUtils.synchronizedCollection(null);
1576             fail("Expecting NullPointerException for null collection.");
1577         } catch (final NullPointerException ex) {
1578             // expected
1579         }
1580     }
1581 
1582     @Test
1583     @Deprecated
1584     public void testUnmodifiableCollection() {
1585         final Collection<Object> col = CollectionUtils.unmodifiableCollection(new ArrayList<>());
1586         assertTrue("Returned object should be a UnmodifiableCollection.", col instanceof UnmodifiableCollection);
1587         try {
1588             CollectionUtils.unmodifiableCollection(null);
1589             fail("Expecting NullPointerException for null collection.");
1590         } catch (final NullPointerException ex) {
1591             // expected
1592         }
1593     }
1594 
1595     @Test
1596     public void emptyCollection() throws Exception {
1597         final Collection<Number> coll = CollectionUtils.emptyCollection();
1598         assertEquals(CollectionUtils.EMPTY_COLLECTION, coll);
1599     }
1600 
1601     @Test
1602     public void emptyIfNull() {
1603         assertTrue(CollectionUtils.emptyIfNull(null).isEmpty());
1604         final Collection<Object> collection = new ArrayList<>();
1605         assertSame(collection, CollectionUtils.emptyIfNull(collection));
1606     }
1607 
1608     /**
1609      * This test ensures that {@link Iterable}s are supported by {@link CollectionUtils}.
1610      * Specifically, it uses mocks to ensure that if the passed in
1611      * {@link Iterable} is a {@link Collection} then
1612      * {@link Collection#addAll(Collection)} is called instead of iterating.
1613      */
1614     @Test
1615     public void addAllForIterable() {
1616         final Collection<Integer> inputCollection = createMock(Collection.class);
1617         final Iterable<Integer> inputIterable = inputCollection;
1618         final Iterable<Long> iterable = createMock(Iterable.class);
1619         final Iterator<Long> iterator = createMock(Iterator.class);
1620         final Collection<Number> c = createMock(Collection.class);
1621 
1622         expect(iterable.iterator()).andReturn(iterator);
1623         next(iterator, 1L);
1624         next(iterator, 2L);
1625         next(iterator, 3L);
1626         expect(iterator.hasNext()).andReturn(false);
1627         expect(c.add(1L)).andReturn(true);
1628         expect(c.add(2L)).andReturn(true);
1629         expect(c.add(3L)).andReturn(true);
1630         // Check that the collection is added using
1631         // Collection.addAll(Collection)
1632         expect(c.addAll(inputCollection)).andReturn(true);
1633 
1634         // Ensure the method returns false if nothing is added
1635         expect(iterable.iterator()).andReturn(iterator);
1636         next(iterator, 1L);
1637         expect(iterator.hasNext()).andReturn(false);
1638         expect(c.add(1L)).andReturn(false);
1639         expect(c.addAll(inputCollection)).andReturn(false);
1640 
1641         replay();
1642         assertTrue(CollectionUtils.addAll(c, iterable));
1643         assertTrue(CollectionUtils.addAll(c, inputIterable));
1644 
1645         assertFalse(CollectionUtils.addAll(c, iterable));
1646         assertFalse(CollectionUtils.addAll(c, inputIterable));
1647         verify();
1648     }
1649 
1650     @Test
1651     public void addAllForEnumeration() {
1652         final Hashtable<Integer, Integer> h = new Hashtable<>();
1653         h.put(5, 5);
1654         final Enumeration<? extends Integer> enumeration = h.keys();
1655         CollectionUtils.addAll(collectionA, enumeration);
1656         assertTrue(collectionA.contains(5));
1657     }
1658 
1659     @Test
1660     public void addAllForElements() {
1661         CollectionUtils.addAll(collectionA, new Integer[]{5});
1662         assertTrue(collectionA.contains(5));
1663     }
1664 
1665     @Test(expected=IndexOutOfBoundsException.class)
1666     public void getNegative() {
1667         CollectionUtils.get((Object)collectionA, -3);
1668     }
1669 
1670     @Test(expected=IndexOutOfBoundsException.class)
1671     public void getPositiveOutOfBounds() {
1672         CollectionUtils.get((Object)collectionA.iterator(), 30);
1673     }
1674 
1675     @Test(expected=IllegalArgumentException.class)
1676     public void get1() {
1677         CollectionUtils.get((Object)null, 0);
1678     }
1679 
1680     @Test
1681     public void get() {
1682         assertEquals(2, CollectionUtils.get((Object)collectionA, 2));
1683         assertEquals(2, CollectionUtils.get((Object)collectionA.iterator(), 2));
1684         final Map<Integer, Integer> map = CollectionUtils.getCardinalityMap(collectionA);
1685         assertEquals(map.entrySet().iterator().next(), CollectionUtils.get((Object)map, 0));
1686     }
1687 
1688     @Test
1689     public void getIterator() {
1690         final Iterator<Integer> it = collectionA.iterator();
1691         assertEquals(Integer.valueOf(2), CollectionUtils.get((Object) it, 2));
1692         assertTrue(it.hasNext());
1693         assertEquals(Integer.valueOf(4), CollectionUtils.get((Object) it, 6));
1694         assertFalse(it.hasNext());
1695     }
1696 
1697     @Test
1698     public void getEnumeration() {
1699         final Vector<Integer> vectorA = new Vector<>(collectionA);
1700         final Enumeration<Integer> e = vectorA.elements();
1701         assertEquals(Integer.valueOf(2), CollectionUtils.get(e, 2));
1702         assertTrue(e.hasMoreElements());
1703         assertEquals(Integer.valueOf(4), CollectionUtils.get(e, 6));
1704         assertFalse(e.hasMoreElements());
1705     }
1706 
1707     @Test
1708     public void reverse() {
1709         CollectionUtils.reverseArray(new Object[] {});
1710         final Integer[] a = collectionA.toArray(new Integer[collectionA.size()]);
1711         CollectionUtils.reverseArray(a);
1712         // assume our implementation is correct if it returns the same order as the Java function
1713         Collections.reverse(collectionA);
1714         assertEquals(collectionA, Arrays.asList(a));
1715     }
1716 
1717     @Test
1718     public void extractSingleton() {
1719         ArrayList<String> coll = null;
1720         try {
1721             CollectionUtils.extractSingleton(coll);
1722             fail("expected NullPointerException from extractSingleton(null)");
1723         } catch (final NullPointerException e) {
1724         }
1725         coll = new ArrayList<>();
1726         try {
1727             CollectionUtils.extractSingleton(coll);
1728             fail("expected IllegalArgumentException from extractSingleton(empty)");
1729         } catch (final IllegalArgumentException e) {
1730         }
1731         coll.add("foo");
1732         assertEquals("foo", CollectionUtils.extractSingleton(coll));
1733         coll.add("bar");
1734         try {
1735             CollectionUtils.extractSingleton(coll);
1736             fail("expected IllegalArgumentException from extractSingleton(size == 2)");
1737         } catch (final IllegalArgumentException e) {
1738         }
1739     }
1740 
1741     /**
1742      * Records the next object returned for a mock iterator
1743      */
1744     private <T> void next(final Iterator<T> iterator, final T t) {
1745         expect(iterator.hasNext()).andReturn(true);
1746         expect(iterator.next()).andReturn(t);
1747     }
1748 
1749     @Test(expected=NullPointerException.class)
1750     public void collateException1() {
1751         CollectionUtils.collate(collectionA, null);
1752     }
1753 
1754     @Test(expected=NullPointerException.class)
1755     public void collateException2() {
1756         CollectionUtils.collate(collectionA, collectionC, null);
1757     }
1758 
1759     @Test
1760     public void testCollate() {
1761         List<Integer> result = CollectionUtils.collate(emptyCollection, emptyCollection);
1762         assertEquals("Merge empty with empty", 0, result.size());
1763 
1764         result = CollectionUtils.collate(collectionA, emptyCollection);
1765         assertEquals("Merge empty with non-empty", collectionA, result);
1766 
1767         List<Integer> result1 = CollectionUtils.collate(collectionD, collectionE);
1768         List<Integer> result2 = CollectionUtils.collate(collectionE, collectionD);
1769         assertEquals("Merge two lists 1", result1, result2);
1770 
1771         final List<Integer> combinedList = new ArrayList<>();
1772         combinedList.addAll(collectionD);
1773         combinedList.addAll(collectionE);
1774         Collections.sort(combinedList);
1775 
1776         assertEquals("Merge two lists 2", combinedList, result2);
1777 
1778         final Comparator<Integer> reverseComparator =
1779                 ComparatorUtils.reversedComparator(ComparatorUtils.<Integer>naturalComparator());
1780 
1781         result = CollectionUtils.collate(emptyCollection, emptyCollection, reverseComparator);
1782         assertEquals("Comparator Merge empty with empty", 0, result.size());
1783 
1784         Collections.reverse((List<Integer>) collectionD);
1785         Collections.reverse((List<Integer>) collectionE);
1786         Collections.reverse(combinedList);
1787 
1788         result1 = CollectionUtils.collate(collectionD, collectionE, reverseComparator);
1789         result2 = CollectionUtils.collate(collectionE, collectionD, reverseComparator);
1790         assertEquals("Comparator Merge two lists 1", result1, result2);
1791         assertEquals("Comparator Merge two lists 2", combinedList, result2);
1792     }
1793 
1794     @Test
1795     public void testCollateIgnoreDuplicates() {
1796         final List<Integer> result1 = CollectionUtils.collate(collectionD, collectionE, false);
1797         final List<Integer> result2 = CollectionUtils.collate(collectionE, collectionD, false);
1798         assertEquals("Merge two lists 1 - ignore duplicates", result1, result2);
1799 
1800         final Set<Integer> combinedSet = new HashSet<>();
1801         combinedSet.addAll(collectionD);
1802         combinedSet.addAll(collectionE);
1803         final List<Integer> combinedList = new ArrayList<>(combinedSet);
1804         Collections.sort(combinedList);
1805 
1806         assertEquals("Merge two lists 2 - ignore duplicates", combinedList, result2);
1807     }
1808 
1809     @Test(expected=NullPointerException.class)
1810     public void testPermutationsWithNullCollection() {
1811         CollectionUtils.permutations(null);
1812     }
1813 
1814     @Test
1815     public void testPermutations() {
1816         final List<Integer> sample = collectionA.subList(0, 5);
1817         final Collection<List<Integer>> permutations = CollectionUtils.permutations(sample);
1818 
1819         // result size = n!
1820         final int collSize = sample.size();
1821         int factorial = 1;
1822         for (int i = 1; i <= collSize; i++) {
1823             factorial *= i;
1824         }
1825         assertEquals(factorial, permutations.size());
1826     }
1827 
1828     @Test
1829     @Deprecated
1830     public void testMatchesAll() {
1831         assertFalse(CollectionUtils.matchesAll(null, null));
1832         assertFalse(CollectionUtils.matchesAll(collectionA, null));
1833 
1834         final Predicate<Integer> lessThanFive = new Predicate<Integer>() {
1835             @Override
1836             public boolean evaluate(final Integer object) {
1837                 return object < 5;
1838             }
1839         };
1840         assertTrue(CollectionUtils.matchesAll(collectionA, lessThanFive));
1841 
1842         final Predicate<Integer> lessThanFour = new Predicate<Integer>() {
1843             @Override
1844             public boolean evaluate(final Integer object) {
1845                 return object < 4;
1846             }
1847         };
1848         assertFalse(CollectionUtils.matchesAll(collectionA, lessThanFour));
1849 
1850         assertTrue(CollectionUtils.matchesAll(null, lessThanFour));
1851         assertTrue(CollectionUtils.matchesAll(emptyCollection, lessThanFour));
1852     }
1853 
1854     @Test
1855     public void testRemoveAllWithEquator() {
1856         final List<String> base = new ArrayList<>();
1857         base.add("AC");
1858         base.add("BB");
1859         base.add("CA");
1860 
1861         final List<String> remove = new ArrayList<>();
1862         remove.add("AA");
1863         remove.add("CX");
1864         remove.add("XZ");
1865 
1866         // use an equator which compares the second letter only
1867         final Collection<String> result = CollectionUtils.removeAll(base, remove, new Equator<String>() {
1868 
1869             @Override
1870             public boolean equate(final String o1, final String o2) {
1871                 return o1.charAt(1) == o2.charAt(1);
1872             }
1873 
1874             @Override
1875             public int hash(final String o) {
1876                 return o.charAt(1);
1877             }
1878         });
1879 
1880         assertEquals(2, result.size());
1881         assertTrue(result.contains("AC"));
1882         assertTrue(result.contains("BB"));
1883         assertFalse(result.contains("CA"));
1884         assertEquals(3, base.size());
1885         assertEquals(true, base.contains("AC"));
1886         assertEquals(true, base.contains("BB"));
1887         assertEquals(true, base.contains("CA"));
1888         assertEquals(3, remove.size());
1889         assertEquals(true, remove.contains("AA"));
1890         assertEquals(true, remove.contains("CX"));
1891         assertEquals(true, remove.contains("XZ"));
1892 
1893         try {
1894             CollectionUtils.removeAll(null, null, DefaultEquator.defaultEquator());
1895             fail("expecting NullPointerException");
1896         } catch (final NullPointerException npe) {
1897         } // this is what we want
1898 
1899         try {
1900             CollectionUtils.removeAll(base, remove, null);
1901             fail("expecting NullPointerException");
1902         } catch (final NullPointerException npe) {
1903         } // this is what we want
1904     }
1905 
1906     @Test
1907     public void testRetainAllWithEquator() {
1908         final List<String> base = new ArrayList<>();
1909         base.add("AC");
1910         base.add("BB");
1911         base.add("CA");
1912 
1913         final List<String> retain = new ArrayList<>();
1914         retain.add("AA");
1915         retain.add("CX");
1916         retain.add("XZ");
1917 
1918         // use an equator which compares the second letter only
1919         final Collection<String> result = CollectionUtils.retainAll(base, retain, new Equator<String>() {
1920 
1921             @Override
1922             public boolean equate(final String o1, final String o2) {
1923                 return o1.charAt(1) == o2.charAt(1);
1924             }
1925 
1926             @Override
1927             public int hash(final String o) {
1928                 return o.charAt(1);
1929             }
1930         });
1931         assertEquals(1, result.size());
1932         assertTrue(result.contains("CA"));
1933         assertFalse(result.contains("BB"));
1934         assertFalse(result.contains("AC"));
1935 
1936         assertEquals(3, base.size());
1937         assertTrue(base.contains("AC"));
1938         assertTrue(base.contains("BB"));
1939         assertTrue(base.contains("CA"));
1940 
1941         assertEquals(3, retain.size());
1942         assertTrue(retain.contains("AA"));
1943         assertTrue(retain.contains("CX"));
1944         assertTrue(retain.contains("XZ"));
1945 
1946         try {
1947             CollectionUtils.retainAll(null, null, null);
1948             fail("expecting NullPointerException");
1949         } catch (final NullPointerException npe) {
1950         } // this is what we want
1951 
1952         try {
1953             CollectionUtils.retainAll(base, retain, null);
1954             fail("expecting NullPointerException");
1955         } catch (final NullPointerException npe) {
1956         } // this is what we want
1957     }
1958 
1959 }