commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r815112 - /commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java
Date Tue, 15 Sep 2009 05:57:02 GMT
Author: bayard
Date: Tue Sep 15 05:57:01 2009
New Revision: 815112

URL: http://svn.apache.org/viewvc?rev=815112&view=rev
Log:
Merging from -r468106:814127 of collections_jdk5_branch - namely where this code was generified;
mostly in r738956.

Also see the following revisions:

    ------------------------------------------------------------------------
    r471580 | scolebourne | 2006-11-05 16:22:53 -0800 (Sun, 05 Nov 2006) | 1 line
    
    Generify CompositeCollection
    ------------------------------------------------------------------------

Modified:
    commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java

Modified: commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java
URL: http://svn.apache.org/viewvc/commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java?rev=815112&r1=815111&r2=815112&view=diff
==============================================================================
--- commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java
(original)
+++ commons/proper/collections/trunk/src/test/org/apache/commons/collections/collection/TestCompositeCollection.java
Tue Sep 15 05:57:01 2009
@@ -16,16 +16,18 @@
  */
 package org.apache.commons.collections.collection;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
 /**
- * Extension of {@link AbstractTestCollection} for exercising the 
+ * Extension of {@link AbstractTestCollection} for exercising the
  * {@link CompositeCollection} implementation.
  *
  * @since Commons Collections 3.0
@@ -34,12 +36,12 @@
  * @author Brian McCallister
  * @author Phil Steitz
  */
-public class TestCompositeCollection extends AbstractTestCollection {
-    
+public class TestCompositeCollection<E> extends AbstractTestCollection<E> {
+
     public TestCompositeCollection(String name) {
         super(name);
     }
-    
+
     public static Test suite() {
         return new TestSuite(TestCompositeCollection.class);
     }
@@ -48,7 +50,7 @@
         String[] testCaseName = { TestCompositeCollection.class.getName()};
         junit.textui.TestRunner.main(testCaseName);
     }
- 
+
  //-----------------------------------------------------------------------------
     /**
      * Run stock collection tests without Mutator, so turn off add, remove
@@ -56,145 +58,150 @@
     public boolean isAddSupported() {
         return false;
     }
-    
+
     public boolean isRemoveSupported() {
         return false;
     }
-    
+
     /**
      * Empty collection is empty composite
      */
-    public Collection makeCollection() {
-        return new CompositeCollection();
+    public Collection<E> makeObject() {
+        return new CompositeCollection<E>();
     }
-    
-    public Collection makeConfirmedCollection() {
-        return new HashSet();
-    }
-    
-    public Object[] getFullElements() {
-        return new Object[] {"1", "2", "3", "4"};
+
+    public Collection<E> makeConfirmedCollection() {
+        return new HashSet<E>();
+    }
+
+    @SuppressWarnings("unchecked")
+    public E[] getFullElements() {
+        return (E[]) new Object[] { "1", "2", "3", "4" };
     }
-    
+
     /**
      * Full collection consists of 4 collections, each with one element
      */
-    public Collection makeFullCollection() {
-        CompositeCollection compositeCollection = new CompositeCollection();
-        Object[] elements = getFullElements();
+    public Collection<E> makeFullCollection() {
+        CompositeCollection<E> compositeCollection = new CompositeCollection<E>();
+        E[] elements = getFullElements();
         for (int i = 0; i < elements.length; i++) {
-            Collection summand = new HashSet();
+            Collection<E> summand = new HashSet<E>();
             summand.add(elements[i]);
             compositeCollection.addComposited(summand);
         }
         return compositeCollection;
     }
-    
+
     /**
      * Full collection should look like a collection with 4 elements
      */
-    public Collection makeConfirmedFullCollection() {
-        Collection collection = new HashSet();
+    public Collection<E> makeConfirmedFullCollection() {
+        Collection<E> collection = new HashSet<E>();
         collection.addAll(Arrays.asList(getFullElements()));
         return collection;
     }
-    
+
     /**
      * Override testUnsupportedRemove, since the default impl expects removeAll,
      * retainAll and iterator().remove to throw
      */
-    public void testUnsupportedRemove() {    
+    public void testUnsupportedRemove() {
         resetFull();
         try {
-            collection.remove(null);
+            getCollection().remove(null);
             fail("remove should raise UnsupportedOperationException");
         } catch (UnsupportedOperationException e) {
             // expected
         }
         verify();
     }
-    
+
     //--------------------------------------------------------------------------
-    
-    protected CompositeCollection c;
-    protected Collection one;
-    protected Collection two;
-    
+
+    protected CompositeCollection<E> c;
+    protected Collection<E> one;
+    protected Collection<E> two;
+
     protected void setUpTest() {
-        c = new CompositeCollection();
-        one = new HashSet();
-        two = new HashSet();
+        c = new CompositeCollection<E>();
+        one = new HashSet<E>();
+        two = new HashSet<E>();
     }
-    
+
     protected void setUpMutatorTest() {
         setUpTest();
-        c.setMutator(new CompositeCollection.CollectionMutator() {
-            public boolean add(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].add(obj);
+        c.setMutator(new CompositeCollection.CollectionMutator<E>() {
+            public boolean add(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, E obj) {
+                for (Collection<E> collection : collections) {
+                    collection.add(obj);
                 }
                 return true;
             }
-            
-            public boolean addAll(CompositeCollection composite, 
-            Collection[] collections, Collection coll) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].addAll(coll);
+
+            public boolean addAll(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Collection<? extends
E> coll) {
+                for (Collection<E> collection : collections) {
+                    collection.addAll(coll);
                 }
                 return true;
             }
-            
-            public boolean remove(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].remove(obj);
+
+            public boolean remove(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Object obj) {
+                for (Collection<E> collection : collections) {
+                    collection.remove(obj);
                 }
                 return true;
             }
         });
     }
-            
+
+    @SuppressWarnings("unchecked")
     public void testSize() {
         setUpTest();
-        HashSet set = new HashSet();
-        set.add("a");
-        set.add("b");
+        HashSet<E> set = new HashSet<E>();
+        set.add((E) "a");
+        set.add((E) "b");
         c.addComposited(set);
         assertEquals(set.size(), c.size());
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testMultipleCollectionsSize() {
         setUpTest();
-        HashSet set = new HashSet();
-        set.add("a");
-        set.add("b");
+        HashSet<E> set = new HashSet<E>();
+        set.add((E) "a");
+        set.add((E) "b");
         c.addComposited(set);
-        HashSet other = new HashSet();
-        other.add("c");
+        HashSet<E> other = new HashSet<E>();
+        other.add((E) "c");
         c.addComposited(other);
         assertEquals(set.size() + other.size(), c.size());
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testIsEmpty() {
         setUpTest();
         assertTrue(c.isEmpty());
-        HashSet empty = new HashSet();
+        HashSet<E> empty = new HashSet<E>();
         c.addComposited(empty);
         assertTrue(c.isEmpty());
-        empty.add("a");
+        empty.add((E) "a");
         assertTrue(!c.isEmpty());
     }
-    
-    
+
+
+    @SuppressWarnings("unchecked")
     public void testIterator() {
         setUpTest();
-        one.add("1");
-        two.add("2");
+        one.add((E) "1");
+        two.add((E) "2");
         c.addComposited(one);
         c.addComposited(two);
-        Iterator i = c.iterator();
-        Object next = i.next();
+        Iterator<E> i = c.iterator();
+        E next = i.next();
         assertTrue(c.contains(next));
         assertTrue(one.contains(next));
         next = i.next();
@@ -202,31 +209,34 @@
         assertTrue(!c.contains(next));
         assertTrue(!two.contains(next));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testClear() {
         setUpTest();
-        one.add("1");
-        two.add("2");
+        one.add((E) "1");
+        two.add((E) "2");
         c.addComposited(one, two);
         c.clear();
         assertTrue(one.isEmpty());
         assertTrue(two.isEmpty());
         assertTrue(c.isEmpty());
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testContainsAll() {
         setUpTest();
-        one.add("1");
-        two.add("1");
+        one.add((E) "1");
+        two.add((E) "1");
         c.addComposited(one);
         assertTrue(c.containsAll(two));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testRetainAll() {
         setUpTest();
-        one.add("1");
-        one.add("2");
-        two.add("1");
+        one.add((E) "1");
+        one.add((E) "2");
+        two.add((E) "1");
         c.addComposited(one);
         c.retainAll(two);
         assertTrue(!c.contains("2"));
@@ -234,123 +244,132 @@
         assertTrue(c.contains("1"));
         assertTrue(one.contains("1"));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testAddAllMutator() {
         setUpTest();
-        c.setMutator(new CompositeCollection.CollectionMutator() {
-            public boolean add(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].add(obj);
+        c.setMutator(new CompositeCollection.CollectionMutator<E>() {
+            public boolean add(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, E obj) {
+                for (Collection<E> collection : collections) {
+                    collection.add(obj);
                 }
                 return true;
             }
-            
-            public boolean addAll(CompositeCollection composite, 
-            Collection[] collections, Collection coll) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].addAll(coll);
+
+            public boolean addAll(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Collection<? extends
E> coll) {
+                for (Collection<E> collection : collections) {
+                    collection.addAll(coll);
                 }
                 return true;
             }
-            
-            public boolean remove(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
+
+            public boolean remove(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Object obj) {
                 return false;
             }
         });
-        
+
         c.addComposited(one);
-        two.add("foo");
+        two.add((E) "foo");
         c.addAll(two);
         assertTrue(c.contains("foo"));
         assertTrue(one.contains("foo"));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testAddMutator() {
         setUpTest();
-        c.setMutator(new CompositeCollection.CollectionMutator() {
-            public boolean add(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].add(obj);
+        c.setMutator(new CompositeCollection.CollectionMutator<E>() {
+            public boolean add(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, E obj) {
+                for (Collection<E> collection : collections) {
+                    collection.add(obj);
                 }
                 return true;
             }
-            
-            public boolean addAll(CompositeCollection composite, 
-            Collection[] collections, Collection coll) {
-                for (int i = 0; i < collections.length; i++) {
-                    collections[i].addAll(coll);
+
+            public boolean addAll(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Collection<? extends
E> coll) {
+                for (Collection<E> collection : collections) {
+                    collection.addAll(coll);
                 }
                 return true;
             }
-            
-            public boolean remove(CompositeCollection composite, 
-            Collection[] collections, Object obj) {
+
+            public boolean remove(CompositeCollection<E> composite,
+                    List<Collection<E>> collections, Object obj) {
                 return false;
             }
         });
-        
+
         c.addComposited(one);
-        c.add("foo");
+        c.add((E) "foo");
         assertTrue(c.contains("foo"));
         assertTrue(one.contains("foo"));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testToCollection() {
         setUpTest();
-        one.add("1");
-        two.add("2");
+        one.add((E) "1");
+        two.add((E) "2");
         c.addComposited(one, two);
-        Collection foo = c.toCollection();
+        Collection<E> foo = c.toCollection();
         assertTrue(foo.containsAll(c));
         assertEquals(c.size(), foo.size());
-        one.add("3");
+        one.add((E) "3");
         assertTrue(!foo.containsAll(c));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testAddAllToCollection() {
         setUpTest();
-        one.add("1");
-        two.add("2");
+        one.add((E) "1");
+        two.add((E) "2");
         c.addComposited(one, two);
-        Collection toCollection = new HashSet();
+        Collection<E> toCollection = new HashSet<E>();
         toCollection.addAll(c);
         assertTrue(toCollection.containsAll(c));
         assertEquals(c.size(), toCollection.size());
-    }   
-    
+    }
+
+    @SuppressWarnings("unchecked")
     public void testRemove() {
         setUpMutatorTest();
-        one.add("1");
-        two.add("2");
-        two.add("1");
+        one.add((E) "1");
+        two.add((E) "2");
+        two.add((E) "1");
         c.addComposited(one, two);
         c.remove("1");
         assertTrue(!c.contains("1"));
         assertTrue(!one.contains("1"));
         assertTrue(!two.contains("1"));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testRemoveAll() {
         setUpMutatorTest();
-        one.add("1");
-        two.add("2");
-        two.add("1");
+        one.add((E) "1");
+        two.add((E) "2");
+        two.add((E) "1");
+        // need separate list to remove, as otherwise one clears itself
+        Collection<E> removing = new ArrayList<E>(one);
         c.addComposited(one, two);
-        c.removeAll(one);
+        c.removeAll(removing);
         assertTrue(!c.contains("1"));
         assertTrue(!one.contains("1"));
         assertTrue(!two.contains("1"));
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testRemoveComposited() {
         setUpMutatorTest();
-        one.add("1");
-        two.add("2");
-        two.add("1");
-        c.addComposited(one, two);    
+        one.add((E) "1");
+        two.add((E) "2");
+        two.add((E) "1");
+        c.addComposited(one, two);
         c.removeComposited(one);
         assertTrue(c.contains("1"));
         assertEquals(2, c.size());



Mime
View raw message