commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject [13/77] [abbrv] commons-collections git commit: finish generics (minus one class)
Date Tue, 11 Jul 2017 17:54:58 GMT
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestBoundedBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestBoundedBuffer.java b/src/test/org/apache/commons/collections/buffer/TestBoundedBuffer.java
index 5ad63d7..057f469 100644
--- a/src/test/org/apache/commons/collections/buffer/TestBoundedBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestBoundedBuffer.java
@@ -28,7 +28,7 @@ import java.util.Arrays;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
-public class TestBoundedBuffer extends AbstractTestObject {
+public class TestBoundedBuffer<E> extends AbstractTestObject {
 
     public TestBoundedBuffer(String testName) {
         super(testName);
@@ -51,136 +51,142 @@ public class TestBoundedBuffer extends AbstractTestObject {
         return false;
     }
 
-    public Object makeObject() {
-        return BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1);
+    public Buffer<E> makeObject() {
+        return BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 1);
     }
 
     //-----------------------------------------------------------------------
+    @SuppressWarnings("unchecked")
     public void testMaxSize() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 2, 500);
-        BoundedCollection bc = (BoundedCollection) bounded;
+        final Buffer<E> bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 2, 500);
+        BoundedCollection<?> bc = (BoundedCollection<?>) bounded;
         assertEquals(2, bc.maxSize());
         assertEquals(false, bc.isFull());
-        bounded.add("A");
+        bounded.add((E) "A");
         assertEquals(false, bc.isFull());
-        bounded.add("B");
+        bounded.add((E) "B");
         assertEquals(true, bc.isFull());
         bounded.remove();
         assertEquals(false, bc.isFull());
         try {
-            BoundedBuffer.decorate(new UnboundedFifoBuffer(), 0);
+            BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 0);
             fail();
         } catch (IllegalArgumentException ex) {}
         try {
-            BoundedBuffer.decorate(new UnboundedFifoBuffer(), -1);
+            BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), -1);
             fail();
         } catch (IllegalArgumentException ex) {}
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddToFullBufferNoTimeout() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1);
-        bounded.add( "Hello" );
+        final Buffer<E> bounded = makeObject();
+        bounded.add((E) "Hello");
         try {
-            bounded.add("World");
+            bounded.add((E) "World");
             fail();
         } catch (BufferOverflowException e) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddAllToFullBufferNoTimeout() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1);
-        bounded.add( "Hello" );
+        final Buffer<E> bounded = makeObject();
+        bounded.add((E) "Hello");
         try {
-            bounded.addAll(Collections.singleton("World"));
+            bounded.addAll(Collections.singleton((E) "World"));
             fail();
         } catch (BufferOverflowException e) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddAllToEmptyBufferExceedMaxSizeNoTimeout() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1);
+        final Buffer<E> bounded = makeObject();
         try {
-            bounded.addAll(Collections.nCopies(2, "test"));
+            bounded.addAll(Collections.nCopies(2, (E) "test"));
             fail();
         } catch (BufferOverflowException e) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddToFullBufferRemoveViaIterator() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1, 500);
-        bounded.add( "Hello" );
-        new DelayedIteratorRemove( bounded, 200 ).start();
-        bounded.add( "World" );
-        assertEquals( 1, bounded.size() );
-        assertEquals( "World", bounded.get() );
+        final Buffer<E> bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 1, 500);
+        bounded.add((E) "Hello");
+        new DelayedIteratorRemove(bounded, 200).start();
+        bounded.add((E) "World");
+        assertEquals(1, bounded.size());
+        assertEquals("World", bounded.get());
 
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddAllToFullBufferRemoveViaIterator() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 2, 500);
-        bounded.add( "Hello" );
-        bounded.add( "World" );
-        new DelayedIteratorRemove( bounded, 200, 2 ).start();
-        bounded.addAll( Arrays.asList( new String[] { "Foo", "Bar" } ) );
-        assertEquals( 2, bounded.size() );
-        assertEquals( "Foo", bounded.remove() );
-        assertEquals( "Bar", bounded.remove() );
+        final Buffer<E> bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 2, 500);
+        bounded.add((E) "Hello");
+        bounded.add((E) "World");
+        new DelayedIteratorRemove(bounded, 200, 2).start();
+        bounded.addAll(Arrays.asList((E[]) new String[] { "Foo", "Bar" }));
+        assertEquals(2, bounded.size());
+        assertEquals("Foo", bounded.remove());
+        assertEquals("Bar", bounded.remove());
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddToFullBufferWithTimeout() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 1, 500);
-        bounded.add( "Hello" );
-        new DelayedRemove( bounded, 200 ).start();
-        bounded.add( "World" );
-        assertEquals( 1, bounded.size() );
-        assertEquals( "World", bounded.get() );
+        final Buffer<E> bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 1, 500);
+        bounded.add((E) "Hello");
+        new DelayedRemove(bounded, 200).start();
+        bounded.add((E) "World");
+        assertEquals(1, bounded.size());
+        assertEquals("World", bounded.get());
         try {
-            bounded.add( "!" );
+            bounded.add((E) "!");
             fail();
-        }
-        catch( BufferOverflowException e ) {
+        } catch (BufferOverflowException e) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     public void testAddAllToFullBufferWithTimeout() {
-        final Buffer bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer(), 2, 500);
-        bounded.add( "Hello" );
-        bounded.add( "World" );
-        new DelayedRemove( bounded, 200, 2 ).start();
-
-        bounded.addAll( Arrays.asList( new String[] { "Foo", "Bar" } ) );
-        assertEquals( 2, bounded.size() );
-        assertEquals( "Foo", bounded.get() );
+        final Buffer<E> bounded = BoundedBuffer.decorate(new UnboundedFifoBuffer<E>(), 2, 500);
+        bounded.add((E) "Hello");
+        bounded.add((E) "World");
+        new DelayedRemove(bounded, 200, 2).start();
+
+        bounded.addAll(Arrays.asList((E[]) new String[] { "Foo", "Bar" }));
+        assertEquals(2, bounded.size());
+        assertEquals("Foo", bounded.get());
         try {
-            bounded.add( "!" );
+            bounded.add((E) "!");
             fail();
-        }
-        catch( BufferOverflowException e ) {
+        } catch (BufferOverflowException e) {
         }
     }
 
     private class DelayedIteratorRemove extends Thread {
 
-        private final Buffer buffer;
+        private final Buffer<?> buffer;
 
         private final long delay;
 
         private final int nToRemove;
 
-        public DelayedIteratorRemove(Buffer buffer, long delay, int nToRemove) {
+        public DelayedIteratorRemove(Buffer<?> buffer, long delay, int nToRemove) {
             this.buffer = buffer;
             this.delay = delay;
             this.nToRemove = nToRemove;
         }
 
-        public DelayedIteratorRemove(Buffer buffer, long delay) {
+        public DelayedIteratorRemove(Buffer<?> buffer, long delay) {
             this(buffer, delay, 1);
         }
 
         public void run() {
             try {
                 Thread.sleep(delay);
-                Iterator iter = buffer.iterator();
+                Iterator<?> iter = buffer.iterator();
                 for (int i = 0; i < nToRemove; ++i) {
                     iter.next();
                     iter.remove();
@@ -193,19 +199,19 @@ public class TestBoundedBuffer extends AbstractTestObject {
 
     private class DelayedRemove extends Thread {
 
-        private final Buffer buffer;
+        private final Buffer<?> buffer;
 
         private final long delay;
 
         private final int nToRemove;
 
-        public DelayedRemove(Buffer buffer, long delay, int nToRemove) {
+        public DelayedRemove(Buffer<?> buffer, long delay, int nToRemove) {
             this.buffer = buffer;
             this.delay = delay;
             this.nToRemove = nToRemove;
         }
 
-        public DelayedRemove(Buffer buffer, long delay) {
+        public DelayedRemove(Buffer<?> buffer, long delay) {
             this(buffer, delay, 1);
         }
 

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer.java b/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer.java
index a767b6c..8ea7113 100644
--- a/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -17,8 +17,8 @@
 package org.apache.commons.collections.buffer;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 
 import junit.framework.Test;
 
@@ -28,12 +28,12 @@ import org.apache.commons.collections.collection.AbstractTestCollection;
 
 /**
  * Test cases for BoundedFifoBuffer.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Paul Jack
  */
-public class TestBoundedFifoBuffer extends AbstractTestCollection {
+public class TestBoundedFifoBuffer<E> extends AbstractTestCollection<E> {
 
     public TestBoundedFifoBuffer(String n) {
         super(n);
@@ -45,18 +45,18 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
 
     //-----------------------------------------------------------------------
     /**
-     *  Runs through the regular verifications, but also verifies that 
+     *  Runs through the regular verifications, but also verifies that
      *  the buffer contains the same elements in the same sequence as the
      *  list.
      */
     public void verify() {
         super.verify();
-        Iterator iterator1 = collection.iterator();
-        Iterator iterator2 = confirmed.iterator();
+        Iterator<E> iterator1 = getCollection().iterator();
+        Iterator<E> iterator2 = getConfirmed().iterator();
         while (iterator2.hasNext()) {
             assertTrue(iterator1.hasNext());
-            Object o1 = iterator1.next();
-            Object o2 = iterator2.next();
+            E o1 = iterator1.next();
+            E o2 = iterator2.next();
             assertEquals(o1, o2);
         }
     }
@@ -78,14 +78,14 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
         return false;
     }
 
-    //-----------------------------------------------------------------------  
+    //-----------------------------------------------------------------------
     /**
      *  Returns an empty ArrayList.
      *
      *  @return an empty ArrayList
      */
-    public Collection makeConfirmedCollection() {
-        return new ArrayList();
+    public List<E> makeConfirmedCollection() {
+        return new ArrayList<E>();
     }
 
     /**
@@ -93,37 +93,37 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
      *
      *  @return a full ArrayList
      */
-    public Collection makeConfirmedFullCollection() {
-        Collection c = makeConfirmedCollection();
+    public List<E> makeConfirmedFullCollection() {
+        List<E> c = makeConfirmedCollection();
         c.addAll(java.util.Arrays.asList(getFullElements()));
         return c;
     }
 
     /**
-     *  Returns an empty BoundedFifoBuffer that won't overflow.  
-     *  
+     *  Returns an empty BoundedFifoBuffer that won't overflow.
+     *
      *  @return an empty BoundedFifoBuffer
      */
-    public Collection makeCollection() {
-        return new BoundedFifoBuffer(100);
+    public BoundedFifoBuffer<E> makeObject() {
+        return new BoundedFifoBuffer<E>(100);
     }
 
-    //-----------------------------------------------------------------------  
+    //-----------------------------------------------------------------------
     /**
      * Tests that the removal operation actually removes the first element.
      */
     public void testBoundedFifoBufferRemove() {
         resetFull();
-        int size = confirmed.size();
+        int size = getConfirmed().size();
         for (int i = 0; i < size; i++) {
-            Object o1 = ((BoundedFifoBuffer)collection).remove();
-            Object o2 = ((ArrayList)confirmed).remove(0);
+            E o1 = getCollection().remove();
+            E o2 = getConfirmed().remove(0);
             assertEquals("Removed objects should be equal", o1, o2);
             verify();
         }
 
         try {
-            ((BoundedFifoBuffer)collection).remove();
+            getCollection().remove();
             fail("Empty buffer should raise Underflow.");
         } catch (BufferUnderflowException e) {
             // expected
@@ -135,19 +135,19 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException1() {
         try {
-            new BoundedFifoBuffer(0);
+            new BoundedFifoBuffer<E>(0);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     /**
      * Tests that the constructor correctly throws an exception.
      */
     public void testConstructorException2() {
         try {
-            new BoundedFifoBuffer(-20);
+            new BoundedFifoBuffer<E>(-20);
         } catch (IllegalArgumentException ex) {
             return;
         }
@@ -159,7 +159,7 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException3() {
         try {
-            new BoundedFifoBuffer(null);
+            new BoundedFifoBuffer<E>(null);
         } catch (NullPointerException ex) {
             return;
         }
@@ -169,15 +169,16 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
     public String getCompatibilityVersion() {
         return "3.1";
     }
-    
+
     // BZ 33071 -- gets start=end=1 before removal of interior element
+    @SuppressWarnings("unchecked")
     public void testShift() {
-        BoundedFifoBuffer fifo = new BoundedFifoBuffer(3);
-        fifo.add("a");
-        fifo.add("b");
-        fifo.add("c");
+        BoundedFifoBuffer<E> fifo = new BoundedFifoBuffer<E>(3);
+        fifo.add((E) "a");
+        fifo.add((E) "b");
+        fifo.add((E) "c");
         fifo.remove();
-        fifo.add("e");
+        fifo.add((E) "e");
         fifo.remove("c");
     }
 
@@ -188,4 +189,19 @@ public class TestBoundedFifoBuffer extends AbstractTestCollection {
 //        writeExternalFormToDisk((java.io.Serializable) collection, "D:/dev/collections/data/test/BoundedFifoBuffer.fullCollection.version3.1.obj");
 //    }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public BoundedFifoBuffer<E> getCollection() {
+        return (BoundedFifoBuffer<E>) super.getCollection();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public List<E> getConfirmed() {
+        return (List<E>) super.getConfirmed();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer2.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer2.java b/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer2.java
index abe84d8..7efcbd1 100644
--- a/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer2.java
+++ b/src/test/org/apache/commons/collections/buffer/TestBoundedFifoBuffer2.java
@@ -21,7 +21,6 @@ import java.util.Collection;
 
 import junit.framework.Test;
 
-import org.apache.commons.collections.BoundedCollection;
 import org.apache.commons.collections.BufferOverflowException;
 import org.apache.commons.collections.BulkTest;
 
@@ -33,7 +32,7 @@ import org.apache.commons.collections.BulkTest;
  * 
  * @author Unknown
  */
-public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
+public class TestBoundedFifoBuffer2<E> extends TestBoundedFifoBuffer<E> {
 
     public TestBoundedFifoBuffer2(String n) {
         super(n);
@@ -50,11 +49,10 @@ public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
      *
      *  @return a full BoundedFifoBuffer
      */
-    public Collection makeFullCollection() {
-        return new BoundedFifoBuffer(Arrays.asList(getFullElements()));
+    public Collection<E> makeFullCollection() {
+        return new BoundedFifoBuffer<E>(Arrays.asList(getFullElements()));
     }
 
-
     /**
      *  Overridden to skip the add tests.  All of them would fail with a 
      *  BufferOverflowException.
@@ -65,7 +63,6 @@ public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
         return false;
     }
 
-
     /**
      *  Overridden because the add operations raise BufferOverflowException
      *  instead of UnsupportedOperationException.
@@ -73,14 +70,13 @@ public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
     public void testUnsupportedAdd() {
     }
 
-
     /**
      *  Tests to make sure the add operations raise BufferOverflowException.
      */
     public void testBufferOverflow() {
         resetFull();
         try {
-            collection.add(getOtherElements()[0]);
+            getCollection().add(getOtherElements()[0]);
             fail("add should raise BufferOverflow.");
         } catch (BufferOverflowException e) {
             // expected
@@ -88,7 +84,7 @@ public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
         verify();
 
         try {
-            collection.addAll(Arrays.asList(getOtherElements()));
+            getCollection().addAll(Arrays.asList(getOtherElements()));
             fail("addAll should raise BufferOverflow.");
         } catch (BufferOverflowException e) {
             // expected
@@ -99,25 +95,27 @@ public class TestBoundedFifoBuffer2 extends TestBoundedFifoBuffer {
     /**
      * Tests is full
      */
+    @SuppressWarnings("unchecked")
     public void testIsFull() {
         resetFull();
-        assertEquals(true, ((BoundedCollection) collection).isFull());
-        ((BoundedFifoBuffer) collection).remove();
-        assertEquals(false, ((BoundedCollection) collection).isFull());
-        ((BoundedFifoBuffer) collection).add("jj");
-        assertEquals(true, ((BoundedCollection) collection).isFull());
+        assertEquals(true, getCollection().isFull());
+        getCollection().remove();
+        assertEquals(false, getCollection().isFull());
+        getCollection().add((E) "jj");
+        assertEquals(true, getCollection().isFull());
     }
 
     /**
      * Tests max size
      */
+    @SuppressWarnings("unchecked")
     public void testMaxSize() {
         resetFull();
-        assertEquals(getFullElements().length, ((BoundedCollection) collection).maxSize());
-        ((BoundedFifoBuffer) collection).remove();
-        assertEquals(getFullElements().length, ((BoundedCollection) collection).maxSize());
-        ((BoundedFifoBuffer) collection).add("jj");
-        assertEquals(getFullElements().length, ((BoundedCollection) collection).maxSize());
+        assertEquals(getFullElements().length, getCollection().maxSize());
+        getCollection().remove();
+        assertEquals(getFullElements().length, getCollection().maxSize());
+        getCollection().add((E) "jj");
+        assertEquals(getFullElements().length, getCollection().maxSize());
     }
 
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestCircularFifoBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestCircularFifoBuffer.java b/src/test/org/apache/commons/collections/buffer/TestCircularFifoBuffer.java
index 78f0507..cf1aebd 100644
--- a/src/test/org/apache/commons/collections/buffer/TestCircularFifoBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestCircularFifoBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -35,12 +35,12 @@ import org.apache.commons.collections.collection.AbstractTestCollection;
 
 /**
  * Test cases for CircularFifoBuffer.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Stephen Colebourne
  */
-public class TestCircularFifoBuffer extends AbstractTestCollection {
+public class TestCircularFifoBuffer<E> extends AbstractTestCollection<E> {
 
     public TestCircularFifoBuffer(String n) {
         super(n);
@@ -56,14 +56,14 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
 
     //-----------------------------------------------------------------------
     /**
-     *  Runs through the regular verifications, but also verifies that 
+     *  Runs through the regular verifications, but also verifies that
      *  the buffer contains the same elements in the same sequence as the
      *  list.
      */
     public void verify() {
         super.verify();
-        Iterator iterator1 = collection.iterator();
-        Iterator iterator2 = confirmed.iterator();
+        Iterator<E> iterator1 = getCollection().iterator();
+        Iterator<E> iterator2 = getConfirmed().iterator();
         while (iterator2.hasNext()) {
             assertTrue(iterator1.hasNext());
             Object o1 = iterator1.next();
@@ -95,8 +95,8 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
      *
      * @return an empty ArrayList
      */
-    public Collection makeConfirmedCollection() {
-        return new ArrayList();
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayList<E>();
     }
 
     /**
@@ -104,43 +104,44 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
      *
      * @return a full ArrayList
      */
-    public Collection makeConfirmedFullCollection() {
-        Collection c = makeConfirmedCollection();
+    public Collection<E> makeConfirmedFullCollection() {
+        Collection<E> c = makeConfirmedCollection();
         c.addAll(java.util.Arrays.asList(getFullElements()));
         return c;
     }
 
     /**
-     * Returns an empty BoundedFifoBuffer that won't overflow.  
-     *  
+     * Returns an empty BoundedFifoBuffer that won't overflow.
+     *
      * @return an empty BoundedFifoBuffer
      */
-    public Collection makeCollection() {
-        return new CircularFifoBuffer(100);
+    public Collection<E> makeObject() {
+        return new CircularFifoBuffer<E>(100);
     }
 
     //-----------------------------------------------------------------------
     /**
      * Tests that the removal operation actually removes the first element.
      */
+    @SuppressWarnings("unchecked")
     public void testCircularFifoBufferCircular() {
-        List list = new ArrayList();
-        list.add("A");
-        list.add("B");
-        list.add("C");
-        Buffer buf = new CircularFifoBuffer(list);
-        
+        List<E> list = new ArrayList<E>();
+        list.add((E) "A");
+        list.add((E) "B");
+        list.add((E) "C");
+        Buffer<E> buf = new CircularFifoBuffer<E>(list);
+
         assertEquals(true, buf.contains("A"));
         assertEquals(true, buf.contains("B"));
         assertEquals(true, buf.contains("C"));
-        
-        buf.add("D");
-        
+
+        buf.add((E) "D");
+
         assertEquals(false, buf.contains("A"));
         assertEquals(true, buf.contains("B"));
         assertEquals(true, buf.contains("C"));
         assertEquals(true, buf.contains("D"));
-        
+
         assertEquals("B", buf.get());
         assertEquals("B", buf.remove());
         assertEquals("C", buf.remove());
@@ -152,16 +153,16 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
      */
     public void testCircularFifoBufferRemove() {
         resetFull();
-        int size = confirmed.size();
+        int size = getConfirmed().size();
         for (int i = 0; i < size; i++) {
-            Object o1 = ((CircularFifoBuffer) collection).remove();
-            Object o2 = ((ArrayList) confirmed).remove(0);
+            Object o1 = getCollection().remove();
+            Object o2 = getConfirmed().remove(0);
             assertEquals("Removed objects should be equal", o1, o2);
             verify();
         }
 
         try {
-            ((CircularFifoBuffer) collection).remove();
+            getCollection().remove();
             fail("Empty buffer should raise Underflow.");
         } catch (BufferUnderflowException e) {
             // expected
@@ -173,7 +174,7 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException1() {
         try {
-            new CircularFifoBuffer(0);
+            new CircularFifoBuffer<E>(0);
         } catch (IllegalArgumentException ex) {
             return;
         }
@@ -185,220 +186,230 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException2() {
         try {
-            new CircularFifoBuffer(-20);
+            new CircularFifoBuffer<E>(-20);
         } catch (IllegalArgumentException ex) {
             return;
         }
         fail();
     }
-    
+
     /**
      * Tests that the constructor correctly throws an exception.
      */
     public void testConstructorException3() {
         try {
-            new CircularFifoBuffer(null);
+            new CircularFifoBuffer<E>(null);
         } catch (NullPointerException ex) {
             return;
         }
         fail();
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testRemoveError1() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");
+
         assertEquals("[1, 2, 3, 4, 5]", fifo.toString());
-        
+
         fifo.remove("3");
         assertEquals("[1, 2, 4, 5]", fifo.toString());
-        
+
         fifo.remove("4");
         assertEquals("[1, 2, 5]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError2() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");
-        fifo.add("6");
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");
+        fifo.add((E) "6");
+
         assertEquals(5, fifo.size());
         assertEquals("[2, 3, 4, 5, 6]", fifo.toString());
-        
+
         fifo.remove("3");
         assertEquals("[2, 4, 5, 6]", fifo.toString());
-        
+
         fifo.remove("4");
         assertEquals("[2, 5, 6]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError3() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");
+
         assertEquals("[1, 2, 3, 4, 5]", fifo.toString());
-        
+
         fifo.remove("3");
         assertEquals("[1, 2, 4, 5]", fifo.toString());
-        
-        fifo.add("6");
-        fifo.add("7");
+
+        fifo.add((E) "6");
+        fifo.add((E) "7");
         assertEquals("[2, 4, 5, 6, 7]", fifo.toString());
-        
+
         fifo.remove("4");
         assertEquals("[2, 5, 6, 7]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError4() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+
         assertEquals("[3, 4, 5, 6, 7]", fifo.toString());
-        
+
         fifo.remove("4");  // remove element in middle of array, after start
         assertEquals("[3, 5, 6, 7]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError5() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+
         assertEquals("[3, 4, 5, 6, 7]", fifo.toString());
-        
+
         fifo.remove("5");  // remove element at last pos in array
         assertEquals("[3, 4, 6, 7]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError6() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+
         assertEquals("[3, 4, 5, 6, 7]", fifo.toString());
-        
+
         fifo.remove("6");  // remove element at position zero in array
         assertEquals("[3, 4, 5, 7]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError7() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+
         assertEquals("[3, 4, 5, 6, 7]", fifo.toString());
-        
+
         fifo.remove("7");  // remove element at position one in array
         assertEquals("[3, 4, 5, 6]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError8() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        fifo.add("8");  // end=3
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+        fifo.add((E) "8");  // end=3
+
         assertEquals("[4, 5, 6, 7, 8]", fifo.toString());
-        
+
         fifo.remove("7");  // remove element at position one in array, need to shift 8
         assertEquals("[4, 5, 6, 8]", fifo.toString());
     }
 
+    @SuppressWarnings("unchecked")
     public void testRemoveError9() throws Exception {
         // based on bug 33071
-        CircularFifoBuffer fifo = new CircularFifoBuffer(5);
-        fifo.add("1");
-        fifo.add("2");
-        fifo.add("3");
-        fifo.add("4");
-        fifo.add("5");  // end=0
-        fifo.add("6");  // end=1
-        fifo.add("7");  // end=2
-        fifo.add("8");  // end=3
-        
+        CircularFifoBuffer<E> fifo = new CircularFifoBuffer<E>(5);
+        fifo.add((E) "1");
+        fifo.add((E) "2");
+        fifo.add((E) "3");
+        fifo.add((E) "4");
+        fifo.add((E) "5");  // end=0
+        fifo.add((E) "6");  // end=1
+        fifo.add((E) "7");  // end=2
+        fifo.add((E) "8");  // end=3
+
         assertEquals("[4, 5, 6, 7, 8]", fifo.toString());
-        
+
         fifo.remove("8");  // remove element at position two in array
         assertEquals("[4, 5, 6, 7]", fifo.toString());
     }
 
     //-----------------------------------------------------------------------
+    @SuppressWarnings("unchecked")
     public void testRepeatedSerialization() throws Exception {
         // bug 31433
-        CircularFifoBuffer b = new CircularFifoBuffer(2);
-        b.add("a");
+        CircularFifoBuffer<E> b = new CircularFifoBuffer<E>(2);
+        b.add((E) "a");
         assertEquals(1, b.size());
         assertEquals(true, b.contains("a"));
-        
+
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         new ObjectOutputStream(bos).writeObject(b);
-        
-        CircularFifoBuffer b2 = (CircularFifoBuffer) new ObjectInputStream(
+
+        CircularFifoBuffer<E> b2 = (CircularFifoBuffer<E>) new ObjectInputStream(
             new ByteArrayInputStream(bos.toByteArray())).readObject();
-        
+
         assertEquals(1, b2.size());
         assertEquals(true, b2.contains("a"));
-        b2.add("b");
+        b2.add((E) "b");
         assertEquals(2, b2.size());
         assertEquals(true, b2.contains("a"));
         assertEquals(true, b2.contains("b"));
-        
+
         bos = new ByteArrayOutputStream();
         new ObjectOutputStream(bos).writeObject(b2);
-        
-        CircularFifoBuffer b3 = (CircularFifoBuffer) new ObjectInputStream(
+
+        CircularFifoBuffer<E> b3 = (CircularFifoBuffer<E>) new ObjectInputStream(
             new ByteArrayInputStream(bos.toByteArray())).readObject();
-        
+
         assertEquals(2, b3.size());
         assertEquals(true, b3.contains("a"));
         assertEquals(true, b3.contains("b"));
-        b3.add("c");
+        b3.add((E) "c");
         assertEquals(2, b3.size());
         assertEquals(true, b3.contains("b"));
         assertEquals(true, b3.contains("c"));
@@ -415,4 +426,19 @@ public class TestCircularFifoBuffer extends AbstractTestCollection {
 //        writeExternalFormToDisk((java.io.Serializable) collection, "D:/dev/collections/data/test/CircularFifoBuffer.fullCollection.version3.1.obj");
 //    }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public CircularFifoBuffer<E> getCollection() {
+        return (CircularFifoBuffer<E>) super.getCollection();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public List<E> getConfirmed() {
+        return (List<E>) super.getConfirmed();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestPredicatedBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestPredicatedBuffer.java b/src/test/org/apache/commons/collections/buffer/TestPredicatedBuffer.java
index 4f8c200..af5659d 100644
--- a/src/test/org/apache/commons/collections/buffer/TestPredicatedBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestPredicatedBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -28,79 +28,81 @@ import org.apache.commons.collections.Predicate;
 import org.apache.commons.collections.collection.TestPredicatedCollection;
 
 /**
- * Extension of {@link TestPredicatedCollection} for exercising the 
+ * Extension of {@link TestPredicatedCollection} for exercising the
  * {@link PredicatedBuffer} implementation.
  *
  * @since Commons Collections 3.0
  * @version $Revision$ $Date$
- * 
+ *
  * @author Phil Steitz
  */
-public class TestPredicatedBuffer extends TestPredicatedCollection {
-    
+public class TestPredicatedBuffer<E> extends TestPredicatedCollection<E> {
+
     public TestPredicatedBuffer(String testName) {
         super(testName);
     }
-    
+
     public static Test suite() {
         return new TestSuite(TestPredicatedBuffer.class);
     }
-    
+
     public static void main(String args[]) {
         String[] testCaseName = { TestPredicatedBuffer.class.getName()};
         junit.textui.TestRunner.main(testCaseName);
     }
-    
+
     //---------------------------------------------------------------
-    
-    protected Buffer decorateBuffer(Buffer buffer, Predicate predicate) {
+
+    protected Buffer<E> decorateCollection(Buffer<E> buffer, Predicate<E> predicate) {
         return PredicatedBuffer.decorate(buffer, predicate);
     }
-    
-    public Collection makeCollection() {
-        return decorateBuffer(new ArrayStack(), truePredicate);
+
+    public Buffer<E> makeObject() {
+        return decorateCollection(new ArrayStack<E>(), truePredicate);
     }
-    
-    public Collection makeConfirmedCollection() {
-        return new ArrayStack();
+
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayStack<E>();
     }
-    
-    public Collection makeConfirmedFullCollection() {
-        ArrayStack list = new ArrayStack();
+
+    public Collection<E> makeConfirmedFullCollection() {
+        ArrayStack<E> list = new ArrayStack<E>();
         list.addAll(java.util.Arrays.asList(getFullElements()));
         return list;
     }
-    
+
     //------------------------------------------------------------
-    
-    public Buffer makeTestBuffer() {
-        return decorateBuffer(new ArrayStack(), testPredicate);
+
+    public Buffer<E> makeTestBuffer() {
+        return decorateCollection(new ArrayStack<E>(), testPredicate);
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testGet() {
-        Buffer buffer = makeTestBuffer();
+        Buffer<E> buffer = makeTestBuffer();
         try {
-            Object o = buffer.get();
+            buffer.get();
             fail("Expecting BufferUnderflowException");
         } catch (BufferUnderflowException ex) {
             // expected
         }
-        buffer.add("one");
-        buffer.add("two");
-        buffer.add("three");
+        buffer.add((E) "one");
+        buffer.add((E) "two");
+        buffer.add((E) "three");
         assertEquals("Buffer get", buffer.get(), "three");
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testRemove() {
-        Buffer buffer = makeTestBuffer();
-        buffer.add("one");
+        Buffer<E> buffer = makeTestBuffer();
+        buffer.add((E) "one");
         assertEquals("Buffer get", buffer.remove(), "one");
         try {
             buffer.remove();
             fail("Expecting BufferUnderflowException");
         } catch (BufferUnderflowException ex) {
             // expected
-        }      
+        }
     }
 
     public String getCompatibilityVersion() {

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestPriorityBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestPriorityBuffer.java b/src/test/org/apache/commons/collections/buffer/TestPriorityBuffer.java
index 3e2aafb..cff46a8 100644
--- a/src/test/org/apache/commons/collections/buffer/TestPriorityBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestPriorityBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -36,13 +36,13 @@ import org.apache.commons.collections.comparators.ReverseComparator;
 
 /**
  * Tests the PriorityBuffer.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Michael A. Smith
  * @author Steve Phelps
  */
-public class TestPriorityBuffer extends AbstractTestCollection {
+public class TestPriorityBuffer<E> extends AbstractTestCollection<E> {
 
     public static void main(String[] args) {
         junit.textui.TestRunner.run(suite());
@@ -56,22 +56,23 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         super(testName);
     }
 
-    //-----------------------------------------------------------------------  
+    //-----------------------------------------------------------------------
+    @SuppressWarnings("unchecked")
     public void verify() {
         super.verify();
-        PriorityBuffer heap = (PriorityBuffer) collection;
+        PriorityBuffer<E> heap = getCollection();
 
-        Comparator c = heap.comparator;
+        Comparator<? super E> c = heap.comparator;
         if (c == null) {
-            c = ComparatorUtils.naturalComparator();
+            c = ComparatorUtils.NATURAL_COMPARATOR;
         }
         if (!heap.ascendingOrder) {
             c = ComparatorUtils.reversedComparator(c);
         }
 
-        Object[] tree = heap.elements;
+        E[] tree = heap.elements;
         for (int i = 1; i <= heap.size; i++) {
-            Object parent = tree[i];
+            E parent = tree[i];
             if (i * 2 <= heap.size) {
                 assertTrue("Parent is less than or equal to its left child", c.compare(parent, tree[i * 2]) <= 0);
             }
@@ -81,7 +82,7 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         }
     }
 
-    //-----------------------------------------------------------------------  
+    //-----------------------------------------------------------------------
     /**
      * Overridden because BinaryBuffer isn't fail fast.
      * @return false
@@ -90,13 +91,13 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         return false;
     }
 
-    //-----------------------------------------------------------------------  
-    public Collection makeConfirmedCollection() {
-        return new ArrayList();
+    //-----------------------------------------------------------------------
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayList<E>();
     }
 
-    public Collection makeConfirmedFullCollection() {
-        ArrayList list = new ArrayList();
+    public Collection<E> makeConfirmedFullCollection() {
+        ArrayList<E> list = new ArrayList<E>();
         list.addAll(Arrays.asList(getFullElements()));
         return list;
     }
@@ -104,23 +105,25 @@ public class TestPriorityBuffer extends AbstractTestCollection {
     /**
      * Return a new, empty {@link Object} to used for testing.
      */
-    public Collection makeCollection() {
-        return new PriorityBuffer();
+    public Buffer<E> makeObject() {
+        return new PriorityBuffer<E>();
     }
 
-    //-----------------------------------------------------------------------  
-    public Object[] getFullElements() {
-        return getFullNonNullStringElements();
+    //-----------------------------------------------------------------------
+    @SuppressWarnings("unchecked")
+    public E[] getFullElements() {
+        return (E[]) getFullNonNullStringElements();
     }
 
-    public Object[] getOtherElements() {
-        return getOtherNonNullStringElements();
+    @SuppressWarnings("unchecked")
+    public E[] getOtherElements() {
+        return (E[]) getOtherNonNullStringElements();
     }
 
-    //-----------------------------------------------------------------------  
+    //-----------------------------------------------------------------------
     public void testBufferEmpty() {
         resetEmpty();
-        Buffer buffer = (Buffer) collection;
+        Buffer<E> buffer = getCollection();
 
         assertEquals(0, buffer.size());
         assertEquals(true, buffer.isEmpty());
@@ -134,24 +137,24 @@ public class TestPriorityBuffer extends AbstractTestCollection {
             fail();
         } catch (BufferUnderflowException ex) {}
     }
-    
+
+    @SuppressWarnings("unchecked")
     public void testBasicOps() {
-        PriorityBuffer heap = new PriorityBuffer();
-
-        heap.add("a");
-        heap.add("c");
-        heap.add("e");
-        heap.add("b");
-        heap.add("d");
-        heap.add("n");
-        heap.add("m");
-        heap.add("l");
-        heap.add("k");
-        heap.add("j");
-        heap.add("i");
-        heap.add("h");
-        heap.add("g");
-        heap.add("f");
+        PriorityBuffer<E> heap = new PriorityBuffer<E>();
+        heap.add((E) "a");
+        heap.add((E) "c");
+        heap.add((E) "e");
+        heap.add((E) "b");
+        heap.add((E) "d");
+        heap.add((E) "n");
+        heap.add((E) "m");
+        heap.add((E) "l");
+        heap.add((E) "k");
+        heap.add((E) "j");
+        heap.add((E) "i");
+        heap.add((E) "h");
+        heap.add((E) "g");
+        heap.add((E) "f");
 
         assertTrue("heap should not be empty after adds", !heap.isEmpty());
 
@@ -184,8 +187,9 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         } catch (BufferUnderflowException ex) {}
     }
 
+    @SuppressWarnings("unchecked")
     public void testBasicComparatorOps() {
-        PriorityBuffer heap = new PriorityBuffer(new ReverseComparator(new ComparableComparator()));
+        PriorityBuffer<E> heap = new PriorityBuffer<E>(new ReverseComparator<E>((Comparator<E>) ComparableComparator.INSTANCE));
 
         assertTrue("heap should be empty after create", heap.isEmpty());
 
@@ -199,20 +203,20 @@ public class TestPriorityBuffer extends AbstractTestCollection {
             fail("NoSuchElementException should be thrown if remove is called before any elements are added");
         } catch (BufferUnderflowException ex) {}
 
-        heap.add("a");
-        heap.add("c");
-        heap.add("e");
-        heap.add("b");
-        heap.add("d");
-        heap.add("n");
-        heap.add("m");
-        heap.add("l");
-        heap.add("k");
-        heap.add("j");
-        heap.add("i");
-        heap.add("h");
-        heap.add("g");
-        heap.add("f");
+        heap.add((E) "a");
+        heap.add((E) "c");
+        heap.add((E) "e");
+        heap.add((E) "b");
+        heap.add((E) "d");
+        heap.add((E) "n");
+        heap.add((E) "m");
+        heap.add((E) "l");
+        heap.add((E) "k");
+        heap.add((E) "j");
+        heap.add((E) "i");
+        heap.add((E) "h");
+        heap.add((E) "g");
+        heap.add((E) "f");
 
         assertTrue("heap should not be empty after adds", !heap.isEmpty());
 
@@ -250,28 +254,28 @@ public class TestPriorityBuffer extends AbstractTestCollection {
     }
 
     /**
-     * Illustrates bad internal heap state reported in Bugzilla PR #235818. 
-     */  
+     * Illustrates bad internal heap state reported in Bugzilla PR #235818.
+     */
+    @SuppressWarnings("unchecked")
     public void testAddRemove() {
         resetEmpty();
-        PriorityBuffer heap = (PriorityBuffer) collection;
-        heap.add(new Integer(0));
-        heap.add(new Integer(2));
-        heap.add(new Integer(4));
-        heap.add(new Integer(3));
-        heap.add(new Integer(8));
-        heap.add(new Integer(10));
-        heap.add(new Integer(12));
-        heap.add(new Integer(3));
-        confirmed.addAll(heap);
+        PriorityBuffer heap = getCollection();
+        heap.add(0);
+        heap.add(2);
+        heap.add(4);
+        heap.add(3);
+        heap.add(8);
+        heap.add(10);
+        heap.add(12);
+        heap.add(3);
+        getConfirmed().addAll(heap);
         // System.out.println(heap);
-        Object obj = new Integer(10);
-        heap.remove(obj);
-        confirmed.remove(obj);
+        heap.remove(10);
+        getConfirmed().remove(10);
         // System.out.println(heap);
         verify();
     }
-    
+
     /**
      * Generate heaps staring with Integers from 0 - heapSize - 1.
      * Then perform random add / remove operations, checking
@@ -285,29 +289,29 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         int heapSize = 100;
         int operations = 20;
         Random randGenerator = new Random();
-        PriorityBuffer h = null;
-        for(int i=0; i < iterations; i++) {
-            if (i < iterations / 2) {          
-                h = new PriorityBuffer(true);
+        PriorityBuffer<Integer> h = null;
+        for (int i = 0; i < iterations; i++) {
+            if (i < iterations / 2) {
+                h = new PriorityBuffer<Integer>(true);
             } else {
-                h = new PriorityBuffer(false);
+                h = new PriorityBuffer<Integer>(false);
             }
-            for(int r = 0; r < heapSize; r++) {
-                h.add( new Integer( randGenerator.nextInt(heapSize)) );
+            for (int r = 0; r < heapSize; r++) {
+                h.add(randGenerator.nextInt(heapSize));
             }
-            for( int r = 0; r < operations; r++ ) {
+            for (int r = 0; r < operations; r++) {
                 h.remove(new Integer(r));
-                h.add(new Integer(randGenerator.nextInt(heapSize)));
+                h.add(randGenerator.nextInt(heapSize));
             }
             checkOrder(h);
         }
     }
-     
+
     /**
      * Pops all elements from the heap and verifies that the elements come off
      * in the correct order.  NOTE: this method empties the heap.
      */
-    protected void checkOrder(PriorityBuffer h) {
+    protected void checkOrder(PriorityBuffer<?> h) {
         Integer lastNum = null;
         Integer num = null;
         while (!h.isEmpty()) {
@@ -321,17 +325,17 @@ public class TestPriorityBuffer extends AbstractTestCollection {
             num = null;
         }
     }
-    
+
     /**
      * Returns a string showing the contents of the heap formatted as a tree.
-     * Makes no attempt at padding levels or handling wrapping. 
+     * Makes no attempt at padding levels or handling wrapping.
      */
-    protected String showTree(PriorityBuffer h) {
+    protected String showTree(PriorityBuffer<?> h) {
         int count = 1;
         StringBuffer buffer = new StringBuffer();
         for (int offset = 1; count < h.size() + 1; offset *= 2) {
             for (int i = offset; i < offset * 2; i++) {
-                if (i < h.elements.length && h.elements[i] != null) 
+                if (i < h.elements.length && h.elements[i] != null)
                     buffer.append(h.elements[i] + " ");
                 count++;
             }
@@ -344,15 +348,16 @@ public class TestPriorityBuffer extends AbstractTestCollection {
      * Generates 500 randomly initialized heaps of size 100
      * and tests that after serializing and restoring them to a byte array
      * that the following conditions hold:
-     * 
-     *  - the size of the restored heap is the same 
+     *
+     *  - the size of the restored heap is the same
      *      as the size of the orignal heap
-     *  
+     *
      *  - all elements in the original heap are present in the restored heap
-     *  
-     *  - the heap order of the restored heap is intact as 
+     *
+     *  - the heap order of the restored heap is intact as
      *      verified by checkOrder()
      */
+    @SuppressWarnings("unchecked")
     public void testSerialization() {
         int iterations = 500;
         int heapSize = 100;
@@ -360,17 +365,17 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         Random randGenerator = new Random();
         for (int i = 0; i < iterations; i++) {
             if (i < iterations / 2) {
-                h = new PriorityBuffer(true);
+                h = new PriorityBuffer<E>(true);
             } else {
-                h = new PriorityBuffer(false);
+                h = new PriorityBuffer<E>(false);
             }
             for (int r = 0; r < heapSize; r++) {
                 h.add(new Integer(randGenerator.nextInt(heapSize)));
             }
             assertTrue(h.size() == heapSize);
-            PriorityBuffer h1 = serializeAndRestore(h);
+            PriorityBuffer<?> h1 = serializeAndRestore(h);
             assertTrue(h1.size() == heapSize);
-            Iterator hit = h.iterator();
+            Iterator<?> hit = h.iterator();
             while (hit.hasNext()) {
                 Integer n = (Integer) hit.next();
                 assertTrue(h1.contains(n));
@@ -379,11 +384,11 @@ public class TestPriorityBuffer extends AbstractTestCollection {
         }
     }
 
-    public PriorityBuffer serializeAndRestore(PriorityBuffer h) {
-        PriorityBuffer h1 = null;
+    public PriorityBuffer<?> serializeAndRestore(PriorityBuffer<E> h) {
+        PriorityBuffer<?> h1 = null;
         try {
             byte[] objekt = writeExternalFormToBytes(h);
-            h1 = (PriorityBuffer) readExternalFormFromBytes(objekt);
+            h1 = (PriorityBuffer<?>) readExternalFormFromBytes(objekt);
         } catch (IOException e) {
             e.printStackTrace();
             fail(e.toString());
@@ -405,4 +410,11 @@ public class TestPriorityBuffer extends AbstractTestCollection {
 //        writeExternalFormToDisk((java.io.Serializable) collection, "C:/commons/collections/data/test/PriorityBuffer.fullCollection.version3.2.obj");
 //    }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public PriorityBuffer<E> getCollection() {
+        return (PriorityBuffer<E>) super.getCollection();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestSynchronizedBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestSynchronizedBuffer.java b/src/test/org/apache/commons/collections/buffer/TestSynchronizedBuffer.java
index 7bb47fd..305a788 100644
--- a/src/test/org/apache/commons/collections/buffer/TestSynchronizedBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestSynchronizedBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -27,48 +27,47 @@ import org.apache.commons.collections.Buffer;
 import org.apache.commons.collections.collection.AbstractTestCollection;
 
 /**
- * Extension of {@link AbstractTestCollection} for exercising the 
+ * Extension of {@link AbstractTestCollection} for exercising the
  * {@link SynchronizedBuffer} implementation.
  *
  * @since Commons Collections 3.1
  * @version $Revision$ $Date$
- * 
+ *
  * @author Phil Steitz
  * @author Stephen Colebourne
  */
-public class TestSynchronizedBuffer extends AbstractTestCollection {
-    
+public class TestSynchronizedBuffer<E> extends AbstractTestCollection<E> {
+
     public TestSynchronizedBuffer(String testName) {
         super(testName);
     }
-    
+
     public static Test suite() {
         return new TestSuite(TestSynchronizedBuffer.class);
     }
-    
+
     public static void main(String args[]) {
         String[] testCaseName = { TestSynchronizedBuffer.class.getName()};
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    //-----------------------------------------------------------------------    
-    public Collection makeCollection() {
-        return SynchronizedBuffer.decorate(new UnboundedFifoBuffer());
+    //-----------------------------------------------------------------------
+    public Buffer<E> makeObject() {
+        return SynchronizedBuffer.decorate(new UnboundedFifoBuffer<E>());
     }
-    
-    public Collection makeFullCollection() {
-        Buffer buffer = new UnboundedFifoBuffer();
+
+    public Collection<E> makeFullCollection() {
+        Buffer<E> buffer = new UnboundedFifoBuffer<E>();
         buffer.addAll(Arrays.asList(getFullElements()));
         return SynchronizedBuffer.decorate(buffer);
     }
-    
-    public Collection makeConfirmedCollection() {
-        ArrayStack list = new ArrayStack();
-        return list;
+
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayStack<E>();
     }
 
-    public Collection makeConfirmedFullCollection() {
-        ArrayStack list = new ArrayStack();
+    public Collection<E> makeConfirmedFullCollection() {
+        ArrayStack<E> list = new ArrayStack<E>();
         list.addAll(Arrays.asList(getFullElements()));
         return list;
     }
@@ -76,7 +75,7 @@ public class TestSynchronizedBuffer extends AbstractTestCollection {
     public boolean isNullSupported() {
         return false;
     }
-    
+
     public String getCompatibilityVersion() {
         return "3.1";
     }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestTransformedBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestTransformedBuffer.java b/src/test/org/apache/commons/collections/buffer/TestTransformedBuffer.java
index 910622e..d1498a1 100644
--- a/src/test/org/apache/commons/collections/buffer/TestTransformedBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestTransformedBuffer.java
@@ -49,9 +49,9 @@ public class TestTransformedBuffer extends TestCase {
     }
 
     public void testTransformedBuffer() {
-        Buffer buffer = TransformedBuffer.decorate(new ArrayStack(), TestTransformedCollection.STRING_TO_INTEGER_TRANSFORMER);
+        Buffer<Object> buffer = TransformedBuffer.decorate(new ArrayStack<Object>(), TestTransformedCollection.STRING_TO_INTEGER_TRANSFORMER);
         assertEquals(0, buffer.size());
-        Object[] els = new Object[] {"1", "3", "5", "7", "2", "4", "6"};
+        Object[] els = new Object[] { "1", "3", "5", "7", "2", "4", "6" };
         for (int i = 0; i < els.length; i++) {
             buffer.add(els[i]);
             assertEquals(i + 1, buffer.size());

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestUnboundedFifoBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestUnboundedFifoBuffer.java b/src/test/org/apache/commons/collections/buffer/TestUnboundedFifoBuffer.java
index 69978f0..a45248d 100644
--- a/src/test/org/apache/commons/collections/buffer/TestUnboundedFifoBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestUnboundedFifoBuffer.java
@@ -19,6 +19,7 @@ package org.apache.commons.collections.buffer;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 
 import junit.framework.Test;
 
@@ -32,7 +33,7 @@ import org.apache.commons.collections.collection.AbstractTestCollection;
  * 
  * @author Unknown
  */
-public class TestUnboundedFifoBuffer extends AbstractTestCollection {
+public class TestUnboundedFifoBuffer<E> extends AbstractTestCollection<E> {
 
     public TestUnboundedFifoBuffer(String n) {
         super(n);
@@ -49,8 +50,8 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      */
     public void verify() {
         super.verify();
-        Iterator iterator1 = collection.iterator();
-        Iterator iterator2 = confirmed.iterator();
+        Iterator<E> iterator1 = getCollection().iterator();
+        Iterator<E> iterator2 = getConfirmed().iterator();
         while (iterator2.hasNext()) {
             assertTrue(iterator1.hasNext());
             Object o1 = iterator1.next();
@@ -82,8 +83,8 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      *
      *  @return an empty ArrayList
      */
-    public Collection makeConfirmedCollection() {
-        return new ArrayList();
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayList<E>();
     }
 
     /**
@@ -91,8 +92,8 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      *
      *  @return a full ArrayList
      */
-    public Collection makeConfirmedFullCollection() {
-        Collection c = makeConfirmedCollection();
+    public Collection<E> makeConfirmedFullCollection() {
+        Collection<E> c = makeConfirmedCollection();
         c.addAll(java.util.Arrays.asList(getFullElements()));
         return c;
     }
@@ -102,8 +103,8 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      *
      *  @return an empty UnboundedFifoBuffer
      */
-    public Collection makeCollection() {
-        return new UnboundedFifoBuffer(5);
+    public Collection<E> makeObject() {
+        return new UnboundedFifoBuffer<E>(5);
     }
 
     //-----------------------------------------------------------------------
@@ -112,10 +113,10 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      */
     public void testUnboundedFifoBufferRemove() {
         resetFull();
-        int size = confirmed.size();
+        int size = getConfirmed().size();
         for (int i = 0; i < size; i++) {
-            Object o1 = ((UnboundedFifoBuffer)collection).remove();
-            Object o2 = ((ArrayList)confirmed).remove(0);
+            E o1 = getCollection().remove();
+            E o2 = getConfirmed().remove(0);
             assertEquals("Removed objects should be equal", o1, o2);
             verify();
         }
@@ -126,7 +127,7 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException1() {
         try {
-            new UnboundedFifoBuffer(0);
+            new UnboundedFifoBuffer<E>(0);
         } catch (IllegalArgumentException ex) {
             return;
         }
@@ -138,7 +139,7 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
      */
     public void testConstructorException2() {
         try {
-            new UnboundedFifoBuffer(-20);
+            new UnboundedFifoBuffer<E>(-20);
         } catch (IllegalArgumentException ex) {
             return;
         }
@@ -146,43 +147,45 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
     }
 
     //-----------------------------------------------------------------------
+    @SuppressWarnings("unchecked")
     public void testInternalStateAdd() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(2);
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(2);
         assertEquals(3, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(0, test.tail);
-        test.add("A");
+        test.add((E) "A");
         assertEquals(3, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(1, test.tail);
-        test.add("B");
+        test.add((E) "B");
         assertEquals(3, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(2, test.tail);
-        test.add("C");  // forces buffer increase
+        test.add((E) "C");  // forces buffer increase
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
-        test.add("D");
+        test.add((E) "D");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(4, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateAddWithWrap() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
         assertEquals(4, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(0, test.tail);
-        test.add("A");
+        test.add((E) "A");
         assertEquals(4, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(1, test.tail);
-        test.add("B");
+        test.add((E) "B");
         assertEquals(4, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(2, test.tail);
-        test.add("C");
+        test.add((E) "C");
         assertEquals(4, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
@@ -194,21 +197,22 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(3, test.tail);
-        test.add("D");
+        test.add((E) "D");
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(0, test.tail);
-        test.add("E");
+        test.add((E) "E");
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(1, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateRemove1() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(4);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(4);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
@@ -218,17 +222,18 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(1, test.head);
         assertEquals(3, test.tail);
         
-        test.add("D");
+        test.add((E) "D");
         assertEquals(5, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(4, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateRemove2() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(4);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(4);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
@@ -238,41 +243,43 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(0, test.head);
         assertEquals(2, test.tail);
         
-        test.add("D");
+        test.add((E) "D");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemove1() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(4);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(4);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         it.next();
         it.remove();
         assertEquals(5, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(3, test.tail);
         
-        test.add("D");
+        test.add((E) "D");
         assertEquals(5, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(4, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemove2() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(4);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(4);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         it.next();
         it.next();
         it.remove();
@@ -280,24 +287,25 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(0, test.head);
         assertEquals(2, test.tail);
         
-        test.add("D");
+        test.add((E) "D");
         assertEquals(5, test.buffer.length);
         assertEquals(0, test.head);
         assertEquals(3, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithTailAtEnd1() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
-        test.add("D");
+        test.add((E) "D");
         assertEquals(4, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(0, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("B", it.next());
         it.remove();
         assertEquals(4, test.buffer.length);
@@ -305,18 +313,19 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(0, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithTailAtEnd2() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
-        test.add("D");
+        test.add((E) "D");
         assertEquals(4, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(0, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("B", it.next());
         assertEquals("C", it.next());
         it.remove();
@@ -325,18 +334,19 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(3, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithTailAtEnd3() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
-        test.add("D");
+        test.add((E) "D");
         assertEquals(4, test.buffer.length);
         assertEquals(1, test.head);
         assertEquals(0, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("B", it.next());
         assertEquals("C", it.next());
         assertEquals("D", it.next());
@@ -346,20 +356,21 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(3, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithWrap1() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
         test.remove("B");
-        test.add("D");
-        test.add("E");
+        test.add((E) "D");
+        test.add((E) "E");
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(1, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("C", it.next());
         it.remove();
         assertEquals(4, test.buffer.length);
@@ -367,20 +378,21 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(1, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithWrap2() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
         test.remove("B");
-        test.add("D");
-        test.add("E");
+        test.add((E) "D");
+        test.add((E) "E");
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(1, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("C", it.next());
         assertEquals("D", it.next());
         it.remove();
@@ -389,20 +401,21 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
         assertEquals(0, test.tail);
     }
 
+    @SuppressWarnings("unchecked")
     public void testInternalStateIteratorRemoveWithWrap3() {
-        UnboundedFifoBuffer test = new UnboundedFifoBuffer(3);
-        test.add("A");
-        test.add("B");
-        test.add("C");
+        UnboundedFifoBuffer<E> test = new UnboundedFifoBuffer<E>(3);
+        test.add((E) "A");
+        test.add((E) "B");
+        test.add((E) "C");
         test.remove("A");
         test.remove("B");
-        test.add("D");
-        test.add("E");
+        test.add((E) "D");
+        test.add((E) "E");
         assertEquals(4, test.buffer.length);
         assertEquals(2, test.head);
         assertEquals(1, test.tail);
         
-        Iterator it = test.iterator();
+        Iterator<E> it = test.iterator();
         assertEquals("C", it.next());
         assertEquals("D", it.next());
         assertEquals("E", it.next());
@@ -424,4 +437,19 @@ public class TestUnboundedFifoBuffer extends AbstractTestCollection {
 //        writeExternalFormToDisk((java.io.Serializable) collection, "D:/dev/collections/data/test/UnboundedFifoBuffer.fullCollection.version3.1.obj");
 //    }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public UnboundedFifoBuffer<E> getCollection() {
+        return (UnboundedFifoBuffer<E>) super.getCollection();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public List<E> getConfirmed() {
+        return (List<E>) super.getConfirmed();
+    }
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestUnmodifiableBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestUnmodifiableBuffer.java b/src/test/org/apache/commons/collections/buffer/TestUnmodifiableBuffer.java
index 94b21f9..538dc8a 100644
--- a/src/test/org/apache/commons/collections/buffer/TestUnmodifiableBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestUnmodifiableBuffer.java
@@ -5,9 +5,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -27,48 +27,47 @@ import org.apache.commons.collections.Buffer;
 import org.apache.commons.collections.collection.AbstractTestCollection;
 
 /**
- * Extension of {@link AbstractTestCollection} for exercising the 
+ * Extension of {@link AbstractTestCollection} for exercising the
  * {@link UnmodifiableBuffer} implementation.
  *
  * @since Commons Collections 3.1
  * @version $Revision$ $Date$
- * 
+ *
  * @author Phil Steitz
  * @author Stephen Colebourne
  */
-public class TestUnmodifiableBuffer extends AbstractTestCollection {
-    
+public class TestUnmodifiableBuffer<E> extends AbstractTestCollection<E> {
+
     public TestUnmodifiableBuffer(String testName) {
         super(testName);
     }
-    
+
     public static Test suite() {
         return new TestSuite(TestUnmodifiableBuffer.class);
     }
-    
+
     public static void main(String args[]) {
         String[] testCaseName = { TestUnmodifiableBuffer.class.getName()};
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    //-----------------------------------------------------------------------    
-    public Collection makeCollection() {
-        return UnmodifiableBuffer.decorate(new UnboundedFifoBuffer());
+    //-----------------------------------------------------------------------
+    public Collection<E> makeObject() {
+        return UnmodifiableBuffer.decorate(new UnboundedFifoBuffer<E>());
     }
-    
-    public Collection makeFullCollection() {
-        Buffer buffer = new UnboundedFifoBuffer();
+
+    public Collection<E> makeFullCollection() {
+        Buffer<E> buffer = new UnboundedFifoBuffer<E>();
         buffer.addAll(Arrays.asList(getFullElements()));
         return UnmodifiableBuffer.decorate(buffer);
     }
-    
-    public Collection makeConfirmedCollection() {
-        ArrayStack list = new ArrayStack();
-        return list;
+
+    public Collection<E> makeConfirmedCollection() {
+        return new ArrayStack<E>();
     }
 
-    public Collection makeConfirmedFullCollection() {
-        ArrayStack list = new ArrayStack();
+    public Collection<E> makeConfirmedFullCollection() {
+        ArrayStack<E> list = new ArrayStack<E>();
         list.addAll(Arrays.asList(getFullElements()));
         return list;
     }
@@ -76,20 +75,19 @@ public class TestUnmodifiableBuffer extends AbstractTestCollection {
     public boolean isAddSupported() {
         return false;
     }
-    
+
     public boolean isRemoveSupported() {
         return false;
     }
-    
+
     public boolean isNullSupported() {
         return false;
     }
-    
+
     public void testBufferRemove() {
         resetEmpty();
-        Buffer buffer = (Buffer) collection;
         try {
-            buffer.remove();
+            getCollection().remove();
             fail();
         } catch (UnsupportedOperationException ex) {}
     }
@@ -105,4 +103,11 @@ public class TestUnmodifiableBuffer extends AbstractTestCollection {
 //        writeExternalFormToDisk((java.io.Serializable) collection, "D:/dev/collections/data/test/UnmodifiableBuffer.fullCollection.version3.1.obj");
 //    }
 
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Buffer<E> getCollection() {
+        return (Buffer<E>) super.getCollection();
+    }
 }


Mime
View raw message