testcollectionutils.java

iBATIS似乎已远离众说纷纭的OR框架之列

    public void testIsSubCollectionOfSelf() {
        assertTrue(CollectionUtils.isSubCollection(collectionA,collectionA));
        assertTrue(CollectionUtils.isSubCollection(collectionB,collectionB));
    }

    public void testIsSubCollection() {
        assertTrue(!CollectionUtils.isSubCollection(collectionA,collectionB));
        assertTrue(!CollectionUtils.isSubCollection(collectionB,collectionA));
    }

    public void testIsSubCollection2() {
        Collection c = new ArrayList();
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("a");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("b");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("b");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("c");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("c");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("c");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("d");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("d");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("d");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(!CollectionUtils.isSubCollection(collectionA,c));
        c.add("d");
        assertTrue(CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(CollectionUtils.isSubCollection(collectionA,c));
        c.add("e");
        assertTrue(!CollectionUtils.isSubCollection(c,collectionA));
        assertTrue(CollectionUtils.isSubCollection(collectionA,c));
    }

    public void testIsEqualCollectionToSelf() {
        assertTrue(CollectionUtils.isEqualCollection(collectionA,collectionA));
        assertTrue(CollectionUtils.isEqualCollection(collectionB,collectionB));
    }

    public void testIsEqualCollection() {
        assertTrue(!CollectionUtils.isEqualCollection(collectionA,collectionB));
        assertTrue(!CollectionUtils.isEqualCollection(collectionB,collectionA));
    }

    public void testIsEqualCollection2() {
        Collection a = new ArrayList();
        Collection b = new ArrayList();
        assertTrue(CollectionUtils.isEqualCollection(a,b));
        assertTrue(CollectionUtils.isEqualCollection(b,a));
        a.add("1");
        assertTrue(!CollectionUtils.isEqualCollection(a,b));
        assertTrue(!CollectionUtils.isEqualCollection(b,a));
        b.add("1");
        assertTrue(CollectionUtils.isEqualCollection(a,b));
        assertTrue(CollectionUtils.isEqualCollection(b,a));
        a.add("2");
        assertTrue(!CollectionUtils.isEqualCollection(a,b));
        assertTrue(!CollectionUtils.isEqualCollection(b,a));
        b.add("2");
        assertTrue(CollectionUtils.isEqualCollection(a,b));
        assertTrue(CollectionUtils.isEqualCollection(b,a));
        a.add("1");
        assertTrue(!CollectionUtils.isEqualCollection(a,b));
        assertTrue(!CollectionUtils.isEqualCollection(b,a));
        b.add("1");
        assertTrue(CollectionUtils.isEqualCollection(a,b));
        assertTrue(CollectionUtils.isEqualCollection(b,a));
    }
    
    public void testIsProperSubCollection() {
        Collection a = new ArrayList();
        Collection b = new ArrayList();
        assertTrue(!CollectionUtils.isProperSubCollection(a,b));
        b.add("1");
        assertTrue(CollectionUtils.isProperSubCollection(a,b));
        assertTrue(!CollectionUtils.isProperSubCollection(b,a));
        assertTrue(!CollectionUtils.isProperSubCollection(b,b));
        assertTrue(!CollectionUtils.isProperSubCollection(a,a));
        a.add("1");
        a.add("2");
        b.add("2");
        assertTrue(!CollectionUtils.isProperSubCollection(b,a));
        assertTrue(!CollectionUtils.isProperSubCollection(a,b));
        a.add("1");
        assertTrue(CollectionUtils.isProperSubCollection(b,a));
        assertTrue(CollectionUtils.isProperSubCollection(
            CollectionUtils.intersection(collectionA, collectionB), collectionA));
        assertTrue(CollectionUtils.isProperSubCollection(
            CollectionUtils.subtract(a, b), a));
        assertTrue(!CollectionUtils.isProperSubCollection(
            a, CollectionUtils.subtract(a, b)));
    }
    
    public void testFind() {
        Predicate testPredicate = PredicateUtils.equalPredicate("d");
        Object test = CollectionUtils.find(collectionA, testPredicate);
        assertTrue(test.equals("d"));
        testPredicate = PredicateUtils.equalPredicate("de");
        test = CollectionUtils.find(collectionA, testPredicate);
        assertTrue(test == null);
        assertEquals(CollectionUtils.find(null,testPredicate), null);
        assertEquals(CollectionUtils.find(collectionA, null), null);
    }
    
    public void testForAllDo() {
        Closure testClosure = ClosureUtils.invokerClosure("clear");
        Collection col = new ArrayList();
        col.add(collectionA);
        col.add(collectionB);
        CollectionUtils.forAllDo(col, testClosure);
        assertTrue(collectionA.isEmpty() && collectionB.isEmpty());
        CollectionUtils.forAllDo(col, null);
        assertTrue(collectionA.isEmpty() && collectionB.isEmpty());
        CollectionUtils.forAllDo(null, testClosure);
        col.add(null);
        // null should be OK
        CollectionUtils.forAllDo(col, testClosure);
        col.add("x");
        // This will lead to FunctorException
        try {
            CollectionUtils.forAllDo(col, testClosure);
            fail("Expecting FunctorException");
        } catch (FunctorException ex) {
            // expected from invoker -- method not found
        }
    }

    public void testIndex() {     
        // normal map behavior when index is an Integer and a key
        Map map = new HashMap();
        map.put(new Integer(0), "zero");
        map.put(new Integer(-1), "minusOne");
        Object test = CollectionUtils.index(map, 0);
        assertTrue(test.equals("zero"));
        test = CollectionUtils.index(map, new Integer(-1));
        assertTrue(test.equals("minusOne"));
        
        // map, non-integer key that does not exist -- map returned
        test = CollectionUtils.index(map, "missing");
        assertTrue(test.equals(map));
        
        // map, integer not a key, valid index -- "some" element of keyset returned
        test = CollectionUtils.index(map, new Integer(1));   
        assertTrue(map.keySet().contains(test)); 
        
        // map, integer not a key, not valid index -- "dead" keyset iterator returned
        test = CollectionUtils.index(map, new Integer(4));         
        assertTrue((test instanceof Iterator) && !((Iterator) test).hasNext());  

        // sorted map, integer not a key, valid index -- ith key returned
        SortedMap map2 = new TreeMap();
        map2.put(new Integer(23), "u");
        map2.put(new Integer(21), "x");
        map2.put(new Integer(17), "v");
        map2.put(new Integer(42), "w");
        Integer val = (Integer) CollectionUtils.index(map2, 0);
        assertTrue(val.intValue() == 17);
        val = (Integer) CollectionUtils.index(map2, 1);
        assertTrue(val.intValue() == 21);
        val = (Integer) CollectionUtils.index(map2, 2);
        assertTrue(val.intValue() == 23);
        val = (Integer) CollectionUtils.index(map2, 3);
        assertTrue(val.intValue() == 42);   
                
        // list, entry exists
        List list = new ArrayList();
        list.add("zero");
        list.add("one");
        test = CollectionUtils.index(list, 0);
        assertTrue(test.equals("zero"));
        test = CollectionUtils.index(list, 1);
        assertTrue(test.equals("one"));
        
        // list, non-existent entry -- IndexOutOfBoundsException
        try {
            test = CollectionUtils.index(list, 2);
            fail("Expecting IndexOutOfBoundsException");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }
        
        // iterator, entry exists
        Iterator iterator = list.iterator();
        test = CollectionUtils.index(iterator,0);
        assertTrue(test.equals("zero"));
        iterator = list.iterator();
        test = CollectionUtils.index(iterator,1);
        assertTrue(test.equals("one"));
        
        // iterator, non-existent entry -- "dead" iterator returned
        test = CollectionUtils.index(iterator,3);
        assertTrue(test.equals(iterator) && !iterator.hasNext());
        
        // Enumeration, entry exists
        Vector vector = new Vector(list);
        Enumeration en = vector.elements();
        test = CollectionUtils.index(en,0);
        assertTrue(test.equals("zero"));
        en = vector.elements();
        test = CollectionUtils.index(en,1);
        assertTrue(test.equals("one"));
        
        // Enumeration, non-existent entry -- "dead" enumerator returned
        test = CollectionUtils.index(en,3);
        assertTrue(test.equals(en) && !en.hasMoreElements());
        
        // Collection, entry exists
        Bag bag = new HashBag();
        bag.add("element", 1);
        test = CollectionUtils.index(bag, 0);
        assertTrue(test.equals("element"));
        
        // Collection, non-existent entry -- "dead" iterator returned
        test = CollectionUtils.index(bag, 2);
        assertTrue((test instanceof Iterator) && !((Iterator) test).hasNext()); 
        
        // Object array, entry exists
        Object[] objArray = new Object[2];
        objArray[0] = "zero";
        objArray[1] = "one";
        test = CollectionUtils.index(objArray,0);
        assertTrue(test.equals("zero"));
        test = CollectionUtils.index(objArray,1);
        assertTrue(test.equals("one"));
        
        // Object array, non-existent entry -- ArrayIndexOutOfBoundsException
        try {
            test = CollectionUtils.index(objArray,2);
            fail("Expecting ArrayIndexOutOfBoundsException.");
        } catch (ArrayIndexOutOfBoundsException ex) {
            // expected
        }
        
        // Non-collection object -- returned unchanged
        Object obj = new Object();
        test = CollectionUtils.index(obj, obj);
        assertTrue(test.equals(obj));
    }
    
    public void testGet() {     
        {
            // Unordered map, entries exist
            Map expected = new HashMap();
            expected.put("zeroKey", "zero");
            expected.put("oneKey", "one");
        
            Map found = new HashMap();
            Map.Entry entry = (Map.Entry)(CollectionUtils.get(expected, 0));
            found.put(entry.getKey(),entry.getValue());
            entry = (Map.Entry)(CollectionUtils.get(expected, 1));
            found.put(entry.getKey(),entry.getValue());
            assertEquals(expected,found);
        
            // Map index out of range
            try {
                CollectionUtils.get(expected,  2);
                fail("Expecting IndexOutOfBoundsException.");
            } catch (IndexOutOfBoundsException e) {
                // expected
            }
            try {
                CollectionUtils.get(expected,  -2);
                fail("Expecting IndexOutOfBoundsException.");
            } catch (IndexOutOfBoundsException e) {
                // expected
            }
        }

        {
            // Sorted map, entries exist, should respect order
            SortedMap map = new TreeMap();
            map.put("zeroKey", "zero");
            map.put("oneKey", "one");
            Object test = CollectionUtils.get(map, 1);
            assertEquals("zeroKey",((Map.Entry) test).getKey());
            assertEquals("zero",((Map.Entry) test).getValue());
            test = CollectionUtils.get(map, 0);
            assertEquals("oneKey",((Map.Entry) test).getKey());
            assertEquals("one",((Map.Entry) test).getValue());
        }
                
        {
            // List, entry exists
            List list = new ArrayList();
            list.add("zero");
            list.add("one");
            assertEquals("zero",CollectionUtils.get(list, 0));
            assertEquals("one",CollectionUtils.get(list, 1));
            // list, non-existent entry -- IndexOutOfBoundsException
            try {
                CollectionUtils.get(list, 2);
                fail("Expecting IndexOutOfBoundsException");
            } catch (IndexOutOfBoundsException e) {
                // expected
            }

            // Iterator, entry exists
            Iterator iterator = list.iterator();
            assertEquals("zero",CollectionUtils.get(iterator,0));
            iterator = list.iterator();
            assertEquals("one",CollectionUtils.get(iterator,1));
        
            // Iterator, non-existent entry 
            try {
                CollectionUtils.get(iterator,3);
                fail("Expecting IndexOutOfBoundsException.");
            } catch (IndexOutOfBoundsException e) {
                // expected
            }
            assertTrue(!iterator.hasNext());