commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject [14/77] [abbrv] commons-collections git commit: finish generics (minus one class)
Date Tue, 11 Jul 2017 17:54:59 GMT
http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/AbstractTestSortedBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/AbstractTestSortedBidiMap.java b/src/test/org/apache/commons/collections/bidimap/AbstractTestSortedBidiMap.java
index 1ec5c34..8d1a857 100644
--- a/src/test/org/apache/commons/collections/bidimap/AbstractTestSortedBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/AbstractTestSortedBidiMap.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.
@@ -34,74 +34,89 @@ import org.apache.commons.collections.map.AbstractTestSortedMap;
 
 /**
  * Abstract test class for {@link SortedBidiMap} methods and contracts.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Matthew Hawthorne
  * @author Stephen Colebourne
  */
-public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiMap {
+public abstract class AbstractTestSortedBidiMap<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestOrderedBidiMap<K, V> {
 
-    protected List sortedKeys = new ArrayList();
-    protected List sortedValues = new ArrayList();
-    protected SortedSet sortedNewValues = new TreeSet();
+    protected List<K> sortedKeys = new ArrayList<K>();
+    protected List<V> sortedValues = new ArrayList<V>();
+    protected SortedSet<V> sortedNewValues = new TreeSet<V>();
 
     public AbstractTestSortedBidiMap(String testName) {
         super(testName);
         sortedKeys.addAll(Arrays.asList(getSampleKeys()));
         Collections.sort(sortedKeys);
         sortedKeys = Collections.unmodifiableList(sortedKeys);
-        
-        Map map = new TreeMap();
-        for (int i = 0; i < getSampleKeys().length; i++) {
-            map.put(getSampleKeys()[i], getSampleValues()[i]);
-        }
-        sortedValues.addAll(map.values());
-        sortedValues = Collections.unmodifiableList(sortedValues);
-        
-        sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
-    }
 
-    public AbstractTestSortedBidiMap() {
-        super();
-        sortedKeys.addAll(Arrays.asList(getSampleValues()));
-        Collections.sort(sortedKeys);
-        sortedKeys = Collections.unmodifiableList(sortedKeys);
-        
-        Map map = new TreeMap();
-        for (int i = 0; i < getSampleKeys().length; i++) {
-            map.put(getSampleValues()[i], getSampleKeys()[i]);
-        }
+        Map<K, V> map = new TreeMap<K, V>();
+        addSampleMappings(map);
+
         sortedValues.addAll(map.values());
         sortedValues = Collections.unmodifiableList(sortedValues);
-        
+
         sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
     }
 
+//    public AbstractTestSortedBidiMap() {
+//        super();
+//        sortedKeys.addAll(Arrays.asList(getSampleValues()));
+//        Collections.sort(sortedKeys);
+//        sortedKeys = Collections.unmodifiableList(sortedKeys);
+//
+//        Map map = new TreeMap();
+//        for (int i = 0; i < getSampleKeys().length; i++) {
+//            map.put(getSampleValues()[i], getSampleKeys()[i]);
+//        }
+//        sortedValues.addAll(map.values());
+//        sortedValues = Collections.unmodifiableList(sortedValues);
+//
+//        sortedNewValues.addAll(Arrays.asList(getNewSampleValues()));
+//    }
+
     //-----------------------------------------------------------------------
     public boolean isAllowNullKey() {
         return false;
     }
+
     public boolean isAllowNullValue() {
         return false;
     }
-    public Map makeConfirmedMap() {
-        return new TreeMap();
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public abstract SortedBidiMap<K, V> makeObject();
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public SortedBidiMap<K, V> makeFullMap() {
+        return (SortedBidiMap<K, V>) super.makeFullMap();
+    }
+
+    public SortedMap<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>();
     }
 
     //-----------------------------------------------------------------------
     //-----------------------------------------------------------------------
     public void testBidiHeadMapContains() {
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object toKey = it.next();
-        Object second = it.next();
-        Object firstValue = sm.get(first);
-        Object secondValue = sm.get(second);
-        
-        SortedMap head = sm.headMap(toKey);
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K toKey = it.next();
+        K second = it.next();
+        V firstValue = sm.get(first);
+        V secondValue = sm.get(second);
+
+        SortedMap<K, V> head = sm.headMap(toKey);
         assertEquals(1, head.size());
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, head.containsKey(first));
@@ -112,44 +127,44 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(true, sm.containsValue(secondValue));
         assertEquals(false, head.containsValue(secondValue));
     }
-                
+
     //-----------------------------------------------------------------------
     public void testBidiClearByHeadMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
-        Object firstValue = sm.get(first);
-        Object secondValue = sm.get(second);
-        Object toKeyValue = sm.get(toKey);
-        
-        SortedMap sub = sm.headMap(toKey);
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
+        V firstValue = sm.get(first);
+        V secondValue = sm.get(second);
+        V toKeyValue = sm.get(toKey);
+
+        SortedMap<K, V> sub = sm.headMap(toKey);
         int size = sm.size();
         assertEquals(2, sub.size());
         sub.clear();
         assertEquals(0, sub.size());
         assertEquals(size - 2, sm.size());
         assertEquals(size - 2, sm.inverseBidiMap().size());
-        
+
         assertEquals(false, sm.containsKey(first));
         assertEquals(false, sm.containsValue(firstValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
+
         assertEquals(false, sm.containsKey(second));
         assertEquals(false, sm.containsValue(secondValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(second));
         assertEquals(false, sub.containsKey(second));
         assertEquals(false, sub.containsValue(secondValue));
-        
+
         assertEquals(true, sm.containsKey(toKey));
         assertEquals(true, sm.containsValue(toKeyValue));
         assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
@@ -161,23 +176,23 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiRemoveByHeadMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.headMap(toKey);
+        SortedMap<K, V> sub = sm.headMap(toKey);
         assertEquals(2, sub.size());
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
-        
-        Object firstValue = sub.remove(first);
+
+        V firstValue = sub.remove(first);
         assertEquals(1, sub.size());
         assertEquals(size - 1, sm.size());
         assertEquals(size - 1, sm.inverseBidiMap().size());
@@ -187,8 +202,8 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
-        Object secondValue = sub.remove(second);
+
+        V secondValue = sub.remove(second);
         assertEquals(0, sub.size());
         assertEquals(size - 2, sm.size());
         assertEquals(size - 2, sm.inverseBidiMap().size());
@@ -203,30 +218,30 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiRemoveByHeadMapEntrySet() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.headMap(toKey);
-        Set set = sub.entrySet();
+        SortedMap<K, V> sub = sm.headMap(toKey);
+        Set<Map.Entry<K, V>> set = sub.entrySet();
         assertEquals(2, sub.size());
         assertEquals(2, set.size());
-        
-        Iterator it2 = set.iterator();
-        Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
-        Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
+
+        Iterator<Map.Entry<K, V>> it2 = set.iterator();
+        Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
+        Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, set.contains(firstEntry));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
         assertEquals(true, set.contains(secondEntry));
-        
+
         set.remove(firstEntry);
         assertEquals(1, sub.size());
         assertEquals(size - 1, sm.size());
@@ -238,7 +253,7 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sub.containsKey(firstEntry.getKey()));
         assertEquals(false, sub.containsValue(firstEntry.getValue()));
         assertEquals(false, set.contains(firstEntry));
-        
+
         set.remove(secondEntry);
         assertEquals(0, sub.size());
         assertEquals(size - 2, sm.size());
@@ -256,16 +271,16 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiTailMapContains() {
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object fromKey = it.next();
-        Object second = it.next();
-        Object firstValue = sm.get(first);
-        Object fromKeyValue = sm.get(fromKey);
-        Object secondValue = sm.get(second);
-        
-        SortedMap sub = sm.tailMap(fromKey);
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K fromKey = it.next();
+        K second = it.next();
+        V firstValue = sm.get(first);
+        V fromKeyValue = sm.get(fromKey);
+        V secondValue = sm.get(second);
+
+        SortedMap<K, V> sub = sm.tailMap(fromKey);
         assertEquals(sm.size() - 1, sub.size());
         assertEquals(true, sm.containsKey(first));
         assertEquals(false, sub.containsKey(first));
@@ -284,42 +299,42 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiClearByTailMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
         it.next();
-        Object first = it.next();
-        Object fromKey = it.next();
-        Object second = it.next();
-        
-        Object firstValue = sm.get(first);
-        Object fromKeyValue = sm.get(fromKey);
-        Object secondValue = sm.get(second);
-        
-        SortedMap sub = sm.tailMap(fromKey);
+        K first = it.next();
+        K fromKey = it.next();
+        K second = it.next();
+
+        V firstValue = sm.get(first);
+        V fromKeyValue = sm.get(fromKey);
+        V secondValue = sm.get(second);
+
+        SortedMap<K, V> sub = sm.tailMap(fromKey);
         int size = sm.size();
         assertEquals(size - 3, sub.size());
         sub.clear();
         assertEquals(0, sub.size());
         assertEquals(3, sm.size());
         assertEquals(3, sm.inverseBidiMap().size());
-        
+
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sm.containsValue(firstValue));
         assertEquals(true, sm.inverseBidiMap().containsKey(firstValue));
         assertEquals(true, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
+
         assertEquals(false, sm.containsKey(fromKey));
         assertEquals(false, sm.containsValue(fromKeyValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
         assertEquals(false, sub.containsKey(fromKey));
         assertEquals(false, sub.containsValue(fromKeyValue));
-        
+
         assertEquals(false, sm.containsKey(second));
         assertEquals(false, sm.containsValue(secondValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
@@ -328,26 +343,26 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sub.containsValue(secondValue));
     }
 
-    //-----------------------------------------------------------------------                
+    //-----------------------------------------------------------------------
     public void testBidiRemoveByTailMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
         it.next();
-        Object fromKey = it.next();
-        Object first = it.next();
-        Object second = it.next();
-        
+        K fromKey = it.next();
+        K first = it.next();
+        K second = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.tailMap(fromKey);
+        SortedMap<K, V> sub = sm.tailMap(fromKey);
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
-        
+
         Object firstValue = sub.remove(first);
         assertEquals(size - 3, sub.size());
         assertEquals(size - 1, sm.size());
@@ -358,7 +373,7 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
+
         Object secondValue = sub.remove(second);
         assertEquals(size - 4, sub.size());
         assertEquals(size - 2, sm.size());
@@ -374,30 +389,30 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiRemoveByTailMapEntrySet() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
         it.next();
-        Object fromKey = it.next();
-        Object first = it.next();
-        Object second = it.next();
-        
+        K fromKey = it.next();
+        K first = it.next();
+        K second = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.tailMap(fromKey);
-        Set set = sub.entrySet();
-        Iterator it2 = set.iterator();
-        Object fromEntry = it2.next();
-        Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
-        Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
+        SortedMap<K, V> sub = sm.tailMap(fromKey);
+        Set<Map.Entry<K, V>> set = sub.entrySet();
+        Iterator<Map.Entry<K, V>> it2 = set.iterator();
+        it2.next();
+        Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
+        Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, set.contains(firstEntry));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
         assertEquals(true, set.contains(secondEntry));
-        
+
         set.remove(firstEntry);
         assertEquals(size - 3, sub.size());
         assertEquals(size - 1, sm.size());
@@ -409,7 +424,7 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sub.containsKey(firstEntry.getKey()));
         assertEquals(false, sub.containsValue(firstEntry.getValue()));
         assertEquals(false, set.contains(firstEntry));
-        
+
         set.remove(secondEntry);
         assertEquals(size - 4, sub.size());
         assertEquals(size - 2, sm.size());
@@ -427,19 +442,19 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiSubMapContains() {
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
-        Object first = it.next();
-        Object fromKey = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        Object third = it.next();
-        Object firstValue = sm.get(first);
-        Object fromKeyValue = sm.get(fromKey);
-        Object secondValue = sm.get(second);
-        Object thirdValue = sm.get(third);
-        
-        SortedMap sub = sm.subMap(fromKey, toKey);
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
+        K first = it.next();
+        K fromKey = it.next();
+        K second = it.next();
+        K toKey = it.next();
+        K third = it.next();
+        V firstValue = sm.get(first);
+        V fromKeyValue = sm.get(fromKey);
+        V secondValue = sm.get(second);
+        V thirdValue = sm.get(third);
+
+        SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
         assertEquals(2, sub.size());
         assertEquals(true, sm.containsKey(first));
         assertEquals(false, sub.containsKey(first));
@@ -462,50 +477,50 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiClearBySubMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
-        Object fromKey = it.next();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
-        Object fromKeyValue = sm.get(fromKey);
-        Object firstValue = sm.get(first);
-        Object secondValue = sm.get(second);
-        Object toKeyValue = sm.get(toKey);
-        
-        SortedMap sub = sm.subMap(fromKey, toKey);
+        K fromKey = it.next();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
+        V fromKeyValue = sm.get(fromKey);
+        V firstValue = sm.get(first);
+        V secondValue = sm.get(second);
+        V toKeyValue = sm.get(toKey);
+
+        SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
         int size = sm.size();
         assertEquals(3, sub.size());
         sub.clear();
         assertEquals(0, sub.size());
         assertEquals(size - 3, sm.size());
         assertEquals(size - 3, sm.inverseBidiMap().size());
-        
+
         assertEquals(false, sm.containsKey(fromKey));
         assertEquals(false, sm.containsValue(fromKeyValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(fromKeyValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(fromKey));
         assertEquals(false, sub.containsKey(fromKey));
         assertEquals(false, sub.containsValue(fromKeyValue));
-        
+
         assertEquals(false, sm.containsKey(first));
         assertEquals(false, sm.containsValue(firstValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(firstValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
+
         assertEquals(false, sm.containsKey(second));
         assertEquals(false, sm.containsValue(secondValue));
         assertEquals(false, sm.inverseBidiMap().containsKey(secondValue));
         assertEquals(false, sm.inverseBidiMap().containsValue(second));
         assertEquals(false, sub.containsKey(second));
         assertEquals(false, sub.containsValue(secondValue));
-        
+
         assertEquals(true, sm.containsKey(toKey));
         assertEquals(true, sm.containsValue(toKeyValue));
         assertEquals(true, sm.inverseBidiMap().containsKey(toKeyValue));
@@ -517,25 +532,25 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiRemoveBySubMap() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
         it.next();
-        Object fromKey = it.next();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
+        K fromKey = it.next();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.subMap(fromKey, toKey);
+        SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
-        
-        Object firstValue = sub.remove(first);
+
+        V firstValue = sub.remove(first);
         assertEquals(2, sub.size());
         assertEquals(size - 1, sm.size());
         assertEquals(size - 1, sm.inverseBidiMap().size());
@@ -545,8 +560,8 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sm.inverseBidiMap().containsValue(first));
         assertEquals(false, sub.containsKey(first));
         assertEquals(false, sub.containsValue(firstValue));
-        
-        Object secondValue = sub.remove(second);
+
+        V secondValue = sub.remove(second);
         assertEquals(1, sub.size());
         assertEquals(size - 2, sm.size());
         assertEquals(size - 2, sm.inverseBidiMap().size());
@@ -561,32 +576,32 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
     //-----------------------------------------------------------------------
     public void testBidiRemoveBySubMapEntrySet() {
         if (isRemoveSupported() == false) return;
-        
+
         // extra test as other tests get complex
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
-        Iterator it = sm.keySet().iterator();
+        SortedBidiMap<K, V> sm = makeFullMap();
+        Iterator<K> it = sm.keySet().iterator();
         it.next();
         it.next();
-        Object fromKey = it.next();
-        Object first = it.next();
-        Object second = it.next();
-        Object toKey = it.next();
-        
+        K fromKey = it.next();
+        K first = it.next();
+        K second = it.next();
+        K toKey = it.next();
+
         int size = sm.size();
-        SortedMap sub = sm.subMap(fromKey, toKey);
-        Set set = sub.entrySet();
+        SortedMap<K, V> sub = sm.subMap(fromKey, toKey);
+        Set<Map.Entry<K, V>> set = sub.entrySet();
         assertEquals(3, set.size());
-        Iterator it2 = set.iterator();
-        Object fromEntry = it2.next();
-        Map.Entry firstEntry = cloneMapEntry((Map.Entry) it2.next());
-        Map.Entry secondEntry = cloneMapEntry((Map.Entry) it2.next());
+        Iterator<Map.Entry<K, V>> it2 = set.iterator();
+        it2.next();
+        Map.Entry<K, V> firstEntry = cloneMapEntry(it2.next());
+        Map.Entry<K, V> secondEntry = cloneMapEntry(it2.next());
         assertEquals(true, sm.containsKey(first));
         assertEquals(true, sub.containsKey(first));
         assertEquals(true, set.contains(firstEntry));
         assertEquals(true, sm.containsKey(second));
         assertEquals(true, sub.containsKey(second));
         assertEquals(true, set.contains(secondEntry));
-        
+
         set.remove(firstEntry);
         assertEquals(2, sub.size());
         assertEquals(size - 1, sm.size());
@@ -598,7 +613,7 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, sub.containsKey(firstEntry.getKey()));
         assertEquals(false, sub.containsValue(firstEntry.getValue()));
         assertEquals(false, set.contains(firstEntry));
-        
+
         set.remove(secondEntry);
         assertEquals(1, sub.size());
         assertEquals(size - 2, sm.size());
@@ -612,17 +627,17 @@ public abstract class AbstractTestSortedBidiMap extends AbstractTestOrderedBidiM
         assertEquals(false, set.contains(secondEntry));
     }
 
-    //-----------------------------------------------------------------------    
+    //-----------------------------------------------------------------------
     public BulkTest bulkTestHeadMap() {
-        return new AbstractTestSortedMap.TestHeadMap(this);
+        return new AbstractTestSortedMap.TestHeadMap<K, V>(this);
     }
 
     public BulkTest bulkTestTailMap() {
-        return new AbstractTestSortedMap.TestTailMap(this);
+        return new AbstractTestSortedMap.TestTailMap<K, V>(this);
     }
 
     public BulkTest bulkTestSubMap() {
-        return new AbstractTestSortedMap.TestSubMap(this);
+        return new AbstractTestSortedMap.TestSubMap<K, V>(this);
     }
 
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestAbstractOrderedBidiMapDecorator.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestAbstractOrderedBidiMapDecorator.java b/src/test/org/apache/commons/collections/bidimap/TestAbstractOrderedBidiMapDecorator.java
index b385bf8..3223033 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestAbstractOrderedBidiMapDecorator.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestAbstractOrderedBidiMapDecorator.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.
@@ -16,22 +16,21 @@
  */
 package org.apache.commons.collections.bidimap;
 
-import java.util.Map;
+import java.util.SortedMap;
 import java.util.TreeMap;
 
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
-import org.apache.commons.collections.BidiMap;
 import org.apache.commons.collections.OrderedBidiMap;
 
 /**
  * Test class for AbstractOrderedBidiMapDecorator.
- * 
+ *
  * @version $Revision$ $Date$
  */
-public class TestAbstractOrderedBidiMapDecorator
-        extends AbstractTestOrderedBidiMap {
+public class TestAbstractOrderedBidiMapDecorator<K, V>
+        extends AbstractTestOrderedBidiMap<K, V> {
 
     public TestAbstractOrderedBidiMapDecorator(String testName) {
         super(testName);
@@ -41,12 +40,16 @@ public class TestAbstractOrderedBidiMapDecorator
         return new TestSuite(TestAbstractOrderedBidiMapDecorator.class);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return new TestOrderedBidiMap();
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public OrderedBidiMap<K, V> makeObject() {
+        return new TestOrderedBidiMap<K, V>();
     }
 
-    public Map makeConfirmedMap() {
-        return new TreeMap();
+    public SortedMap<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>();
     }
 
     public boolean isAllowNullKey() {
@@ -64,21 +67,21 @@ public class TestAbstractOrderedBidiMapDecorator
     /**
      * Simple class to actually test.
      */
-    private static final class TestOrderedBidiMap extends AbstractOrderedBidiMapDecorator {
-            
-        private TestOrderedBidiMap inverse = null;
+    private static final class TestOrderedBidiMap<K, V> extends AbstractOrderedBidiMapDecorator<K, V> {
+
+        private TestOrderedBidiMap<V, K> inverse = null;
 
         public TestOrderedBidiMap() {
-            super(new DualTreeBidiMap());
+            super(new DualTreeBidiMap<K, V>());
         }
-        
-        public TestOrderedBidiMap(OrderedBidiMap map) {
+
+        public TestOrderedBidiMap(OrderedBidiMap<K, V> map) {
             super(map);
         }
-        
-        public BidiMap inverseBidiMap() {
+
+        public OrderedBidiMap<V, K> inverseBidiMap() {
             if (inverse == null) {
-                inverse = new TestOrderedBidiMap((OrderedBidiMap) getBidiMap().inverseBidiMap());
+                inverse = new TestOrderedBidiMap<V, K>(decorated().inverseBidiMap());
                 inverse.inverse = this;
             }
             return inverse;

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestDualHashBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestDualHashBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestDualHashBidiMap.java
index 1118356..af5c363 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestDualHashBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestDualHashBidiMap.java
@@ -19,7 +19,6 @@ package org.apache.commons.collections.bidimap;
 import junit.framework.Test;
 import junit.textui.TestRunner;
 
-import org.apache.commons.collections.BidiMap;
 import org.apache.commons.collections.BulkTest;
 
 /**
@@ -30,7 +29,7 @@ import org.apache.commons.collections.BulkTest;
  * @author Matthew Hawthorne
  * @author Stephen Colebourne
  */
-public class TestDualHashBidiMap extends AbstractTestBidiMap {
+public class TestDualHashBidiMap<K, V> extends AbstractTestBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
@@ -44,15 +43,19 @@ public class TestDualHashBidiMap extends AbstractTestBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return new DualHashBidiMap();
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public DualHashBidiMap<K, V> makeObject() {
+        return new DualHashBidiMap<K, V>();
     }
 
     /**
      * Override to prevent infinite recursion of tests.
      */
     public String[] ignoredTests() {
-        return new String[] {"TestDualHashBidiMap.bulkTestInverseMap.bulkTestInverseMap"};
+        return new String[] { "TestDualHashBidiMap.bulkTestInverseMap.bulkTestInverseMap" };
     }
     
 //    public void testCreate() throws Exception {

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap.java
index a9c34f5..470d6c0 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap.java
@@ -19,7 +19,6 @@ package org.apache.commons.collections.bidimap;
 import junit.framework.Test;
 import junit.textui.TestRunner;
 
-import org.apache.commons.collections.BidiMap;
 import org.apache.commons.collections.BulkTest;
 
 /**
@@ -30,7 +29,7 @@ import org.apache.commons.collections.BulkTest;
  * @author Matthew Hawthorne
  * @author Stephen Colebourne
  */
-public class TestDualTreeBidiMap extends AbstractTestSortedBidiMap {
+public class TestDualTreeBidiMap<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestSortedBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
@@ -44,8 +43,12 @@ public class TestDualTreeBidiMap extends AbstractTestSortedBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return new DualTreeBidiMap();
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public DualTreeBidiMap<K, V> makeObject() {
+        return new DualTreeBidiMap<K, V>();
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap2.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap2.java b/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap2.java
index fba5af8..74c7389 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap2.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestDualTreeBidiMap2.java
@@ -25,13 +25,11 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 import java.util.TreeMap;
 
 import junit.framework.Test;
 import junit.textui.TestRunner;
 
-import org.apache.commons.collections.BidiMap;
 import org.apache.commons.collections.BulkTest;
 import org.apache.commons.collections.SortedBidiMap;
 import org.apache.commons.collections.comparators.ComparableComparator;
@@ -46,7 +44,7 @@ import org.apache.commons.collections.comparators.ReverseComparator;
  * @author Stephen Colebourne
  * @author Jonas Van Poucke
  */
-public class TestDualTreeBidiMap2 extends AbstractTestSortedBidiMap {
+public class TestDualTreeBidiMap2<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestSortedBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
@@ -60,21 +58,24 @@ public class TestDualTreeBidiMap2 extends AbstractTestSortedBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return new DualTreeBidiMap(new ReverseComparator(ComparableComparator.getInstance()));
+    public DualTreeBidiMap<K, V> makeObject() {
+        return new DualTreeBidiMap<K, V>(
+                new ReverseComparator<K>(ComparableComparator.<K> getInstance()),
+                new ReverseComparator<V>(ComparableComparator.<V> getInstance()));
     }
 
-    public Map makeConfirmedMap() {
-        return new TreeMap(new ReverseComparator(ComparableComparator.getInstance()));
+    public TreeMap<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>(new ReverseComparator<K>(ComparableComparator.<K>getInstance()));
     }
 
     public void testComparator() {
         resetEmpty();
-        SortedBidiMap bidi = (SortedBidiMap) map;
+        SortedBidiMap<K, V> bidi = (SortedBidiMap<K, V>) map;
         assertNotNull(bidi.comparator());
         assertTrue(bidi.comparator() instanceof ReverseComparator);
     }
 
+    @SuppressWarnings("unchecked")
     public void testSerializeDeserializeCheckComparator() throws Exception {
         SortedBidiMap obj = (SortedBidiMap) makeObject();
         if (obj instanceof Serializable && isTestSerialization()) {
@@ -95,18 +96,18 @@ public class TestDualTreeBidiMap2 extends AbstractTestSortedBidiMap {
     }
 
     public void testSortOrder() throws Exception {
-        SortedBidiMap sm = (SortedBidiMap) makeFullMap();
+        SortedBidiMap<K, V> sm = makeFullMap();
 
         // Sort by the comparator used in the makeEmptyBidiMap() method
-        List newSortedKeys = Arrays.asList(getSampleKeys());
-        Collections.sort(newSortedKeys, new ReverseComparator(ComparableComparator.getInstance()));
+        List<K> newSortedKeys = Arrays.asList(getSampleKeys());
+        Collections.sort(newSortedKeys, new ReverseComparator<K>(ComparableComparator.<K>getInstance()));
         newSortedKeys = Collections.unmodifiableList(newSortedKeys);
 
-        Iterator mapIter = sm.keySet().iterator();
-        Iterator expectedIter = newSortedKeys.iterator();
+        Iterator<K> mapIter = sm.keySet().iterator();
+        Iterator<K> expectedIter = newSortedKeys.iterator();
         while (expectedIter.hasNext()) {
-            Object expectedKey = expectedIter.next();
-            Object mapKey = mapIter.next();
+            K expectedKey = expectedIter.next();
+            K mapKey = mapIter.next();
             assertNotNull("key in sorted list may not be null", expectedKey);
             assertNotNull("key in map may not be null", mapKey);
             assertEquals("key from sorted list and map must be equal", expectedKey, mapKey);

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestTreeBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestTreeBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestTreeBidiMap.java
index 42028c6..66def22 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestTreeBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestTreeBidiMap.java
@@ -16,7 +16,6 @@
  */
 package org.apache.commons.collections.bidimap;
 
-import java.util.Map;
 import java.util.TreeMap;
 
 import junit.framework.Test;
@@ -32,7 +31,7 @@ import org.apache.commons.collections.BulkTest;
  * 
  * @author Stephen Colebourne
  */
-public class TestTreeBidiMap extends AbstractTestOrderedBidiMap {
+public class TestTreeBidiMap<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestOrderedBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
@@ -46,12 +45,12 @@ public class TestTreeBidiMap extends AbstractTestOrderedBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return new TreeBidiMap();
+    public BidiMap<K, V> makeObject() {
+        return new TreeBidiMap<K, V>();
     }
     
-    public Map makeConfirmedMap() {
-        return new TreeMap();
+    public TreeMap<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>();
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableBidiMap.java
index e8da77c..8af3f17 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableBidiMap.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,17 +27,17 @@ import org.apache.commons.collections.BulkTest;
 
 /**
  * JUnit tests.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Stephen Colebourne
  */
-public class TestUnmodifiableBidiMap extends AbstractTestBidiMap {
+public class TestUnmodifiableBidiMap<K, V> extends AbstractTestBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
     }
-    
+
     public static Test suite() {
         return BulkTest.makeSuite(TestUnmodifiableBidiMap.class);
     }
@@ -46,24 +46,18 @@ public class TestUnmodifiableBidiMap extends AbstractTestBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return UnmodifiableBidiMap.decorate(new DualHashBidiMap());
-    }
-    public BidiMap makeFullBidiMap() {
-        BidiMap bidi = new DualHashBidiMap();
-        for (int i = 0; i < entries.length; i++) {
-            bidi.put(entries[i][0], entries[i][1]);
-        }
-        return UnmodifiableBidiMap.decorate(bidi);
+    public BidiMap<K, V> makeObject() {
+        return UnmodifiableBidiMap.decorate(new DualHashBidiMap<K, V>());
     }
-    public Map makeFullMap() {
-        BidiMap bidi = new DualHashBidiMap();
+
+    public BidiMap<K, V> makeFullMap() {
+        BidiMap<K, V> bidi = new DualHashBidiMap<K, V>();
         addSampleMappings(bidi);
         return UnmodifiableBidiMap.decorate(bidi);
     }
-    
-    public Map makeConfirmedMap() {
-        return new HashMap();
+
+    public Map<K, V> makeConfirmedMap() {
+        return new HashMap<K, V>();
     }
 
     /**
@@ -76,11 +70,13 @@ public class TestUnmodifiableBidiMap extends AbstractTestBidiMap {
     public boolean isPutAddSupported() {
         return false;
     }
+
     public boolean isPutChangeSupported() {
         return false;
     }
+
     public boolean isRemoveSupported() {
         return false;
     }
-    
+
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableOrderedBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableOrderedBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableOrderedBidiMap.java
index 1a84417..6c732e7 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableOrderedBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableOrderedBidiMap.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,17 +28,17 @@ import org.apache.commons.collections.OrderedBidiMap;
 
 /**
  * JUnit tests.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Stephen Colebourne
  */
-public class TestUnmodifiableOrderedBidiMap extends AbstractTestOrderedBidiMap {
+public class TestUnmodifiableOrderedBidiMap<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestOrderedBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
     }
-    
+
     public static Test suite() {
         return BulkTest.makeSuite(TestUnmodifiableOrderedBidiMap.class);
     }
@@ -47,24 +47,18 @@ public class TestUnmodifiableOrderedBidiMap extends AbstractTestOrderedBidiMap {
         super(testName);
     }
 
-    public BidiMap makeEmptyBidiMap() {
-        return UnmodifiableOrderedBidiMap.decorate(new TreeBidiMap());
-    }
-    public BidiMap makeFullBidiMap() {
-        OrderedBidiMap bidi = new TreeBidiMap();
-        for (int i = 0; i < entries.length; i++) {
-            bidi.put(entries[i][0], entries[i][1]);
-        }
-        return UnmodifiableOrderedBidiMap.decorate(bidi);
+    public OrderedBidiMap<K, V> makeObject() {
+        return UnmodifiableOrderedBidiMap.decorate(new TreeBidiMap<K, V>());
     }
-    public Map makeFullMap() {
-        OrderedBidiMap bidi = new TreeBidiMap();
+
+    public BidiMap<K, V> makeFullMap() {
+        OrderedBidiMap<K, V> bidi = new TreeBidiMap<K, V>();
         addSampleMappings(bidi);
         return UnmodifiableOrderedBidiMap.decorate(bidi);
     }
-    
-    public Map makeConfirmedMap() {
-        return new TreeMap();
+
+    public Map<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>();
     }
 
     /**
@@ -73,21 +67,25 @@ public class TestUnmodifiableOrderedBidiMap extends AbstractTestOrderedBidiMap {
     public String[] ignoredTests() {
         return new String[] {"TestUnmodifiableOrderedBidiMap.bulkTestInverseMap.bulkTestInverseMap"};
     }
-    
+
     public boolean isAllowNullKey() {
         return false;
     }
+
     public boolean isAllowNullValue() {
         return false;
     }
+
     public boolean isPutAddSupported() {
         return false;
     }
+
     public boolean isPutChangeSupported() {
         return false;
     }
+
     public boolean isRemoveSupported() {
         return false;
     }
-    
+
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableSortedBidiMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableSortedBidiMap.java b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableSortedBidiMap.java
index b4ae163..7b4597c 100644
--- a/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableSortedBidiMap.java
+++ b/src/test/org/apache/commons/collections/bidimap/TestUnmodifiableSortedBidiMap.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.
@@ -16,29 +16,28 @@
  */
 package org.apache.commons.collections.bidimap;
 
-import java.util.Map;
+import java.util.SortedMap;
 import java.util.TreeMap;
 
 import junit.framework.Test;
 import junit.textui.TestRunner;
 
-import org.apache.commons.collections.BidiMap;
 import org.apache.commons.collections.BulkTest;
 import org.apache.commons.collections.SortedBidiMap;
 
 /**
  * JUnit tests.
- * 
+ *
  * @version $Revision$ $Date$
- * 
+ *
  * @author Stephen Colebourne
  */
-public class TestUnmodifiableSortedBidiMap extends AbstractTestSortedBidiMap {
+public class TestUnmodifiableSortedBidiMap<K extends Comparable<K>, V extends Comparable<V>> extends AbstractTestSortedBidiMap<K, V> {
 
     public static void main(String[] args) {
         TestRunner.run(suite());
     }
-    
+
     public static Test suite() {
         return BulkTest.makeSuite(TestUnmodifiableSortedBidiMap.class);
     }
@@ -48,30 +47,25 @@ public class TestUnmodifiableSortedBidiMap extends AbstractTestSortedBidiMap {
     }
 
     //-----------------------------------------------------------------------
-    public BidiMap makeEmptyBidiMap() {
-        return UnmodifiableSortedBidiMap.decorate(new DualTreeBidiMap());
-    }
-    public BidiMap makeFullBidiMap() {
-        SortedBidiMap bidi = new DualTreeBidiMap();
-        for (int i = 0; i < entries.length; i++) {
-            bidi.put(entries[i][0], entries[i][1]);
-        }
-        return UnmodifiableSortedBidiMap.decorate(bidi);
+    public SortedBidiMap<K, V> makeObject() {
+        return UnmodifiableSortedBidiMap.decorate(new DualTreeBidiMap<K, V>());
     }
-    public Map makeFullMap() {
-        SortedBidiMap bidi = new DualTreeBidiMap();
+
+    public SortedBidiMap<K, V> makeFullMap() {
+        SortedBidiMap<K, V> bidi = new DualTreeBidiMap<K, V>();
         addSampleMappings(bidi);
         return UnmodifiableSortedBidiMap.decorate(bidi);
     }
-    
-    public Map makeConfirmedMap() {
-        return new TreeMap();
+
+    public SortedMap<K, V> makeConfirmedMap() {
+        return new TreeMap<K, V>();
     }
 
     public boolean isSubMapViewsSerializable() {
         // TreeMap sub map views have a bug in deserialization.
         return false;
     }
+
     public String[] ignoredTests() {
         // Override to prevent infinite recursion of tests.
         return new String[] {"TestUnmodifiableSortedBidiMap.bulkTestInverseMap.bulkTestInverseMap"};
@@ -81,17 +75,21 @@ public class TestUnmodifiableSortedBidiMap extends AbstractTestSortedBidiMap {
     public boolean isAllowNullKey() {
         return false;
     }
+
     public boolean isAllowNullValue() {
         return false;
     }
+
     public boolean isPutAddSupported() {
         return false;
     }
+
     public boolean isPutChangeSupported() {
         return false;
     }
+
     public boolean isRemoveSupported() {
         return false;
     }
-    
+
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/884baf0d/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java b/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
index e5ea282..2860de5 100644
--- a/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
@@ -29,30 +29,31 @@ import java.util.LinkedList;
 import java.util.Set;
 
 /**
- * Extension of {@link AbstractTestObject} for exercising the {@link BlockingBuffer} implementation.
- *
+ * Extension of {@link AbstractTestObject} for exercising the
+ * {@link BlockingBuffer} implementation.
+ * 
  * @author Janek Bogucki
  * @author Phil Steitz
  * @version $Revision$
  * @since Commons Collections 3.0
  */
-public class TestBlockingBuffer extends AbstractTestObject {
+public class TestBlockingBuffer<E> extends AbstractTestObject {
 
-    public TestBlockingBuffer( String testName ) {
-        super( testName );
+    public TestBlockingBuffer(String testName) {
+        super(testName);
     }
 
     public static Test suite() {
-        return new TestSuite( TestBlockingBuffer.class );
+        return new TestSuite(TestBlockingBuffer.class);
     }
 
-    public static void main( String args[] ) {
-        String[] testCaseName = {TestBlockingBuffer.class.getName()};
-        junit.textui.TestRunner.main( testCaseName );
+    public static void main(String args[]) {
+        String[] testCaseName = { TestBlockingBuffer.class.getName() };
+        junit.textui.TestRunner.main(testCaseName);
     }
 
-    public Object makeObject() {
-        return BlockingBuffer.decorate( new MyBuffer() );
+    public Buffer<E> makeObject() {
+        return BlockingBuffer.decorate(new MyBuffer<E>());
     }
 
     public boolean isEqualsCheckable() {
@@ -61,113 +62,122 @@ public class TestBlockingBuffer extends AbstractTestObject {
 
     //-----------------------------------------------------------------------
 
+    @SuppressWarnings("unchecked")
+    protected E makeElement() {
+        return (E) new Object();
+    }
+    
     /**
-     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)}.
+     * Tests {@link BlockingBuffer#get()} in combination with
+     * {@link BlockingBuffer#add(Object)}.
      */
     public void testGetWithAdd() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
-        new DelayedAdd( blockingBuffer, obj ).start();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
+        new DelayedAdd<E>(blockingBuffer, obj).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.get() );
+        assertSame(obj, blockingBuffer.get());
     }
 
     public void testGetWithAddTimeout() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 );
-        Object obj = new Object();
-        new DelayedAdd( blockingBuffer, obj, 100 ).start();
+        Buffer<E> blockingBuffer = BlockingBuffer.decorate(new MyBuffer<E>(), 500);
+        E obj = makeElement();
+        new DelayedAdd<E>(blockingBuffer, obj, 100).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.get() );
+        assertSame(obj, blockingBuffer.get());
     }
 
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}.
+     * Tests {@link BlockingBuffer#get()} in combination with
+     * {@link BlockingBuffer#addAll(java.util.Collection)}.
      */
     public void testGetWithAddAll() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
-        new DelayedAddAll( blockingBuffer, obj ).start();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
+        new DelayedAddAll<E>(blockingBuffer, obj).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.get() );
+        assertSame(obj, blockingBuffer.get());
     }
 
     public void testGetWithAddAllTimeout() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 );
-        Object obj = new Object();
-        new DelayedAddAll( blockingBuffer, obj, 100 ).start();
+        Buffer<E> blockingBuffer = BlockingBuffer.decorate(new MyBuffer<E>(), 500);
+        E obj = makeElement();
+        new DelayedAddAll<E>(blockingBuffer, obj, 100).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.get() );
+        assertSame(obj, blockingBuffer.get());
     }
 
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)}.
+     * Tests {@link BlockingBuffer#remove()} in combination with
+     * {@link BlockingBuffer#add(Object)}.
      */
     public void testRemoveWithAdd() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
-        new DelayedAdd( blockingBuffer, obj ).start();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
+        new DelayedAdd<E>(blockingBuffer, obj).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.remove() );
+        assertSame(obj, blockingBuffer.remove());
     }
 
     public void testRemoveWithAddTimeout() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 );
-        Object obj = new Object();
-        new DelayedAdd( blockingBuffer, obj, 500 ).start();
+        Buffer<E> blockingBuffer = BlockingBuffer.decorate(new MyBuffer<E>(), 100);
+        E obj = makeElement();
+        new DelayedAdd<E>(blockingBuffer, obj, 500).start();
         try {
             blockingBuffer.remove();
-        }
-        catch( BufferUnderflowException e ) {
+        } catch (BufferUnderflowException e) {
         }
     }
+
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}.
+     * Tests {@link BlockingBuffer#remove()} in combination with
+     * {@link BlockingBuffer#addAll(java.util.Collection)}.
      */
     public void testRemoveWithAddAll() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
-        new DelayedAddAll( blockingBuffer, obj ).start();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
+        new DelayedAddAll<E>(blockingBuffer, obj).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame( obj, blockingBuffer.remove() );
+        assertSame(obj, blockingBuffer.remove());
     }
 
     public void testRemoveWithAddAllTimeout() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 );
-        Object obj = new Object();
-        new DelayedAddAll( blockingBuffer, obj, 500 ).start();
+        Buffer<E> blockingBuffer = BlockingBuffer.decorate(new MyBuffer<E>(), 100);
+        E obj = makeElement();
+        new DelayedAddAll<E>(blockingBuffer, obj, 500).start();
         try {
             blockingBuffer.remove();
-        }
-        catch( BufferUnderflowException e ) {
+        } catch (BufferUnderflowException e) {
         }
     }
+
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)} using multiple read
-     * threads.
-     * <p/>
-     * Two read threads should block on an empty buffer until one object is added then both threads should complete.
+     * Tests {@link BlockingBuffer#get()} in combination with
+     * {@link BlockingBuffer#add(Object)} using multiple read threads. <p/> Two
+     * read threads should block on an empty buffer until one object is added
+     * then both threads should complete.
      */
     public void testBlockedGetWithAdd() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // run methods will get and compare -- must wait for add
-        Thread thread1 = new ReadThread( blockingBuffer, obj );
-        Thread thread2 = new ReadThread( blockingBuffer, obj );
+        Thread thread1 = new ReadThread<E>(blockingBuffer, obj);
+        Thread thread2 = new ReadThread<E>(blockingBuffer, obj);
         thread1.start();
         thread2.start();
 
@@ -175,32 +185,32 @@ public class TestBlockingBuffer extends AbstractTestObject {
         delay();
 
         // notifyAll should allow both read threads to complete
-        blockingBuffer.add( obj );
+        blockingBuffer.add(obj);
 
         // allow notified threads to complete 
         delay();
 
         // There should not be any threads waiting.
-        if( thread1.isAlive() || thread2.isAlive() ) {
-            fail( "Live thread(s) when both should be dead." );
+        if (thread1.isAlive() || thread2.isAlive()) {
+            fail("Live thread(s) when both should be dead.");
         }
     }
 
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)} using
-     * multiple read threads.
-     * <p/>
-     * Two read threads should block on an empty buffer until a singleton is added then both threads should complete.
+     * Tests {@link BlockingBuffer#get()} in combination with
+     * {@link BlockingBuffer#addAll(java.util.Collection)} using multiple read
+     * threads. <p/> Two read threads should block on an empty buffer until a
+     * singleton is added then both threads should complete.
      */
     public void testBlockedGetWithAddAll() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // run methods will get and compare -- must wait for addAll
-        Thread thread1 = new ReadThread( blockingBuffer, obj );
-        Thread thread2 = new ReadThread( blockingBuffer, obj );
+        Thread thread1 = new ReadThread<E>(blockingBuffer, obj);
+        Thread thread2 = new ReadThread<E>(blockingBuffer, obj);
         thread1.start();
         thread2.start();
 
@@ -208,14 +218,14 @@ public class TestBlockingBuffer extends AbstractTestObject {
         delay();
 
         // notifyAll should allow both read threads to complete
-        blockingBuffer.addAll( Collections.singleton( obj ) );
+        blockingBuffer.addAll(Collections.singleton(obj));
 
         // allow notified threads to complete 
         delay();
 
         // There should not be any threads waiting.
-        if( thread1.isAlive() || thread2.isAlive() ) {
-            fail( "Live thread(s) when both should be dead." );
+        if (thread1.isAlive() || thread2.isAlive()) {
+            fail("Live thread(s) when both should be dead.");
         }
     }
 
@@ -225,12 +235,12 @@ public class TestBlockingBuffer extends AbstractTestObject {
      * Tests interrupted {@link BlockingBuffer#get()}.
      */
     public void testInterruptedGet() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // spawn a read thread to wait on the empty buffer
-        ArrayList exceptionList = new ArrayList();
-        Thread thread = new ReadThread( blockingBuffer, obj, exceptionList );
+        ArrayList<String> exceptionList = new ArrayList<String>();
+        Thread thread = new ReadThread<E>(blockingBuffer, obj, exceptionList);
         thread.start();
 
         // Interrupting the thread should cause it to throw BufferUnderflowException
@@ -238,10 +248,10 @@ public class TestBlockingBuffer extends AbstractTestObject {
 
         // Chill, so thread can throw and add message to exceptionList
         delay();
-        assertTrue( "Thread interrupt should have led to underflow",
-                    exceptionList.contains( "BufferUnderFlow" ) );
-        if( thread.isAlive() ) {
-            fail( "Read thread has hung." );
+        assertTrue("Thread interrupt should have led to underflow", exceptionList
+                .contains("BufferUnderFlow"));
+        if (thread.isAlive()) {
+            fail("Read thread has hung.");
         }
 
     }
@@ -249,115 +259,116 @@ public class TestBlockingBuffer extends AbstractTestObject {
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)} using multiple read
-     * threads.
-     * <p/>
-     * Two read threads should block on an empty buffer until one object is added then one thread should complete. The
-     * remaining thread should complete after the addition of a second object.
+     * Tests {@link BlockingBuffer#remove()} in combination with
+     * {@link BlockingBuffer#add(Object)} using multiple read threads. <p/> Two
+     * read threads should block on an empty buffer until one object is added
+     * then one thread should complete. The remaining thread should complete
+     * after the addition of a second object.
      */
     public void testBlockedRemoveWithAdd() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // run methods will remove and compare -- must wait for add
-        Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" );
-        Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" );
+        Thread thread1 = new ReadThread<E>(blockingBuffer, obj, null, "remove");
+        Thread thread2 = new ReadThread<E>(blockingBuffer, obj, null, "remove");
         thread1.start();
         thread2.start();
 
         // give hungry read threads ample time to hang
         delay();
-        blockingBuffer.add( obj );
+        blockingBuffer.add(obj);
 
         // allow notified threads to complete 
         delay();
 
         // There should be one thread waiting.
-        assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() );
-        blockingBuffer.add( obj );
+        assertTrue("There is one thread waiting", thread1.isAlive() ^ thread2.isAlive());
+        blockingBuffer.add(obj);
 
         // allow notified thread to complete 
         delay();
 
         // There should not be any threads waiting.
-        if( thread1.isAlive() || thread2.isAlive() ) {
-            fail( "Live thread(s) when both should be dead." );
+        if (thread1.isAlive() || thread2.isAlive()) {
+            fail("Live thread(s) when both should be dead.");
         }
     }
 
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}
-     * using multiple read threads.
-     * <p/>
-     * Two read threads should block on an empty buffer until a singleton collection is added then one thread should
-     * complete. The remaining thread should complete after the addition of a second singleton.
+     * Tests {@link BlockingBuffer#remove()} in combination with
+     * {@link BlockingBuffer#addAll(java.util.Collection)} using multiple read
+     * threads. <p/> Two read threads should block on an empty buffer until a
+     * singleton collection is added then one thread should complete. The
+     * remaining thread should complete after the addition of a second
+     * singleton.
      */
     public void testBlockedRemoveWithAddAll1() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // run methods will remove and compare -- must wait for addAll
-        Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" );
-        Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" );
+        Thread thread1 = new ReadThread<E>(blockingBuffer, obj, null, "remove");
+        Thread thread2 = new ReadThread<E>(blockingBuffer, obj, null, "remove");
         thread1.start();
         thread2.start();
 
         // give hungry read threads ample time to hang
         delay();
-        blockingBuffer.addAll( Collections.singleton( obj ) );
+        blockingBuffer.addAll(Collections.singleton(obj));
 
         // allow notified threads to complete 
         delay();
 
         // There should be one thread waiting.
-        assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() );
-        blockingBuffer.addAll( Collections.singleton( obj ) );
+        assertTrue("There is one thread waiting", thread1.isAlive() ^ thread2.isAlive());
+        blockingBuffer.addAll(Collections.singleton(obj));
 
         // allow notified thread to complete 
         delay();
 
         // There should not be any threads waiting.
-        if( thread1.isAlive() || thread2.isAlive() ) {
-            fail( "Live thread(s) when both should be dead." );
+        if (thread1.isAlive() || thread2.isAlive()) {
+            fail("Live thread(s) when both should be dead.");
         }
     }
 
     //-----------------------------------------------------------------------
 
     /**
-     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}
-     * using multiple read threads.
-     * <p/>
-     * Two read threads should block on an empty buffer until a collection with two distinct objects is added then both
-     * threads should complete. Each thread should have read a different object.
+     * Tests {@link BlockingBuffer#remove()} in combination with
+     * {@link BlockingBuffer#addAll(java.util.Collection)} using multiple read
+     * threads. <p/> Two read threads should block on an empty buffer until a
+     * collection with two distinct objects is added then both threads should
+     * complete. Each thread should have read a different object.
      */
     public void testBlockedRemoveWithAddAll2() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj1 = new Object();
-        Object obj2 = new Object();
-        Set objs = Collections.synchronizedSet( new HashSet() );
-        objs.add( obj1 );
-        objs.add( obj2 );
+        Buffer<E> blockingBuffer = makeObject();
+        E obj1 = makeElement();
+        E obj2 = makeElement();
+        Set<E> objs = Collections.synchronizedSet(new HashSet<E>());
+        objs.add(obj1);
+        objs.add(obj2);
 
         // run methods will remove and compare -- must wait for addAll
-        Thread thread1 = new ReadThread( blockingBuffer, objs, "remove" );
-        Thread thread2 = new ReadThread( blockingBuffer, objs, "remove" );
+        Thread thread1 = new ReadThread<E>(blockingBuffer, objs, "remove");
+        Thread thread2 = new ReadThread<E>(blockingBuffer, objs, "remove");
         thread1.start();
         thread2.start();
 
         // give hungry read threads ample time to hang
         delay();
-        blockingBuffer.addAll( objs );
+        blockingBuffer.addAll(objs);
 
         // allow notified threads to complete 
         delay();
-        assertEquals( "Both objects were removed", 0, objs.size() );
+        assertEquals("Both objects were removed", 0, objs.size());
 
         // There should not be any threads waiting.
-        if( thread1.isAlive() || thread2.isAlive() ) {
-            fail( "Live thread(s) when both should be dead." );
+        if (thread1.isAlive() || thread2.isAlive()) {
+            fail("Live thread(s) when both should be dead.");
         }
     }
 
@@ -367,12 +378,12 @@ public class TestBlockingBuffer extends AbstractTestObject {
      * Tests interrupted remove.
      */
     public void testInterruptedRemove() {
-        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
-        Object obj = new Object();
+        Buffer<E> blockingBuffer = makeObject();
+        E obj = makeElement();
 
         // spawn a read thread to wait on the empty buffer
-        ArrayList exceptionList = new ArrayList();
-        Thread thread = new ReadThread( blockingBuffer, obj, exceptionList, "remove" );
+        ArrayList<String> exceptionList = new ArrayList<String>();
+        Thread thread = new ReadThread<E>(blockingBuffer, obj, exceptionList, "remove");
         thread.start();
 
         // Interrupting the thread should cause it to throw BufferUnderflowException
@@ -380,49 +391,47 @@ public class TestBlockingBuffer extends AbstractTestObject {
 
         // Chill, so thread can throw and add message to exceptionList
         delay();
-        assertTrue( "Thread interrupt should have led to underflow",
-                    exceptionList.contains( "BufferUnderFlow" ) );
-        if( thread.isAlive() ) {
-            fail( "Read thread has hung." );
+        assertTrue("Thread interrupt should have led to underflow", exceptionList
+                .contains("BufferUnderFlow"));
+        if (thread.isAlive()) {
+            fail("Read thread has hung.");
         }
 
     }
 
     public void testTimeoutGet() {
-        final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() );
+        final BlockingBuffer<E> buffer = new BlockingBuffer<E>(new MyBuffer<E>());
         try {
-            buffer.get( 100 );
-            fail( "Get should have timed out." );
-        }
-        catch( BufferUnderflowException e ) {
+            buffer.get(100);
+            fail("Get should have timed out.");
+        } catch (BufferUnderflowException e) {
         }
     }
 
     public void testTimeoutRemove() {
-        final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() );
+        final BlockingBuffer<E> buffer = new BlockingBuffer<E>(new MyBuffer<E>());
         try {
-            buffer.remove( 100 );
-            fail( "Get should have timed out." );
-        }
-        catch( BufferUnderflowException e ) {
+            buffer.remove(100);
+            fail("Get should have timed out.");
+        } catch (BufferUnderflowException e) {
         }
     }
 
-    protected static class DelayedAdd extends Thread {
+    protected static class DelayedAdd<E> extends Thread {
 
-        Buffer buffer;
+        Buffer<E> buffer;
 
-        Object obj;
+        E obj;
 
         long delay = 1000;
 
-        public DelayedAdd( Buffer buffer, Object obj, long delay ) {
+        public DelayedAdd(Buffer<E> buffer, E obj, long delay) {
             this.buffer = buffer;
             this.obj = obj;
             this.delay = delay;
         }
 
-        DelayedAdd( Buffer buffer, Object obj ) {
+        DelayedAdd(Buffer<E> buffer, E obj) {
             super();
             this.buffer = buffer;
             this.obj = obj;
@@ -431,29 +440,28 @@ public class TestBlockingBuffer extends AbstractTestObject {
         public void run() {
             try {
                 // wait for other thread to block on get() or remove()
-                Thread.sleep( delay );
-            }
-            catch( InterruptedException e ) {
+                Thread.sleep(delay);
+            } catch (InterruptedException e) {
             }
-            buffer.add( obj );
+            buffer.add(obj);
         }
     }
 
-    protected static class DelayedAddAll extends Thread {
+    protected static class DelayedAddAll<E> extends Thread {
 
-        Buffer buffer;
+        Buffer<E> buffer;
 
-        Object obj;
+        E obj;
 
         long delay = 100;
 
-        public DelayedAddAll( Buffer buffer, Object obj, long delay ) {
+        public DelayedAddAll(Buffer<E> buffer, E obj, long delay) {
             this.buffer = buffer;
             this.obj = obj;
             this.delay = delay;
         }
 
-        DelayedAddAll( Buffer buffer, Object obj ) {
+        DelayedAddAll(Buffer<E> buffer, E obj) {
             super();
             this.buffer = buffer;
             this.obj = obj;
@@ -462,40 +470,39 @@ public class TestBlockingBuffer extends AbstractTestObject {
         public void run() {
             try {
                 // wait for other thread to block on get() or remove()
-                Thread.sleep( delay );
-            }
-            catch( InterruptedException e ) {
+                Thread.sleep(delay);
+            } catch (InterruptedException e) {
             }
-            buffer.addAll( Collections.singleton( obj ) );
+            buffer.addAll(Collections.singleton(obj));
         }
     }
 
-    protected static class ReadThread extends Thread {
+    protected static class ReadThread<E> extends Thread {
 
-        Buffer buffer;
+        Buffer<E> buffer;
 
         Object obj;
 
-        ArrayList exceptionList = null;
+        ArrayList<String> exceptionList = null;
 
         String action = "get";
 
-        Set objs;
+        Set<E> objs;
 
-        ReadThread( Buffer buffer, Object obj ) {
+        ReadThread(Buffer<E> buffer, Object obj) {
             super();
             this.buffer = buffer;
             this.obj = obj;
         }
 
-        ReadThread( Buffer buffer, Object obj, ArrayList exceptionList ) {
+        ReadThread(Buffer<E> buffer, Object obj, ArrayList<String> exceptionList) {
             super();
             this.buffer = buffer;
             this.obj = obj;
             this.exceptionList = exceptionList;
         }
 
-        ReadThread( Buffer buffer, Object obj, ArrayList exceptionList, String action ) {
+        ReadThread(Buffer<E> buffer, Object obj, ArrayList<String> exceptionList, String action) {
             super();
             this.buffer = buffer;
             this.obj = obj;
@@ -503,7 +510,7 @@ public class TestBlockingBuffer extends AbstractTestObject {
             this.action = action;
         }
 
-        ReadThread( Buffer buffer, Set objs, String action ) {
+        ReadThread(Buffer<E> buffer, Set<E> objs, String action) {
             super();
             this.buffer = buffer;
             this.objs = objs;
@@ -512,46 +519,43 @@ public class TestBlockingBuffer extends AbstractTestObject {
 
         public void run() {
             try {
-                if( action == "get" ) {
-                    assertSame( obj, buffer.get() );
-                }
-                else {
-                    if( null != obj ) {
-                        assertSame( obj, buffer.remove() );
-                    }
-                    else {
-                        assertTrue( objs.remove( buffer.remove() ) );
+                if (action == "get") {
+                    assertSame(obj, buffer.get());
+                } else {
+                    if (null != obj) {
+                        assertSame(obj, buffer.remove());
+                    } else {
+                        assertTrue(objs.remove(buffer.remove()));
                     }
                 }
-            }
-            catch( BufferUnderflowException ex ) {
-                exceptionList.add( "BufferUnderFlow" );
+            } catch (BufferUnderflowException ex) {
+                exceptionList.add("BufferUnderFlow");
             }
         }
     }
 
-    protected static class MyBuffer extends LinkedList implements Buffer {
+    @SuppressWarnings("serial")
+    protected static class MyBuffer<E> extends LinkedList<E> implements Buffer<E> {
 
-        public Object get() {
-            if( isEmpty() ) {
+        public E get() {
+            if (isEmpty()) {
                 throw new BufferUnderflowException();
             }
-            return get( 0 );
+            return get(0);
         }
 
-        public Object remove() {
-            if( isEmpty() ) {
+        public E remove() {
+            if (isEmpty()) {
                 throw new BufferUnderflowException();
             }
-            return remove( 0 );
+            return remove(0);
         }
     }
 
     private void delay() {
         try {
-            Thread.sleep( 100 );
-        }
-        catch( InterruptedException e ) {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
         }
     }
 
@@ -559,15 +563,15 @@ public class TestBlockingBuffer extends AbstractTestObject {
         return "3.1";
     }
 
-//    public void testCreate() throws Exception {
-//        Buffer buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
-//        writeExternalFormToDisk((java.io.Serializable) buffer,
-//        "D:/dev/collections/data/test/BlockingBuffer.emptyCollection.version3.1.obj");
-//        buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
-//        buffer.add("A");
-//        buffer.add("B");
-//        buffer.add("C");
-//        writeExternalFormToDisk((java.io.Serializable) buffer,
-//        "D:/dev/collections/data/test/BlockingBuffer.fullCollection.version3.1.obj");
-//    }
+    //    public void testCreate() throws Exception {
+    //        Buffer buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
+    //        writeExternalFormToDisk((java.io.Serializable) buffer,
+    //        "D:/dev/collections/data/test/BlockingBuffer.emptyCollection.version3.1.obj");
+    //        buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
+    //        buffer.add("A");
+    //        buffer.add("B");
+    //        buffer.add("C");
+    //        writeExternalFormToDisk((java.io.Serializable) buffer,
+    //        "D:/dev/collections/data/test/BlockingBuffer.fullCollection.version3.1.obj");
+    //    }
 }


Mime
View raw message