1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.collections4;
18
19 import static org.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
59
60
61 @SuppressWarnings("boxing")
62 public class CollectionUtilsTest extends MockTestCase {
63
64
65
66
67 private List<Integer> collectionA = null;
68
69
70
71
72 private List<Long> collectionB = null;
73
74
75
76
77
78 private Collection<Integer> collectionC = null;
79
80
81
82
83 private Collection<Integer> collectionD = null;
84
85
86
87
88 private Collection<Integer> collectionE = null;
89
90
91
92
93 private Collection<Number> collectionA2 = null;
94
95
96
97
98 private Collection<Number> collectionB2 = null;
99
100
101
102
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
210
211
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
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
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
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
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
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
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
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));
754 assertNull(CollectionUtils.forAllButLastDo((Collection<String>) null, (Closure<String>) null));
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));
770 }
771
772 @Test
773 public void getFromMap() {
774
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
787 try {
788 CollectionUtils.get(expected, 2);
789 fail("Expecting IndexOutOfBoundsException.");
790 } catch (final IndexOutOfBoundsException e) {
791
792 }
793 try {
794 CollectionUtils.get(expected, -2);
795 fail("Expecting IndexOutOfBoundsException.");
796 } catch (final IndexOutOfBoundsException e) {
797
798 }
799
800
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
814
815
816 @Test(expected=IndexOutOfBoundsException.class)
817 public void getFromList() throws Exception {
818
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
827 CollectionUtils.get(new ArrayList<>(), 2);
828 }
829
830 @Test
831 @Deprecated
832 public void getFromIterator() throws Exception {
833
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
840 try {
841 CollectionUtils.get(iterator, 10);
842 fail("Expecting IndexOutOfBoundsException.");
843 } catch (final IndexOutOfBoundsException e) {
844
845 }
846 assertTrue(!iterator.hasNext());
847 }
848
849 @Test
850 @Deprecated
851 public void getFromEnumeration() throws Exception {
852
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
862 try {
863 CollectionUtils.get(en, 3);
864 fail("Expecting IndexOutOfBoundsException.");
865 } catch (final IndexOutOfBoundsException e) {
866
867 }
868 assertTrue(!en.hasMoreElements());
869 }
870
871 @Test(expected = IndexOutOfBoundsException.class)
872 @Deprecated
873 public void getFromIterable() throws Exception {
874
875 final Bag<String> bag = new HashBag<>();
876 bag.add("element", 1);
877 assertEquals("element", CollectionUtils.get(bag, 0));
878
879
880 CollectionUtils.get(bag, 1);
881 }
882
883 @Test(expected = IndexOutOfBoundsException.class)
884 public void getFromObjectArray() throws Exception {
885
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
893
894 CollectionUtils.get(objArray, 2);
895 }
896
897 @Test(expected = IndexOutOfBoundsException.class)
898 public void getFromPrimitiveArray() throws Exception {
899
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
907
908 CollectionUtils.get(array, 2);
909 }
910
911 @Test(expected=IllegalArgumentException.class)
912 public void getFromObject() throws Exception {
913
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
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
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
1226 assertEquals(1, output.size());
1227 assertEquals(2, CollectionUtils.extractSingleton(output).intValue());
1228
1229
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
1373 }
1374 try {
1375 CollectionUtils.predicatedCollection(null, predicate);
1376 fail("Expecting NullPointerException for null collection.");
1377 } catch (final NullPointerException ex) {
1378
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
1433 final Integer elta = new Integer(17);
1434 final Integer eltb = new Integer(17);
1435
1436
1437 assertEquals(elta, eltb);
1438 assertEquals(eltb, elta);
1439
1440
1441 assertTrue(elta != eltb);
1442
1443
1444 final Collection<Number> cola = new ArrayList<>();
1445 final Collection<Integer> colb = new ArrayList<>();
1446
1447
1448
1449 cola.add(elta);
1450 colb.add(eltb);
1451
1452
1453
1454 final Collection<Number> intersection = CollectionUtils.intersection(cola, colb);
1455 assertEquals(1, intersection.size());
1456
1457
1458
1459
1460 final Object eltc = intersection.iterator().next();
1461 assertTrue(eltc == elta && eltc != eltb || eltc != elta && eltc == eltb);
1462
1463
1464
1465 assertEquals(elta, eltc);
1466 assertEquals(eltc, elta);
1467 assertEquals(eltb, eltc);
1468 assertEquals(eltc, eltb);
1469 }
1470
1471
1472
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 }
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 }
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
1548 }
1549 try {
1550 CollectionUtils.transformingCollection(null, transformer);
1551 fail("Expecting NullPointerException for null collection.");
1552 } catch (final NullPointerException ex) {
1553
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"));
1565 assertEquals(true, result.contains("2"));
1566 assertEquals(true, result.contains("3"));
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
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
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
1610
1611
1612
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
1631
1632 expect(c.addAll(inputCollection)).andReturn(true);
1633
1634
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
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
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
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
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 }
1898
1899 try {
1900 CollectionUtils.removeAll(base, remove, null);
1901 fail("expecting NullPointerException");
1902 } catch (final NullPointerException npe) {
1903 }
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
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 }
1951
1952 try {
1953 CollectionUtils.retainAll(base, retain, null);
1954 fail("expecting NullPointerException");
1955 } catch (final NullPointerException npe) {
1956 }
1957 }
1958
1959 }