Back to Repositories
Testing Collection Utility Operations in AndroidUtilCode

A comprehensive JUnit test suite for the CollectionUtils class in AndroidUtilCode, focusing on collection manipulation operations and edge cases. The suite validates core collection utility functions including union, intersection, filtering, and transformation operations.
Test Coverage Overview

The test suite provides extensive coverage of collection manipulation operations with a focus on null handling and edge cases.
Tests basic set operations: union, intersection, disjunction, subtraction
Validates collection comparison methods like isSubCollection and isEqualCollection
Covers transformation and filtering operations
Tests utility functions for collection manipulation and validation
Implementation Analysis

The testing approach employs JUnit 4 framework with systematic validation of collection operations.

Key patterns include:
Consistent null checking across all operations
Verification of collection integrity after operations
Use of Assert statements for explicit result validation
Implementation of Predicate and Transformer interfaces for collection processing
Technical Details

Testing infrastructure:
JUnit 4 testing framework
Custom collection utility methods
ArrayList as primary test data structure
BaseTest extension for common functionality
Predicate and Closure interfaces for collection operations
Best Practices Demonstrated

The test suite exemplifies high-quality testing practices through comprehensive validation of collection operations.
Systematic null handling and edge case testing
Clear test method naming and organization
Independent test cases with proper setup
Thorough validation of operation results
Consistent assertion usage for result verification
blankj/androidutilcode

lib/utilcode/src/test/java/com/blankj/utilcode/util/CollectionUtilsTest.java
            
package com.blankj.utilcode.util;

import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;

/**
 * <pre>
 *     author: blankj
 *     blog  : http://blankj.com
 *     time  : 2019/08/12
 *     desc  : test CollectionUtils
 * </pre>
 */
public class CollectionUtilsTest extends BaseTest {

    @Test
    public void union() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("00", "01", "02");
        ArrayList<String> l1 = CollectionUtils.newArrayList("00", "11", "12");

        Collection unionNullNull = CollectionUtils.union(null, null);
        Collection unionL0Null = CollectionUtils.union(l0, null);
        Collection unionNullL1 = CollectionUtils.union(null, l1);
        Collection unionL0L1 = CollectionUtils.union(l0, l1);

        System.out.println(unionNullNull);
        System.out.println(unionL0Null);
        System.out.println(unionNullL1);
        System.out.println(unionL0L1);

        Assert.assertNotSame(l0, unionL0Null);
        Assert.assertNotSame(l1, unionNullL1);
    }

    @Test
    public void intersection() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("00", "01", "02");
        ArrayList<String> l1 = CollectionUtils.newArrayList("00", "11", "12");

        Collection intersectionNullNull = CollectionUtils.intersection(null, null);
        Collection intersectionL0Null = CollectionUtils.intersection(l0, null);
        Collection intersectionNullL1 = CollectionUtils.intersection(null, l1);
        Collection intersectionL0L1 = CollectionUtils.intersection(l0, l1);

        System.out.println(intersectionNullNull);
        System.out.println(intersectionL0Null);
        System.out.println(intersectionNullL1);
        System.out.println(intersectionL0L1);
    }

    @Test
    public void disjunction() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("00", "01", "02");
        ArrayList<String> l1 = CollectionUtils.newArrayList("00", "11", "12");

        Collection disjunctionNullNull = CollectionUtils.disjunction(null, null);
        Collection disjunctionL0Null = CollectionUtils.disjunction(l0, null);
        Collection disjunctionNullL1 = CollectionUtils.disjunction(null, l1);
        Collection disjunctionL0L1 = CollectionUtils.disjunction(l0, l1);

        System.out.println(disjunctionNullNull);
        System.out.println(disjunctionL0Null);
        System.out.println(disjunctionNullL1);
        System.out.println(disjunctionL0L1);

        Assert.assertNotSame(l0, disjunctionL0Null);
        Assert.assertNotSame(l1, disjunctionNullL1);
    }

    @Test
    public void subtract() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("00", "01", "02");
        ArrayList<String> l1 = CollectionUtils.newArrayList("00", "11", "12");

        Collection subtractNullNull = CollectionUtils.subtract(null, null);
        Collection subtractL0Null = CollectionUtils.subtract(l0, null);
        Collection subtractNullL1 = CollectionUtils.subtract(null, l1);
        Collection subtractL0L1 = CollectionUtils.subtract(l0, l1);

        System.out.println(subtractNullNull);
        System.out.println(subtractL0Null);
        System.out.println(subtractNullL1);
        System.out.println(subtractL0L1);

        Assert.assertNotSame(l0, subtractL0Null);
    }

    @Test
    public void containsAny() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("00", "01", "02");
        ArrayList<String> l1 = CollectionUtils.newArrayList("00", "11", "12");

        Assert.assertFalse(CollectionUtils.containsAny(null, null));
        Assert.assertFalse(CollectionUtils.containsAny(l0, null));
        Assert.assertFalse(CollectionUtils.containsAny(null, l1));
        Assert.assertTrue(CollectionUtils.containsAny(l0, l1));
    }

    @Test
    public void getCardinalityMap() {
        System.out.println(CollectionUtils.getCardinalityMap(null));

        ArrayList<String> l0 = CollectionUtils.newArrayList("0", "0", "1", "1", "2");
        System.out.println(CollectionUtils.getCardinalityMap(l0));
    }

    @Test
    public void isSubCollection() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("0", "1", "2");
        ArrayList<String> l1 = CollectionUtils.newArrayList("0", "0", "1", "1", "2");

        Assert.assertFalse(CollectionUtils.isSubCollection(null, null));
        Assert.assertFalse(CollectionUtils.isSubCollection(l0, null));
        Assert.assertFalse(CollectionUtils.isSubCollection(null, l0));
        Assert.assertTrue(CollectionUtils.isSubCollection(l0, l1));
        Assert.assertTrue(CollectionUtils.isSubCollection(l0, l0));
        Assert.assertFalse(CollectionUtils.isSubCollection(l1, l0));
    }

    @Test
    public void isProperSubCollection() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("0", "1", "2");
        ArrayList<String> l1 = CollectionUtils.newArrayList("0", "0", "1", "1", "2");

        Assert.assertFalse(CollectionUtils.isProperSubCollection(null, null));
        Assert.assertFalse(CollectionUtils.isProperSubCollection(l0, null));
        Assert.assertFalse(CollectionUtils.isProperSubCollection(null, l0));
        Assert.assertTrue(CollectionUtils.isProperSubCollection(l0, l1));
        Assert.assertFalse(CollectionUtils.isProperSubCollection(l0, l0));
        Assert.assertFalse(CollectionUtils.isProperSubCollection(l1, l0));
    }

    @Test
    public void isEqualCollection() {
        ArrayList<String> l0 = CollectionUtils.newArrayList("0", "1", "2");
        ArrayList<String> l1 = CollectionUtils.newArrayList("0", "0", "1", "1", "2");

        Assert.assertFalse(CollectionUtils.isEqualCollection(null, null));
        Assert.assertFalse(CollectionUtils.isEqualCollection(l0, null));
        Assert.assertFalse(CollectionUtils.isEqualCollection(null, l0));
        Assert.assertTrue(CollectionUtils.isEqualCollection(l0, l0));
        Assert.assertFalse(CollectionUtils.isEqualCollection(l0, l1));
    }

    @Test
    public void cardinality() {
        ArrayList<String> list = CollectionUtils.newArrayList("0", "1", "1", "2");
        Assert.assertEquals(0, CollectionUtils.cardinality(null, null));
        Assert.assertEquals(0, CollectionUtils.cardinality(null, list));
        list.add(null);
        Assert.assertEquals(1, CollectionUtils.cardinality(null, list));
        Assert.assertEquals(2, CollectionUtils.cardinality("1", list));
    }

    @Test
    public void find() {
        ArrayList<String> list = CollectionUtils.newArrayList("0", "1", "1", "2");

        Assert.assertNull(CollectionUtils.find(null, null));
        Assert.assertNull(CollectionUtils.find(list, null));
        Assert.assertNull(CollectionUtils.find(null, new CollectionUtils.Predicate<String>() {
            @Override
            public boolean evaluate(String item) {
                return true;
            }
        }));
        Assert.assertEquals("1", CollectionUtils.find(list, new CollectionUtils.Predicate<String>() {
            @Override
            public boolean evaluate(String item) {
                return "1".equals(item);
            }
        }));
    }

    @Test
    public void forAllDo() {
        ArrayList<String> list = CollectionUtils.newArrayList("0", "1", "1", "2");

        CollectionUtils.forAllDo(null, null);
        CollectionUtils.forAllDo(list, null);
        CollectionUtils.forAllDo(null, new CollectionUtils.Closure<Object>() {
            @Override
            public void execute(int index, Object item) {
                System.out.println(index + ": " + index);
            }
        });

        CollectionUtils.forAllDo(list, new CollectionUtils.Closure<String>() {
            @Override
            public void execute(int index, String item) {
                System.out.println(index + ": " + index);
            }
        });
    }

    @Test
    public void filter() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        CollectionUtils.filter(l0, null);
        Assert.assertNull(l0);

        CollectionUtils.filter(l0, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return item > 1;
            }
        });
        Assert.assertNull(l0);

        CollectionUtils.filter(l1, null);
        Assert.assertEquals(l1, l1);

        CollectionUtils.filter(l1, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return item > 1;
            }
        });
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList(2, 3), l1));
    }

    @Test
    public void select() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.select(null, null).size());
        Assert.assertEquals(0, CollectionUtils.select(list, null).size());
        Assert.assertEquals(0, CollectionUtils.select(null, new CollectionUtils.Predicate<Object>() {
            @Override
            public boolean evaluate(Object item) {
                return true;
            }
        }).size());

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(2, 3),
                CollectionUtils.select(list, new CollectionUtils.Predicate<Integer>() {
                    @Override
                    public boolean evaluate(Integer item) {
                        return item > 1;
                    }
                })));

        Collection<Integer> list1 = CollectionUtils.select(list, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return true;
            }
        });

        Assert.assertTrue(CollectionUtils.isEqualCollection(list, list1));
        Assert.assertNotSame(list, list1);
    }


    @Test
    public void selectRejected() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.selectRejected(null, null).size());
        Assert.assertEquals(0, CollectionUtils.selectRejected(list, null).size());
        Assert.assertEquals(0, CollectionUtils.selectRejected(null, new CollectionUtils.Predicate<Object>() {
            @Override
            public boolean evaluate(Object item) {
                return true;
            }
        }).size());

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(0, 1),
                CollectionUtils.selectRejected(list, new CollectionUtils.Predicate<Integer>() {
                    @Override
                    public boolean evaluate(Integer item) {
                        return item > 1;
                    }
                })));


        Collection<Integer> list1 = CollectionUtils.selectRejected(list, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return false;
            }
        });

        Assert.assertTrue(CollectionUtils.isEqualCollection(list, list1));
        Assert.assertNotSame(list, list1);
    }

    @Test
    public void transform() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        CollectionUtils.transform(l0, null);
        Assert.assertNull(l0);

        CollectionUtils.transform(l0, new CollectionUtils.Transformer<Integer, Object>() {
            @Override
            public Object transform(Integer input) {
                return "int: " + input;
            }
        });
        Assert.assertNull(l0);

        CollectionUtils.transform(l1, null);
        Assert.assertEquals(l1, l1);

        CollectionUtils.transform(l1, new CollectionUtils.Transformer<Integer, String>() {
            @Override
            public String transform(Integer input) {
                return String.valueOf(input);
            }
        });
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList("0", "1", "2", "3"), l1));
    }

    @Test
    public void collect() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertTrue(CollectionUtils.isEmpty(CollectionUtils.collect(null, null)));
        Assert.assertTrue(CollectionUtils.isEmpty(CollectionUtils.collect(list, null)));
        Assert.assertTrue(CollectionUtils.isEmpty(CollectionUtils.collect(null, new CollectionUtils.Transformer() {
            @Override
            public Object transform(Object input) {
                return null;
            }
        })));

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList("0", "1", "2", "3"),
                CollectionUtils.collect(list, new CollectionUtils.Transformer<Integer, String>() {
                    @Override
                    public String transform(Integer input) {
                        return String.valueOf(input);
                    }
                })));
    }

    @Test
    public void countMatches() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.countMatches(null, null));
        Assert.assertEquals(0, CollectionUtils.countMatches(list, null));
        Assert.assertEquals(0, CollectionUtils.countMatches(null, new CollectionUtils.Predicate<Object>() {
            @Override
            public boolean evaluate(Object item) {
                return false;
            }
        }));
        Assert.assertEquals(2, CollectionUtils.countMatches(list, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return item > 1;
            }
        }));
    }

    @Test
    public void exists() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertFalse(CollectionUtils.exists(null, null));
        Assert.assertFalse(CollectionUtils.exists(list, null));
        Assert.assertFalse(CollectionUtils.exists(null, new CollectionUtils.Predicate<Object>() {
            @Override
            public boolean evaluate(Object item) {
                return false;
            }
        }));
        Assert.assertTrue(CollectionUtils.exists(list, new CollectionUtils.Predicate<Integer>() {
            @Override
            public boolean evaluate(Integer item) {
                return item > 1;
            }
        }));
    }

    @Test
    public void addIgnoreNull() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertFalse(CollectionUtils.addIgnoreNull(null, null));
        Assert.assertFalse(CollectionUtils.addIgnoreNull(null, 1));

        CollectionUtils.addIgnoreNull(list, null);
        Assert.assertEquals(CollectionUtils.newArrayList(0, 1, 2, 3), list);

        CollectionUtils.addIgnoreNull(list, 4);
        Assert.assertEquals(CollectionUtils.newArrayList(0, 1, 2, 3, 4), list);
    }

    @Test
    public void addAll() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);
        CollectionUtils.addAll(l0, (Iterator<Integer>) null);
        Assert.assertNull(l0);
        CollectionUtils.addAll(l0, (Enumeration<Integer>) null);
        Assert.assertNull(l0);
        CollectionUtils.addAll(l0, (Integer[]) null);
        Assert.assertNull(l0);

        CollectionUtils.addAll(l1, (Iterator<Integer>) null);
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList(0, 1, 2, 3), l1));
        CollectionUtils.addAll(l1, (Enumeration<Integer>) null);
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList(0, 1, 2, 3), l1));
        CollectionUtils.addAll(l1, (Integer[]) null);
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList(0, 1, 2, 3), l1));

        CollectionUtils.addAll(l1, CollectionUtils.newArrayList(4, 5).iterator());
        Assert.assertTrue(CollectionUtils.isEqualCollection(CollectionUtils.newArrayList(0, 1, 2, 3, 4, 5), l1));
    }

    @Test
    public void get() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertNull(CollectionUtils.get(l0, 0));
        Assert.assertEquals(0, CollectionUtils.get(l1, 0));
    }

    @Test
    public void size() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.size(l0));
        Assert.assertEquals(4, CollectionUtils.size(l1));
    }

    @Test
    public void sizeIsEmpty() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertTrue(CollectionUtils.sizeIsEmpty(l0));
        Assert.assertFalse(CollectionUtils.sizeIsEmpty(l1));
    }

    @Test
    public void isEmpty() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertTrue(CollectionUtils.isEmpty(l0));
        Assert.assertFalse(CollectionUtils.isEmpty(l1));
    }

    @Test
    public void isNotEmpty() {
        ArrayList<Integer> l0 = null;
        ArrayList<Integer> l1 = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertFalse(CollectionUtils.isNotEmpty(l0));
        Assert.assertTrue(CollectionUtils.isNotEmpty(l1));
    }

    @Test
    public void retainAll() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.retainAll(null, null).size());
        Assert.assertEquals(0, CollectionUtils.retainAll(list, null).size());
        Assert.assertEquals(0, CollectionUtils.retainAll(null, list).size());

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(0, 1, 2, 3),
                CollectionUtils.retainAll(list, list)
        ));

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(0, 1),
                CollectionUtils.retainAll(list, CollectionUtils.newArrayList(0, 1, 6))
        ));
    }

    @Test
    public void removeAll() {
        ArrayList<Integer> list = CollectionUtils.newArrayList(0, 1, 2, 3);

        Assert.assertEquals(0, CollectionUtils.removeAll(null, null).size());
        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(0, 1, 2, 3),
                CollectionUtils.removeAll(list, null)
        ));
        Assert.assertEquals(0, CollectionUtils.removeAll(null, list).size());

        Assert.assertTrue(CollectionUtils.isEqualCollection(
                CollectionUtils.newArrayList(2, 3),
                CollectionUtils.removeAll(list, CollectionUtils.newArrayList(0, 1, 6))
        ));
    }
}