Add abstract test class for OrderedMap

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/collections/trunk@131362 13f79535-47bb-0310-9956-ffa450edef68

src/test/org/apache/commons/collections/map/AbstractTestOrderedMap.java

@@ -0,0 +1,306 @@
+/*
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/map/AbstractTestOrderedMap.java,v 1.1 2003/11/20 22:34:49 scolebourne Exp $
+ * ====================================================================
+ *
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The end-user documentation included with the redistribution, if
+ *    any, must include the following acknowledgement:
+ *       "This product includes software developed by the
+ *        Apache Software Foundation (http://www.apache.org/)."
+ *    Alternately, this acknowledgement may appear in the software itself,
+ *    if and wherever such third-party acknowledgements normally appear.
+ *
+ * 4. The names "The Jakarta Project", "Commons", and "Apache Software
+ *    Foundation" must not be used to endorse or promote products derived
+ *    from this software without prior written permission. For written
+ *    permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache"
+ *    nor may "Apache" appear in their names without prior written
+ *    permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ *
+ */
+package org.apache.commons.collections.map;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.TreeMap;
+
+import org.apache.commons.collections.BulkTest;
+import org.apache.commons.collections.comparators.NullComparator;
+import org.apache.commons.collections.iterators.AbstractTestMapIterator;
+import org.apache.commons.collections.iterators.AbstractTestOrderedMapIterator;
+import org.apache.commons.collections.iterators.MapIterator;
+
+/**
+ * Abstract test class for {@link OrderedMap} methods and contracts.
+ *
+ * @version $Revision: 1.1 $ $Date: 2003/11/20 22:34:49 $
+ * 
+ * @author Stephen Colebourne
+ */
+public abstract class AbstractTestOrderedMap extends AbstractTestMap {
+
+    /**
+     * JUnit constructor.
+     * 
+     * @param testName  the test name
+     */
+    public AbstractTestOrderedMap(String testName) {
+        super(testName);
+    }
+    
+    //-----------------------------------------------------------------------
+    /**
+     * OrderedMap uses TreeMap as its known comparison.
+     * 
+     * @return a map that is known to be valid
+     */
+    public Map makeConfirmedMap() {
+        return new TreeMap(new NullComparator());
+    }
+    
+    /**
+     * The only confirmed collection we have that is ordered is the sorted one.
+     * Thus, sort the keys.
+     */
+    public Object[] getSampleKeys() {
+        List list = new ArrayList(Arrays.asList(super.getSampleKeys()));
+        Collections.sort(list, new NullComparator());
+        return list.toArray();
+    }
+
+    //-----------------------------------------------------------------------
+    public void testFirstKey() {
+        resetEmpty();
+        OrderedMap ordered = (OrderedMap) map;
+        try {
+            ordered.firstKey();
+            fail();
+        } catch (NoSuchElementException ex) {}
+        
+        resetFull();
+        ordered = (OrderedMap) map;
+        Object confirmedFirst = confirmed.keySet().iterator().next();
+        assertEquals(confirmedFirst, ordered.firstKey());
+    }
+    
+    public void testLastKey() {
+        resetEmpty();
+        OrderedMap ordered = (OrderedMap) map;
+        try {
+            ordered.lastKey();
+            fail();
+        } catch (NoSuchElementException ex) {}
+        
+        resetFull();
+        ordered = (OrderedMap) map;
+        Object confirmedLast = null;
+        for (Iterator it = confirmed.keySet().iterator(); it.hasNext();) {
+            confirmedLast = it.next();
+        }
+        assertEquals(confirmedLast, ordered.lastKey());
+    }
+
+    //-----------------------------------------------------------------------    
+    public void testNextKey() {
+        resetEmpty();
+        OrderedMap ordered = (OrderedMap) map;
+        assertEquals(null, ordered.nextKey(getOtherKeys()[0]));
+        if (isAllowNullKey() == false) {
+            try {
+                assertEquals(null, ordered.nextKey(null)); // this is allowed too
+            } catch (NullPointerException ex) {}
+        } else {
+            assertEquals(null, ordered.nextKey(null));
+        }
+        
+        resetFull();
+        ordered = (OrderedMap) map;
+        Iterator it = confirmed.keySet().iterator();
+        Object confirmedLast = it.next();
+        while (it.hasNext()) {
+            Object confirmedObject = it.next();
+            assertEquals(confirmedObject, ordered.nextKey(confirmedLast));
+            confirmedLast = confirmedObject;
+        }
+        assertEquals(null, ordered.nextKey(confirmedLast));
+        
+        if (isAllowNullKey() == false) {
+            try {
+                ordered.nextKey(null);
+                fail();
+            } catch (NullPointerException ex) {}
+        } else {
+            assertEquals(null, ordered.nextKey(null));
+        }
+    }
+    
+    public void testPreviousKey() {
+        resetEmpty();
+        OrderedMap ordered = (OrderedMap) map;
+        assertEquals(null, ordered.previousKey(getOtherKeys()[0]));
+        if (isAllowNullKey() == false) {
+            try {
+                assertEquals(null, ordered.previousKey(null)); // this is allowed too
+            } catch (NullPointerException ex) {}
+        } else {
+            assertEquals(null, ordered.previousKey(null));
+        }
+        
+        resetFull();
+        ordered = (OrderedMap) map;
+        List list = new ArrayList(confirmed.keySet());
+        Collections.reverse(list);
+        Iterator it = list.iterator();
+        Object confirmedLast = it.next();
+        while (it.hasNext()) {
+            Object confirmedObject = it.next();
+            assertEquals(confirmedObject, ordered.previousKey(confirmedLast));
+            confirmedLast = confirmedObject;
+        }
+        assertEquals(null, ordered.previousKey(confirmedLast));
+        
+        if (isAllowNullKey() == false) {
+            try {
+                ordered.previousKey(null);
+                fail();
+            } catch (NullPointerException ex) {}
+        } else {
+            if (isAllowNullKey() == false) {
+                assertEquals(null, ordered.previousKey(null));
+            }
+        }
+    }
+    
+    //-----------------------------------------------------------------------
+    public BulkTest bulkTestMapIterator() {
+        return new InnerTestOrderedMapIterator();
+    }
+    
+    // TODO: Test mapIterator() and orderedMapIterator() separately
+    public class InnerTestMapIterator extends AbstractTestMapIterator {
+        public InnerTestMapIterator() {
+            super("InnerTestMapIterator");
+        }
+        
+        public boolean supportsRemove() {
+            return AbstractTestOrderedMap.this.isRemoveSupported();
+        }
+
+        public boolean supportsSetValue() {
+            return AbstractTestOrderedMap.this.isSetValueSupported();
+        }
+
+        public MapIterator makeEmptyMapIterator() {
+            resetEmpty();
+            return ((OrderedMap) AbstractTestOrderedMap.this.map).mapIterator();
+        }
+
+        public MapIterator makeFullMapIterator() {
+            resetFull();
+            return ((OrderedMap) AbstractTestOrderedMap.this.map).mapIterator();
+        }
+        
+        public Map getMap() {
+            // assumes makeFullMapIterator() called first
+            return AbstractTestOrderedMap.this.map;
+        }
+        
+        public Map getConfirmedMap() {
+            // assumes makeFullMapIterator() called first
+            return AbstractTestOrderedMap.this.confirmed;
+        }
+        
+        public void verify() {
+            super.verify();
+            AbstractTestOrderedMap.this.verify();
+        }
+    }
+    
+    //-----------------------------------------------------------------------
+    public BulkTest bulkTestOrderedMapIterator() {
+        return new InnerTestOrderedMapIterator();
+    }
+    
+    // TODO: Test mapIterator() and orderedMapIterator() separately
+    public class InnerTestOrderedMapIterator extends AbstractTestOrderedMapIterator {
+        public InnerTestOrderedMapIterator() {
+            super("InnerTestOrderedMapIterator");
+        }
+        
+        public boolean supportsRemove() {
+            return AbstractTestOrderedMap.this.isRemoveSupported();
+        }
+
+        public boolean supportsSetValue() {
+            return AbstractTestOrderedMap.this.isSetValueSupported();
+        }
+
+        public MapIterator makeEmptyMapIterator() {
+            resetEmpty();
+            return ((OrderedMap) AbstractTestOrderedMap.this.map).orderedMapIterator();
+        }
+
+        public MapIterator makeFullMapIterator() {
+            resetFull();
+            return ((OrderedMap) AbstractTestOrderedMap.this.map).orderedMapIterator();
+        }
+        
+        public Map getMap() {
+            // assumes makeFullMapIterator() called first
+            return AbstractTestOrderedMap.this.map;
+        }
+        
+        public Map getConfirmedMap() {
+            // assumes makeFullMapIterator() called first
+            return AbstractTestOrderedMap.this.confirmed;
+        }
+        
+        public void verify() {
+            super.verify();
+            AbstractTestOrderedMap.this.verify();
+        }
+    }
+    
+}

src/test/org/apache/commons/collections/map/TestListOrderedMap.java

@@ -1,10 +1,10 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/map/TestListOrderedMap.java,v 1.4 2003/11/20 00:03:06 scolebourne Exp $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/map/TestListOrderedMap.java,v 1.5 2003/11/20 22:34:49 scolebourne Exp $
  * ====================================================================
  *
  * The Apache Software License, Version 1.1
  *
- * Copyright (c) 2003 The Apache Software Foundation.  All rights
+ * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -57,30 +57,24 @@
  */
 package org.apache.commons.collections.map;
 
-import java.util.ArrayList;
-import java.util.Collection;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
-import java.util.Set;
 
 import junit.framework.Test;
 
 import org.apache.commons.collections.BulkTest;
-import org.apache.commons.collections.iterators.AbstractTestOrderedMapIterator;
-import org.apache.commons.collections.iterators.MapIterator;
 
 /**
  * Extension of {@link TestMap} for exercising the {@link ListOrderedMap}
  * implementation.
  *
  * @since Commons Collections 3.0
- * @version $Revision: 1.4 $ $Date: 2003/11/20 00:03:06 $
+ * @version $Revision: 1.5 $ $Date: 2003/11/20 22:34:49 $
  * 
  * @author Henri Yandell
  * @author Stephen Colebourne
  */
-public class TestListOrderedMap extends AbstractTestMap {
+public class TestListOrderedMap extends AbstractTestOrderedMap {
 
     public TestListOrderedMap(String testName) {
         super(testName);
@@ -99,97 +93,4 @@ public class TestListOrderedMap extends AbstractTestMap {
         return ListOrderedMap.decorate(new HashMap());
     }
 
-    //-----------------------------------------------------------------------
-    public BulkTest bulkTestMapIterator() {
-        return new TestListOrderedMapIterator();
-    }
-    
-    // TODO: Test mapIterator() and orderedMapIterator() separately
-    public class TestListOrderedMapIterator extends AbstractTestOrderedMapIterator {
-        public TestListOrderedMapIterator() {
-            super("TestListOrderedMapIterator");
-        }
-        
-        public boolean supportsRemove() {
-            return TestListOrderedMap.this.isRemoveSupported();
-        }
-
-        public boolean supportsSetValue() {
-            return TestListOrderedMap.this.isSetValueSupported();
-        }
-
-        public MapIterator makeEmptyMapIterator() {
-            resetEmpty();
-            return ((ListOrderedMap) TestListOrderedMap.this.map).mapIterator();
-        }
-
-        public MapIterator makeFullMapIterator() {
-            resetFull();
-            return ((ListOrderedMap) TestListOrderedMap.this.map).mapIterator();
-        }
-        
-        public Map getMap() {
-            // assumes makeFullMapIterator() called first
-            return TestListOrderedMap.this.map;
-        }
-        
-        public Map getConfirmedMap() {
-            // assumes makeFullMapIterator() called first
-            return TestListOrderedMap.this.confirmed;
-        }
-        
-        public void verify() {
-            super.verify();
-            TestListOrderedMap.this.verify();
-        }
-    }
-    
-    //-----------------------------------------------------------------------
-    // Creates a known series of Objects, puts them in 
-    // an OrderedMap and ensures that all three Collection 
-    // methods return in the correct order.
-    public void testInsertionOrder() {
-        int size = 10; // number to try
-        ArrayList list = new ArrayList(size);
-        for( int i=0; i<size; i++ ) {
-            list.add( new Object() );
-        }
-
-        Map map = makeEmptyMap();
-        for( Iterator itr = list.iterator(); itr.hasNext(); ) {
-            Object obj = itr.next();
-            map.put( obj, obj );
-        }
-
-        assertSameContents(map.values(), list);
-        assertSameContents(map.keySet(), list);
-
-        // check entrySet
-        Set entries = map.entrySet();
-        assertEquals( entries.size(), list.size() );
-        Iterator i1 = entries.iterator();
-        Iterator i2 = list.iterator();
-        while( i1.hasNext() && i2.hasNext() ) {
-            Map.Entry entry = (Map.Entry) i1.next();
-            Object obj = i2.next();
-            assertSame( entry.getKey(), obj );
-            assertSame( entry.getValue(), obj );
-        }
-        assertTrue( !(i1.hasNext() && i2.hasNext()) );
-
-    }
-
-    private void assertSameContents(Collection c1, Collection c2) {
-        assertNotNull(c1);
-        assertNotNull(c2);
-        assertEquals( c1.size(), c2.size() );
-        Iterator i1 = c1.iterator();
-        Iterator i2 = c2.iterator();
-        while( i1.hasNext() && i2.hasNext() ) {
-            assertSame( i1.next(), i2.next() );
-        }
-        // ensure they've both ended
-        assertTrue( !(i1.hasNext() && i2.hasNext()) );
-    }
-
 }