commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject [01/18] commons-collections git commit: merging serialization test methods into the 1.x branch
Date Tue, 11 Jul 2017 17:53:49 GMT
Repository: commons-collections
Updated Branches:
  refs/heads/collections_1_x_branch [created] 88d84e95e


merging serialization test methods into the 1.x branch


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


Project: http://git-wip-us.apache.org/repos/asf/commons-collections/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-collections/commit/6a2c9bff
Tree: http://git-wip-us.apache.org/repos/asf/commons-collections/tree/6a2c9bff
Diff: http://git-wip-us.apache.org/repos/asf/commons-collections/diff/6a2c9bff

Branch: refs/heads/collections_1_x_branch
Commit: 6a2c9bff5d2130a06b077472a37c35d334725764
Parents: 7696ab2
Author: Morgan James Delagrange <morgand@apache.org>
Authored: Tue Feb 26 00:51:21 2002 +0000
Committer: Morgan James Delagrange <morgand@apache.org>
Committed: Tue Feb 26 00:51:21 2002 +0000

----------------------------------------------------------------------
 .../apache/commons/collections/TestHashMap.java |  12 +-
 .../apache/commons/collections/TestLRUMap.java  |  12 +-
 .../org/apache/commons/collections/TestMap.java | 953 ++++++++++++++++++-
 .../commons/collections/TestMultiHashMap.java   |   8 +-
 .../apache/commons/collections/TestObject.java  | 135 ++-
 .../apache/commons/collections/TestTreeMap.java |  12 +-
 6 files changed, 1053 insertions(+), 79 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestHashMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestHashMap.java b/src/test/org/apache/commons/collections/TestHashMap.java
index 84399a7..c28f788 100644
--- a/src/test/org/apache/commons/collections/TestHashMap.java
+++ b/src/test/org/apache/commons/collections/TestHashMap.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestHashMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
- * $Revision: 1.2 $
- * $Date: 2001/07/14 23:33:27 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestHashMap.java,v 1.2.2.1 2002/02/26 00:51:21 morgand Exp $
+ * $Revision: 1.2.2.1 $
+ * $Date: 2002/02/26 00:51:21 $
  *
  * ====================================================================
  *
@@ -69,7 +69,7 @@ import java.util.Map;
 
 /**
  * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
- * @version $Id: TestHashMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
+ * @version $Id: TestHashMap.java,v 1.2.2.1 2002/02/26 00:51:21 morgand Exp $
  */
 public class TestHashMap extends TestMap
 {
@@ -89,7 +89,7 @@ public class TestHashMap extends TestMap
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    public Map makeMap() {
+    public Map makeEmptyMap() {
         HashMap hm = new HashMap();
         return (hm);
     }
@@ -98,7 +98,7 @@ public class TestHashMap extends TestMap
 
     public void setUp()
     {
-        map = (HashMap) makeMap();
+        map = (HashMap) makeEmptyMap();
     }
 
     public void testNewMap()

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestLRUMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestLRUMap.java b/src/test/org/apache/commons/collections/TestLRUMap.java
index 3e9319a..091252b 100644
--- a/src/test/org/apache/commons/collections/TestLRUMap.java
+++ b/src/test/org/apache/commons/collections/TestLRUMap.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestLRUMap.java,v 1.11 2002/02/19 21:28:53 morgand Exp $
- * $Revision: 1.11 $
- * $Date: 2002/02/19 21:28:53 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestLRUMap.java,v 1.11.2.1 2002/02/26 00:51:21 morgand Exp $
+ * $Revision: 1.11.2.1 $
+ * $Date: 2002/02/26 00:51:21 $
  *
  * ====================================================================
  *
@@ -76,7 +76,7 @@ import java.util.HashMap;
  * 
  * @author <a href="mailto:jstrachan@apache.org">James Strachan</a>
  * @author <a href="mailto:morgand@apache.org">Morgan Delagrange</a>
- * @version $Id: TestLRUMap.java,v 1.11 2002/02/19 21:28:53 morgand Exp $
+ * @version $Id: TestLRUMap.java,v 1.11.2.1 2002/02/26 00:51:21 morgand Exp $
  */
 public class TestLRUMap extends TestMap
 {
@@ -93,7 +93,7 @@ public class TestLRUMap extends TestMap
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    public Map makeMap() {
+    public Map makeEmptyMap() {
         LRUMap map = new LRUMap(10);
         return map;
     }
@@ -153,7 +153,7 @@ public class TestLRUMap extends TestMap
 
 
     public void testMapSupportsNullValues() {
-        Map map = makeMap();
+        Map map = makeEmptyMap();
         map.put(new Integer(1),"foo");
         
         assertTrue("no null values in Map",map.containsValue(null) == false);

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestMap.java b/src/test/org/apache/commons/collections/TestMap.java
index ce8063a..0261d3f 100644
--- a/src/test/org/apache/commons/collections/TestMap.java
+++ b/src/test/org/apache/commons/collections/TestMap.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestMap.java,v 1.3 2002/02/15 20:48:18 morgand Exp $
- * $Revision: 1.3 $
- * $Date: 2002/02/15 20:48:18 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestMap.java,v 1.3.2.1 2002/02/26 00:51:21 morgand Exp $
+ * $Revision: 1.3.2.1 $
+ * $Date: 2002/02/26 00:51:21 $
  *
  * ====================================================================
  *
@@ -62,55 +62,730 @@
 package org.apache.commons.collections;
 
 import junit.framework.*;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Collection;
 import java.util.Map;
 import java.util.Collection;
+import java.util.Set;
+import java.util.Iterator;
+import java.util.HashSet;
+import java.util.NoSuchElementException;
 
 /**
  * Tests base {@link java.util.Map} methods and contracts.
  * <p>
- * To use, simply extend this class, and implement
- * the {@link #makeMap} method.
+ * If your class implements the full Map interface, including optional
+ * operations, simply extend this class, and implement the {@link
+ * #makeEmptyMap()} method.
  * <p>
- * If your {@link Map} fails one of these tests by design,
- * you may still use this base set of cases.  Simply override the
- * test case (method) your {@link Map} fails.
+ * If your {@link Map} fails one of these tests by design, you may still use
+ * this base set of cases.  Simply override the test case (method) your {@link
+ * Map} fails and/or the methods that define the assumptions used by the test
+ * cases.  For example, if your map does not allow duplicate values, override
+ * {@link useDuplicateValues()} and have it return <code>false</code>
  *
+ * @author Michael Smith
  * @author Rodney Waldhoff
- * @version $Id: TestMap.java,v 1.3 2002/02/15 20:48:18 morgand Exp $
+ * @version $Id: TestMap.java,v 1.3.2.1 2002/02/26 00:51:21 morgand Exp $
  */
 public abstract class TestMap extends TestObject {
+
     public TestMap(String testName) {
         super(testName);
     }
+    /**
+     *  Override if your map does not allow a <code>null</code> key.  The
+     *  default implementation returns <code>true</code>
+     **/
+    public boolean useNullKey() {
+        return true;
+    }
+
+    /**
+     *  Override if your map does not allow <code>null</code> values.  The
+     *  default implementation returns <code>true</code>.
+     **/
+    public boolean useNullValue() {
+        return true;
+    }
+
+    /**
+     *  Override if your map does not allow duplicate values.  The default
+     *  implementation returns <code>true</code>.
+     **/
+    public boolean useDuplicateValues() {
+        return true;
+    }
+
+    /**
+     *  Override if your map allows its mappings to be changed to new values.
+     *  The default implementation returns <code>true</code>.
+     **/
+    public boolean isChangeable() {
+        return true;
+    }
+
+    /**
+     *  Override if your map does not allow add/remove modifications.  The
+     *  default implementation returns <code>true</code>.
+     **/
+    public boolean isAddRemoveModifiable() {
+        return true;
+    }
+
+    /**
+     *  Returns the set of keys in the mappings used to test the map.  This
+     *  method must return an array with the same length as {@link
+     *  #getSampleValues()} and all array elements must be different. The
+     *  default implementation constructs a set of String keys, and includes a
+     *  single null key if {@link #useNullKey()} returns <code>true</code>.
+     **/
+    public Object[] getSampleKeys() {
+        Object[] result = new Object[] {
+            "blah", "foo", "bar", "baz", "tmp", "gosh", "golly", "gee", 
+            "hello", "goodbye", "we'll", "see", "you", "all", "again",
+            "key",
+            "key2",
+            (useNullKey()) ? null : "nonnullkey"
+        };
+        return result;
+    }
+
+    /**
+     *  Returns the set of values in the mappings used to test the map.  This
+     *  method must return an array with the same length as {@link
+     *  #getSampleKeys()}.  The default implementation contructs a set of
+     *  String values and includes a single null value if {@link
+     *  #useNullValue()} returns <code>true</code>, and includes two values
+     *  that are the same if {@link #useDuplicateValues()} returns
+     *  <code>true</code>.
+     **/
+    public Object[] getSampleValues() {
+        Object[] result = new Object[] {
+            "blahv", "foov", "barv", "bazv", "tmpv", "goshv", "gollyv", "geev",
+            "hellov", "goodbyev", "we'llv", "seev", "youv", "allv", "againv",
+            (useNullValue()) ? null : "nonnullvalue",
+            "value",
+            (useDuplicateValues()) ? "value" : "value2",
+        };
+        return result;
+    }
+
+    /**
+     *  Returns a the set of values that can be used to replace the values
+     *  returned from {@link #getSampleValues()}.  This method must return an
+     *  array with the same length as {@link #getSampleValues()}.  The values
+     *  returned from this method should not be the same as those returned from
+     *  {@link #getSampleValues()}.  The default implementation constructs a
+     *  set of String values and includes a single null value if {@link
+     *  #useNullValue()} returns <code>true</code>, and includes two values
+     *  that are the same if {@link #useDuplicateValues()} returns
+     *  <code>true</code>.  
+     **/
+    public Object[] getNewSampleValues() {
+        Object[] result = new Object[] {
+            (useNullValue()) ? null : "newnonnullvalue",
+            "newvalue",
+            (useDuplicateValues()) ? "newvalue" : "newvalue2",
+            "newblahv", "newfoov", "newbarv", "newbazv", "newtmpv", "newgoshv", 
+            "newgollyv", "newgeev", "newhellov", "newgoodbyev", "newwe'llv", 
+            "newseev", "newyouv", "newallv", "newagainv",
+        };
+        return result;
+    }
+
+    /**
+     *  Helper method to add all the mappings described by {@link
+     *  #getSampleKeys()} and {@link #getSampleValues()}.
+     **/
+    public void addSampleMappings(Map m) {
+
+        Object[] keys = getSampleKeys();
+        Object[] values = getSampleValues();
+        
+        for(int i = 0; i < keys.length; i++) {
+            try {
+                m.put(keys[i], values[i]);
+            } catch (NullPointerException exception) {
+                assertTrue("NullPointerException only allowed to be thrown " +
+                           "if either the key or value is null.", 
+                           keys[i] == null || values[i] == null);
+                
+                assertTrue("NullPointerException on null key, but " +
+                           "useNullKey is not overridden to return false.", 
+                           keys[i] == null || !useNullKey());
+                
+                assertTrue("NullPointerException on null value, but " +
+                           "useNullValue is not overridden to return false.",
+                           values[i] == null || !useNullValue());
+                
+                assertTrue("Unknown reason for NullPointer.", false);
+            }
+        }
+        assertEquals("size must reflect number of mappings added.",
+                     keys.length, m.size());
+    }
 
     /**
-     * Return a new, empty {@link Map} to used for testing.
+     * Return a new, empty {@link Map} to be used for testing. 
      */
-    public abstract Map makeMap();
+    public abstract Map makeEmptyMap();
+
+    /**
+     *  Return a new, populated map.  The mappings in the map should match the
+     *  keys and values returned from {@linke #getSampleKeys()} and {@link
+     *  #getSampleValues()}.  The default implementation uses makeEmptyMap()
+     *  and calls {@link #addSampleMappings()} to add all the mappings to the
+     *  map.
+     **/
+    public Map makeFullMap() {
+        Map m = makeEmptyMap();
+        addSampleMappings(m);
+        return m;
+    }
 
     public Object makeObject() {
-        return makeMap();
+        return makeEmptyMap();
     }
 
-    /*
+    /**
+     *  Test to ensure the test setup is working properly.  This method checks
+     *  to ensure that the getSampleKeys and getSampleValues methods are
+     *  returning results that look appropriate.  That is, they both return a
+     *  non-null array of equal length.  The keys array must not have any
+     *  duplicate values, and may only contain a (single) null key if
+     *  useNullKey() returns true.  The values array must only have a null
+     *  value if useNullValue() is true and may only have duplicate values if
+     *  useDuplicateValues() returns true.  
+     **/
+    public void testSampleMappings() {
+      Object[] keys = getSampleKeys();
+      Object[] values = getSampleValues();
+      Object[] newValues = getNewSampleValues();
 
-    // optional operation
-    public void testMapClear() {
-        // XXX finish me
+      assertTrue("failure in test: Must have keys returned from " +
+                 "getSampleKeys.", keys != null);
+
+      assertTrue("failure in test: Must have values returned from " +
+                 "getSampleValues.", values != null);
+
+      // verify keys and values have equivalent lengths (in case getSampleX are
+      // overridden)
+      assertEquals("failure in test: not the same number of sample " +
+                   "keys and values.",  keys.length, values.length);
+      
+      assertEquals("failure in test: not the same number of values and new values.",
+                   values.length, newValues.length);
+
+      // verify there aren't duplicate keys, and check values
+      for(int i = 0; i < keys.length - 1; i++) {
+          for(int j = i + 1; j < keys.length; j++) {
+              assertTrue("failure in test: duplicate null keys.",
+                         (keys[i] != null || keys[j] != null));
+              assertTrue("failure in test: duplicate non-null key.",
+                         (keys[i] == null || keys[j] == null || 
+                          (!keys[i].equals(keys[j]) && 
+                           !keys[j].equals(keys[i]))));
+          }
+          assertTrue("failure in test: found null key, but useNullKey " +
+                     "is false.", keys[i] != null || useNullKey());
+          assertTrue("failure in test: found null value, but useNullValue " +
+                     "is false.", values[i] != null || useNullValue());
+          assertTrue("failure in test: found null new value, but useNullValue " +
+                     "is false.", newValues[i] != null || useNullValue());
+          assertTrue("failure in test: values should not be the same as new value",
+                     values[i] != newValues[i] && 
+                     (values[i] == null || !values[i].equals(newValues[i])));
+      }
     }
+    
+    // tests begin here.  Each test adds a little bit of tested functionality.
+    // Many methods assume previous methods passed.  That is, they do not
+    // exhaustively recheck things that have already been checked in a previous
+    // test methods.  
 
-    public void testMapContainsKey() {
-        // XXX finish me
+    /**
+     *  Test to ensure that makeEmptyMap and makeFull returns a new non-null
+     *  map with each invocation.  
+     **/
+    public void testMakeMap() {
+        Map em = makeEmptyMap();
+        assertTrue("failure in test: makeEmptyMap must return a non-null map.",
+                   em != null);
+        
+        Map em2 = makeEmptyMap();
+        assertTrue("failure in test: makeEmptyMap must return a non-null map.",
+                   em != null);
+
+        assertTrue("failure in test: makeEmptyMap must return a new map " +
+                   "with each invocation.", em != em2);
+
+        Map fm = makeFullMap();
+        assertTrue("failure in test: makeFullMap must return a non-null map.",
+                   fm != null);
+        
+        Map fm2 = makeFullMap();
+        assertTrue("failure in test: makeFullMap must return a non-null map.",
+                   fm != null);
+
+        assertTrue("failure in test: makeFullMap must return a new map " +
+                   "with each invocation.", fm != fm2);
     }
 
-    public void testMapContainsValue() {
-        // XXX finish me
+    /**
+     *  Tests Map.isEmpty()
+     **/
+    public void testIsEmpty() {
+        Map em = makeEmptyMap();
+        assertEquals("Map.isEmpty() should return true with an empty map", 
+                     true, em.isEmpty());
+
+        Map fm = makeFullMap();
+        assertEquals("Map.isEmpty() should return false with a non-empty map",
+                     false, fm.isEmpty());
     }
 
-    public void testMapEntrySet() {
-        // XXX finish me
+    /**
+     *  Tests Map.size()
+     **/
+    public void testSize() {
+        Map em = makeEmptyMap();
+        assertEquals("Map.size() should be 0 with an empty map",
+                     0, em.size());
+
+        Map fm = makeFullMap();
+        assertEquals("Map.size() should equal the number of entries in the map",
+                     getSampleKeys().length, fm.size());
     }
 
+    /**
+     *  Tests {@link Map#clear()}.  If the map {@link #isAddRemoveModifiable()
+     *  can add and remove elements}, then {@link Map#size()} and {@link
+     *  Map#isEmpty()} are used to ensure that map has no elements after a call
+     *  to clear.  If the map does not support adding and removing elements,
+     *  this method checks to ensure clear throws an
+     *  UnsupportedOperationException.  This method checks that the both maps
+     *  returned by makeEmptyMap and makeFullMap have correct behavior.
+     **/
+    public void testClear() {
+        Map em = makeEmptyMap();
+        try {
+            em.clear();
+            assertTrue("Map must throw UnsupportedOperationException if the " +
+                       "map does not support removing elements", 
+                       isAddRemoveModifiable());
+            assertEquals("size() must return zero after clear.", 
+                         0, em.size());
+            assertEquals("isEmpty() must return true after clear.", 
+                         true, em.isEmpty());
+        } catch (UnsupportedOperationException exception) {
+            assertTrue("Map must not throw UnsupportedOperationException if the " +
+                       "map supports removing elements", !isAddRemoveModifiable());
+        }
+
+        Map fm = makeFullMap();
+        try {
+            fm.clear();
+            assertTrue("Map must throw UnsupportedOperationException if the " +
+                       "map does not support removing elements", 
+                       isAddRemoveModifiable());
+            assertEquals("size() must return zero after clear.", 
+                         0, fm.size());
+            assertEquals("isEmpty() must return true after clear.", 
+                         true, fm.isEmpty());
+        } catch (UnsupportedOperationException exception) {
+            assertTrue("Map must not throw UnsupportedOperationException if the " +
+                       "map supports removing elements", !isAddRemoveModifiable());
+        }
+    }
+
+    /**
+     *  Tests:
+     *  <ul>
+     *  <li> Map.entrySet().isEmpty()
+     *  <li> Map.entrySet().size()
+     *  </ul>
+     **/
+    public void testEntrySetIsEmpty() {
+        Map em = makeEmptyMap();
+        Set es = em.entrySet();
+        
+        assertEquals("entrySet() must return an empty set when map is empty.", 
+                     em.isEmpty(), es.isEmpty());
+        assertEquals("entrySet() must return a set with the same size as " +
+                     "the map.", em.size(), es.size());
+
+        Map fm = makeEmptyMap();
+        Set fs = fm.entrySet();
+        
+        assertEquals("entrySet() must return a non-empty set when map is not empty.", 
+                     fm.isEmpty(), fs.isEmpty());
+        assertEquals("entrySet() must return a set with the same size as " +
+                     "the map.", fm.size(), fs.size());
+    }
+
+    /**
+     *  Tests Map.containsKey(Object) by verifying it returns false for all
+     *  sample keys on a map created using makeEmptyMap() and returns true for
+     *  all sample keys returned on a map created using makeFullMap()
+     **/
+    public void testContainsKey() {
+        Object[] keys = getSampleKeys();
+
+        Map em = makeEmptyMap();
+
+        for(int i = 0; i < keys.length; i++) {
+            assertTrue("Map must not contain key when map is empty", 
+                       !em.containsKey(keys[i]));
+        }
+
+        Map fm = makeFullMap();
+
+        for(int i = 0; i < keys.length; i++) {
+            assertTrue("Map must contain key for a mapping in the map.", 
+                       fm.containsKey(keys[i]));
+        }
+    }
+
+    /**
+     *  Tests Map.containsValue(Object) by verifying it returns false for all
+     *  sample alues on a map created using makeEmptyMap() and returns true for
+     *  all sample values returned on a map created using makeFullMap.
+     **/
+    public void testContainsValue() {
+        Object[] values = getSampleValues();
+
+        Map em = makeEmptyMap();
+
+        for(int i = 0; i < values.length; i++) {
+            assertTrue("Empty map must not contain value", 
+                       !em.containsValue(values[i]));
+        }
+
+        Map fm = makeFullMap();
+
+        for(int i = 0; i < values.length; i++) {
+            assertTrue("Map must contain value for a mapping in the map.", 
+                       fm.containsValue(values[i]));
+        }
+    }
+
+    /**
+     *  Test to ensure that Map.entrySet() returns a non-null set.
+     **/
+    public void testEntrySet() {
+        Map em = makeEmptyMap();
+        Set es = em.entrySet();
+        
+        assertTrue("entrySet() must return a non-null set.", es != null);
+
+        Map fm = makeEmptyMap();
+        Set fs = fm.entrySet();
+        
+        assertTrue("entrySet() must return a non-null set.", fs != null);
+    }
+    
+    /**
+     *  Tests:
+     *  <ul>
+     *  <li> Map.entrySet().contains(Object)
+     *  <li> Map.entrySet().containsAll(Collection)
+     *  </ul>
+     *
+     *  Note:  This test relies on a working commons.collections.DefaultMapEntry class.
+     **/
+    public void testEntrySetContainsProperMappings() {
+        Object[] keys = getSampleKeys();
+        Object[] values = getSampleValues();
+        Map.Entry[] entries = new Map.Entry[keys.length];
+        HashSet mappings = new HashSet();
+
+        for(int i = 0; i < keys.length; i++) {
+            entries[i] = new DefaultMapEntry(keys[i], values[i]);
+            mappings.add(entries[i]);
+        }
+
+        // test an empty map
+        Map em = makeEmptyMap();
+        Set es = em.entrySet();
+
+        for(int i = 0; i < keys.length; i++) {
+            assertEquals("entrySet().contains(Object) must return false when map " +
+                         "is empty", false, es.contains(entries[i]));
+        }
+
+        assertEquals("entrySet().containsAll(Collection) must return false when the " +
+                     "map is empty", false, es.containsAll(mappings));
+
+
+        Map fm = makeFullMap();
+        Set fs = fm.entrySet();
+
+        for(int i = 0; i < keys.length; i++) {
+            assertEquals("entrySet().contains(Object) must return true when map " +
+                         "contains the mapping", true, fs.contains(entries[i]));
+        }
+        assertEquals("entrySet().containsAll(Collection) must return true when the " +
+                     "map contains the mapping", true, fs.containsAll(mappings));
+
+        try {
+            es.containsAll((Collection)null);
+            fail("entrySet().containsAll(null) should " +
+                 "throw a NullPointerException");
+        } catch (NullPointerException exception) {
+            // expected
+        }
+        try {
+            fs.containsAll((Collection)null);
+            fail("entrySet().containsAll(null) should " +
+                 "throw a NullPointerException");
+        } catch (NullPointerException exception) {
+            // expected
+        }
+    }
+
+    // TODO: test entrySet().clear()
+    // TODO: test entrySet().add() throws OperationNotSupported
+    // TODO: test entrySet().addAll() throws OperationNotSupported
+    // TODO: test entrySet().contains(Object)
+    // TODO: test entrySet().containsAll(Collection)
+    // TODO: test entrySet().equals(Object)
+    // TODO: test entrySet().hashCode()
+    // TODO: test entrySet().toArray()
+    // TODO: test entrySet().toArray(Object[] a)
+    // TODO: test entrySet().remove(Object)
+    // TODO: test entrySet().removeAll(Collection)
+    // TODO: test entrySet().retainAll(Collection)
+
+    /**
+     *  Tests:
+     *  <ul>
+     *  <li> Map.entrySet().iterator()
+     *  <li> Map.entrySet().iterator().hasNext()
+     *  <li> Map.entrySet().iterator().next()
+     *  </ul>
+     **/
+    public void testEntrySetIterator() {
+        Map em = makeEmptyMap();
+        Set es = em.entrySet();
+        Iterator eiter = es.iterator();
+
+        assertEquals("entrySet().iterator().hasNext() must return false " +
+                     "when then the map is empty.", 
+                     false, eiter.hasNext());
+
+        // note: we make a new map to test for this because some impls in the
+        // past have required a call to hasMoreElements before a call to next
+        // for it to work properly.  By using a new map, we make sure this test
+        // will catch those broken impls.
+        em = makeEmptyMap();
+        es = em.entrySet();
+        eiter = es.iterator();
+        
+        try {
+            eiter.next();
+            fail("entrySet().iterator().next() must throw a NoSuchElementException " +
+                 "when the map is empty");
+        } catch (NoSuchElementException exception) {
+            // expected
+        }
+
+
+        Map fm = makeFullMap();
+
+        Set fs = fm.entrySet();
+
+        Object[] keys = getSampleKeys();
+        Object[] values = getSampleValues();
+        boolean[] found = new boolean[keys.length];
+
+        Iterator iter = fs.iterator();
+
+        assertTrue("entrySet().iterator() must return a non-null " +
+                   "iterator.", iter != null);
+
+        while(iter.hasNext()) {
+            Object obj = iter.next();
+            assertTrue("Null is not allowed to be returned from the " +
+                       "entrySet().iterator()'s next().", obj != null);
+            assertTrue("Objects returned from entrySet().iterator() must be " +
+                       "instances of Map.Entry.", obj instanceof Map.Entry);
+                
+            Map.Entry entry = (Map.Entry)obj;
+            Object key = entry.getKey();
+            Object value = entry.getValue();
+
+            assertTrue("the key for an entry returned from the entry " +
+                       "set's iterator can only be null if useNullKey " +
+                       "is true.",
+                       key != null || (key == null && useNullKey()));
+            
+            assertTrue("the value for an entry returned from the entry " +
+                       "set's iterator can only be null if useNullValue " +
+                       "is true.",
+                       value != null || (value == null && useNullValue()));
+
+            for(int i = 0; i < keys.length; i++) {
+                if((key == null && keys[i] == null) ||
+                   (key != null && key.equals(keys[i]))) {
+                    assertTrue("entrySet().iterator() must not return " +
+                               "multiple entries with the same key.", 
+                               !found[i]);
+                        
+                    found[i] = true;
+
+                    assertTrue
+                        ("value of entry returned from iterator " +
+                         "must be the value for the added mapping.",
+                         (value == null && values[i] == null) ||
+                         (value != null && value.equals(values[i])));
+                }
+            }
+        }
+        for(int i = 0; i < found.length; i++) {
+            assertTrue("must find all added elements through entrySet's " +
+                       "iterator().", found[i]);
+        }
+    }
+  
+    /**
+     *  Tests Map.entrySet().iterator().remove()
+     **/
+    public void testEntrySetIteratorRemove() {
+        Map m = makeFullMap();
+        Set s = m.entrySet();
+        Iterator iter = s.iterator();
+
+        try {
+            iter.remove();
+            fail("Entry set iterator must not allow a call to remove " +
+                 "before any calls to next");
+        } catch (IllegalStateException exception) {
+            // expected exception provided add/remove modifiable
+            assertTrue("iterator should throw UnsupportedOperationException " +
+                       "if remove is not allowed from the entrySet().iterator()",
+                       isAddRemoveModifiable());
+        } catch (UnsupportedOperationException exception) {
+            assertTrue("iterator should not throw UnsupportedOperationException " +
+                       "if the map supports adding and removing elements",
+                       !isAddRemoveModifiable());
+        }
+
+        while(iter.hasNext()) {
+            Map.Entry entry = (Map.Entry)iter.next();
+            
+            assertTrue("Entry key from entry set iterator must exist in map",
+                       m.containsKey(entry.getKey()));
+            try {
+                iter.remove();
+                // note: we do not check that the mapping was actually removed
+                // from the map because some classes do not have their
+                // entrySet().iterator() backed by the map.  That test occurs
+                // below in testEntrySetIteratorRemoveCausesMapModification
+            } catch (UnsupportedOperationException exception) {
+                assertTrue("iterator should not throw UnsupportedOperationException " +
+                           "if the map supports adding and removing elements",
+                           !isAddRemoveModifiable());
+            }
+
+            try {
+                iter.remove();
+                fail("Entry set iterator must not allow two calls to " +
+                     "remove without a call to next.");
+            } catch (IllegalStateException exception) {
+                // expected exception provided add/remove modifiable
+                assertTrue("iterator should throw UnsupportedOperationException " +
+                           "if remove is not allowed from the entrySet().iterator()",
+                           isAddRemoveModifiable());
+            } catch (UnsupportedOperationException exception) {
+                assertTrue("iterator should not throw UnsupportedOperationException " +
+                           "if the map supports adding and removing elements",
+                           !isAddRemoveModifiable());
+            }
+        }
+    }
+
+    /**
+     *  Tests whether the map's entrySet() is backed by the map by making sure
+     *  a put in the map is reflected in the entrySet.  This test does nothing
+     *  if add/remove modifications are not supported.
+     **/
+    public void testEntrySetChangesWithMapPut() {
+        if(!isAddRemoveModifiable()) return;
+
+        Map m = makeEmptyMap();
+
+        // test insert reflected in entry set
+        Set s = m.entrySet();
+        addSampleMappings(m);
+        assertEquals("entrySet() must only be empty if map is empty.",
+                     m.isEmpty(), s.isEmpty());
+        assertEquals("entrySet() must adjust size when map changes.",
+                     m.size(), s.size());
+        // TODO: test set and map reflect the same contents
+    }
+
+    /**
+     *  Tests whether the map's entrySet() is backed by the map by making sure
+     *  a remove from the map is reflected in the entrySet.  This test does nothing
+     *  if add/remove modifications are not supported.
+     **/
+    public void testEntrySetChangesWithMapRemove() {
+        if(!isAddRemoveModifiable()) return;
+
+        Map m = makeFullMap();
+        Set s = m.entrySet();
+
+        Object[] keys = getSampleKeys();
+        Object[] values = getSampleValues();
+
+        for(int i = 0; i < keys.length; i++) {
+            m.remove(keys[i]);
+            assertEquals("entrySet() must only be empty if map is empty.",
+                         m.isEmpty(), s.isEmpty());
+            assertEquals("entrySet() must adjust size when map changes.",
+                         m.size(), s.size());
+            //TODO: test set and map reflect the same contents
+        }
+    }
+
+    // TODO: test entrySet() changes after Map.remove
+    // TODO: test entrySet() changes after Map.clear
+    // TODO: test entrySet() changes after Map.putAll
+
+    /**
+     *  Tests whether the map's entrySet() is backed by the map by making sure
+     *  a remove from the entrySet's iterator is reflected in the map. This
+     *  test does nothing if add/remove modifications are not supported.
+     **/
+    public void testEntrySetIteratorRemoveCausesMapModification() {
+        if(!isAddRemoveModifiable()) return;
+        
+        Map m = makeFullMap();
+        Set s = m.entrySet();
+        Iterator iter = s.iterator();
+        
+        while(iter.hasNext()) {
+            Map.Entry entry = (Map.Entry)iter.next();
+            
+            try {
+                iter.remove();
+                assertTrue("Entry key from entry set iterator must " +
+                           "no longer exist in map",
+                           !m.containsKey(entry.getKey()));
+            } catch (UnsupportedOperationException exception) {
+                // isAddRemoveModifiable is true -- we've checked that above
+                fail("iterator should not throw UnsupportedOperationException " +
+                     "if the map supports adding and removing elements");
+            }
+        }
+    }
+
+    // TODO: test map changes after entrySet().remove
+    // TODO: test map changes after entrySet().removeAll
+    // TODO: test map changes after entrySet().retainAll
+
     public void testMapEquals() {
         // XXX finish me
     }
@@ -123,14 +798,206 @@ public abstract class TestMap extends TestObject {
         // XXX finish me
     }
 
-    public void testMapIsEmpty() {
+    public void testMapKeySet() {
         // XXX finish me
     }
+    
+    //-------TEST AGAINST OPTIONAL OPERATIONS, ENABLE IN TEST SUBCLASSES
 
-    public void testMapKeySet() {
-        // XXX finish me
+    public void testMapSupportsNullValues() {
+
+        if ((this instanceof TestMap.SupportsPut) == false) {
+            return;
+        }
+
+        Map map = makeEmptyMap();
+        map.put(new Integer(1),"foo");
+        
+        assertTrue("no null values in Map",map.containsValue(null) == false);
+
+        map.put(new Integer(2),null);
+
+        assertTrue("null value in Map",map.containsValue(null));
+        assertTrue("key to a null value",map.containsKey(new Integer(2)));
+    }
+
+    public void testMultiplePuts() {
+
+        if ((this instanceof TestMap.SupportsPut) == false) {
+            return;
+        }
+
+        Map map = makeEmptyMap();
+        map.put(new Integer(4),"foo");
+        map.put(new Integer(4),"bar");
+        map.put(new Integer(4),"foo");
+        map.put(new Integer(4),"bar");
+
+        assertTrue("same key different value",map.get(new Integer(4)).equals("bar"));
+    }
+
+
+    public void testCapacity() {
+
+        if ((this instanceof TestMap.SupportsPut) == false) {
+            return;
+        }
+
+        Map map = makeEmptyMap();
+        map.put(new Integer(1),"foo");
+        map.put(new Integer(2),"foo");
+        map.put(new Integer(3),"foo");
+        map.put(new Integer(1),"foo");
+        
+        assertTrue("size of Map should be 3, but was " + map.size(), map.size() == 3);
+    }
+
+    public void testEntrySetRemove() {
+
+        if ((this instanceof TestMap.EntrySetSupportsRemove) == false ||
+            (this instanceof TestMap.SupportsPut) == false) {
+            return;
+        }
+
+        Map map = makeEmptyMap();
+        map.put("1","1");
+        map.put("2","2");
+        map.put("3","3");
+
+        Object o = map.entrySet().iterator().next();
+        // remove one of the key/value pairs
+        Set set = map.entrySet();
+        set.remove(o);
+        assertTrue(set.size() == 2);
+        // try to remove it again, to make sure 
+        // the Set is not confused by missing entries
+        set.remove(o);
+
+        assertTrue("size of Map should be 2, but was " + map.size(), map.size() == 2);
+
+    }
+
+    public void testEntrySetContains() {
+
+        if ((this instanceof TestMap.SupportsPut) == false) {
+            return;
+        }
+
+        Map map = makeEmptyMap();
+        map.put("1","1");
+        map.put("2","2");
+        map.put("3","3");
+
+        Set set = map.entrySet();
+        Object o = set.iterator().next();
+        assertTrue("entry set should contain valid element",set.contains(o));
+
+        // create a fresh entry mapped to existing values
+        DefaultMapEntry goodEntry  = new DefaultMapEntry("2","2");
+        assertTrue("entry set should recognize externally constructed MapEntry objects",
+                   set.contains(goodEntry));
+
+        // make a bogus entry
+        DefaultMapEntry badEntry = new DefaultMapEntry("4","4");
+        assertTrue("entry set should not contain a bogus element",
+                   set.contains(badEntry) == false);
+        
+
+    }
+
+    public void testEmptyMapSerialization() 
+    throws IOException, ClassNotFoundException {
+        Map map = makeEmptyMap();
+        if (!(map instanceof Serializable)) return;
+        
+        byte[] objekt = writeExternalFormToBytes((Serializable) map);
+        Map map2 = (Map) readExternalFormFromBytes(objekt);
+
+        assertTrue("Both maps are empty",map.isEmpty()  == true);
+        assertTrue("Both maps are empty",map2.isEmpty() == true);
     }
 
+    public void testFullMapSerialization() 
+    throws IOException, ClassNotFoundException {
+        Map map = makeFullMap();
+        if (!(map instanceof Serializable)) return;
+        
+        byte[] objekt = writeExternalFormToBytes((Serializable) map);
+        Map map2 = (Map) readExternalFormFromBytes(objekt);
+
+        assertEquals("Both maps are same size",map.size(), getSampleKeys().length);
+        assertEquals("Both maps are same size",map2.size(),getSampleKeys().length);
+    }
+
+
+    public String getCanonicalEmptyMapName(Map map) {
+        StringBuffer retval = new StringBuffer();
+        retval.append("data/test/");
+        String mapName = map.getClass().getName();
+        mapName = mapName.substring(mapName.lastIndexOf(".")+1,mapName.length());
+        retval.append(mapName);
+        retval.append(".emptyMap.version");
+        retval.append(getCompatibilityVersion());
+        retval.append(".obj");
+        return retval.toString();
+    }
+
+    public String getCanonicalFullMapName(Map map) {
+        StringBuffer retval = new StringBuffer();
+        retval.append("data/test/");
+        String mapName = map.getClass().getName();
+        mapName = mapName.substring(mapName.lastIndexOf(".")+1,mapName.length());
+        retval.append(mapName);
+        retval.append(".fullMap.version");
+        retval.append(getCompatibilityVersion());
+        retval.append(".obj");
+        return retval.toString();
+    }
+
+    /**
+     * Compare the current serialized form of the Map
+     * against the canonical version in CVS.
+     */
+    public void testEmptyMapCompatibility() throws IOException, ClassNotFoundException {
+        /**
+         * Create canonical objects with this code
+        Map map = makeEmptyMap();
+        if (!(map instanceof Serializable)) return;
+        
+        writeExternalFormToDisk((Serializable) map, getCanonicalEmptyMapName(map));
+        */
+
+        // test to make sure the canonical form has been preserved
+        if (!(makeEmptyMap() instanceof Serializable)) return;
+        Map map = (Map) readExternalFormFromDisk(getCanonicalEmptyMapName(makeEmptyMap()));
+        assertTrue("Map is empty",map.isEmpty()  == true);
+    }
+
+        /**
+     * Compare the current serialized form of the Map
+     * against the canonical version in CVS.
+     */
+    public void testFullMapCompatibility() throws IOException, ClassNotFoundException {
+        /**
+         * Create canonical objects with this code
+        Map map = makeFullMap();
+        if (!(map instanceof Serializable)) return;
+        
+        writeExternalFormToDisk((Serializable) map, getCanonicalFullMapName(map));
+        */
+
+        // test to make sure the canonical form has been preserved
+        if (!(makeFullMap() instanceof Serializable)) return;
+        Map map = (Map) readExternalFormFromDisk(getCanonicalFullMapName(makeFullMap()));
+        assertEquals("Map is the right size",map.size(), getSampleKeys().length);
+    }
+
+    /*
+        // optional operation
+public void testMapClear() {
+    // XXX finish me
+}
+
     // optional operation
     public void testMapPut() {
         // XXX finish me
@@ -146,38 +1013,20 @@ public abstract class TestMap extends TestObject {
         // XXX finish me
     }
 
-    public void testMapSize() {
-        // XXX finish me
-    }
-
     public void testMapValues() {
         // XXX finish me
     }
 
-    */
-
     /**
-     * Try to put the given pair into the given Collection.
-     *
-     * Fails any Throwable except UnsupportedOperationException,
-     * ClassCastException, or IllegalArgumentException
-     * or NullPointerException is thrown.
+     * Marker interface, indicating that a TestMap subclass
+     * can test put(Object,Object) operations.
      */
-    protected Object tryToPut(Map map, Object key, Object val) {
-        try {
-            return map.put(key,val);
-        } catch(UnsupportedOperationException e) {
-            return null;
-        } catch(ClassCastException e) {
-            return null;
-        } catch(IllegalArgumentException e) {
-            return null;
-        } catch(NullPointerException e) {
-            return null;
-        } catch(Throwable t) {
-            t.printStackTrace();
-            fail("Map.put should only throw UnsupportedOperationException, ClassCastException, IllegalArgumentException or NullPointerException. Found " + t.toString());
-            return null; // never get here, since fail throws exception
-        }
+    public interface SupportsPut {
+
+    }
+
+    public interface EntrySetSupportsRemove {
+
     }
+
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestMultiHashMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestMultiHashMap.java b/src/test/org/apache/commons/collections/TestMultiHashMap.java
index d296bc2..bc7ed85 100644
--- a/src/test/org/apache/commons/collections/TestMultiHashMap.java
+++ b/src/test/org/apache/commons/collections/TestMultiHashMap.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestMultiHashMap.java,v 1.1 2001/09/18 10:41:39 jstrachan Exp $
- * $Revision: 1.1 $
- * $Date: 2001/09/18 10:41:39 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestMultiHashMap.java,v 1.1.2.1 2002/02/26 00:51:21 morgand Exp $
+ * $Revision: 1.1.2.1 $
+ * $Date: 2002/02/26 00:51:21 $
  *
  * ====================================================================
  *
@@ -90,7 +90,7 @@ public class TestMultiHashMap extends TestMap
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    public Map makeMap() {
+    public Map makeEmptyMap() {
         return new MultiHashMap();
     }
     

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestObject.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestObject.java b/src/test/org/apache/commons/collections/TestObject.java
index 9d23a6b..fa97171 100644
--- a/src/test/org/apache/commons/collections/TestObject.java
+++ b/src/test/org/apache/commons/collections/TestObject.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestObject.java,v 1.1 2001/04/20 16:54:03 rwaldhoff Exp $
- * $Revision: 1.1 $
- * $Date: 2001/04/20 16:54:03 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/Attic/TestObject.java,v 1.1.2.1 2002/02/26 00:48:14 morgand Exp $
+ * $Revision: 1.1.2.1 $
+ * $Date: 2002/02/26 00:48:14 $
  *
  * ====================================================================
  *
@@ -62,6 +62,18 @@
 package org.apache.commons.collections;
 
 import junit.framework.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.io.Serializable;
+
 import java.util.Collection;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -71,20 +83,39 @@ import java.util.NoSuchElementException;
  * Tests base {@link java.util.Object} methods and contracts.
  * <p>
  * To use, simply extend this class, and implement
- * the {@link #makeObject} method.
+ * the {@link #makeObject()} method.
  * <p>
  * If your {@link Object} fails one of these tests by design,
  * you may still use this base set of cases.  Simply override the
  * test case (method) your {@link Object} fails.
  *
  * @author Rodney Waldhoff
- * @version $Id: TestObject.java,v 1.1 2001/04/20 16:54:03 rwaldhoff Exp $
+ * @version $Id: TestObject.java,v 1.1.2.1 2002/02/26 00:48:14 morgand Exp $
  */
 public abstract class TestObject extends TestCase {
     public TestObject(String testName) {
         super(testName);
     }
 
+    // current major release for Collections
+    public static final int COLLECTIONS_MAJOR_VERSION = 2;
+
+    /**
+     * This constant makes it possible for TestMap (and other subclasses,
+     * if necessary) to automatically check CVS for a versionX copy of a
+     * Serialized object, so we can make sure that compatibility is maintained.
+     * See, for example, TestMap.getCanonicalFullMapName(Map map).
+     * Subclasses can override this variable, indicating compatibility
+     * with earlier Collections versions.
+     * Defaults to 1, the earliest Collections version.  (Note: some
+     * collections did not even exist in this version).
+     * 
+     * @return 1
+     */
+    public int getCompatibilityVersion() {
+        return 1;
+    }
+
     /**
      * Return a new, empty {@link Object} to used for testing.
      */
@@ -108,6 +139,100 @@ public abstract class TestObject extends TestCase {
         Object obj2 = makeObject();
         if(obj1.equals(obj2)) {
             assertEquals("[2] When two objects are equal, their hashCodes should be also.",obj1.hashCode(),obj2.hashCode());
+            assertTrue("When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true", obj2.equals(obj1));
+        }
+    }
+
+    private void writeExternalFormToStream(Serializable o, OutputStream stream) 
+    throws IOException {
+        ObjectOutputStream oStream = new ObjectOutputStream(stream);
+        oStream.writeObject(o);
+    }
+
+    /**
+     * Write a Serializable or Externalizable object as
+     * a file at the given path.  NOT USEFUL as part
+     * of a unit test; this is just a utility method
+     * for creating disk-based objects in CVS that can become
+     * the basis for compatibility tests using
+     * readExternalFormFromDisk(String path)
+     * 
+     * @param o Object to serialize
+     * @param path path to write the serialized Object
+     * @exception IOException
+     */
+    protected void writeExternalFormToDisk(Serializable o, String path) 
+    throws IOException {
+        FileOutputStream fileStream = new FileOutputStream(path);
+        writeExternalFormToStream(o,fileStream);
+    }
+
+    /**
+     * Converts a Serializable or Externalizable object to
+     * bytes.  Useful for in-memory tests of serialization
+     * 
+     * @param o Object to convert to bytes
+     * @return serialized form of the Object
+     * @exception IOException
+     */
+    protected byte[] writeExternalFormToBytes(Serializable o) 
+    throws IOException {
+        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+        writeExternalFormToStream(o,byteStream);
+        return byteStream.toByteArray();
+    }
+
+    private Object readExternalFormFromStream(InputStream stream) 
+    throws IOException, ClassNotFoundException {
+        ObjectInputStream oStream = new ObjectInputStream(stream);
+        return oStream.readObject();
+    }
+
+    /**
+     * Reads a Serialized or Externalized Object from disk.
+     * Useful for creating compatibility tests betweeen
+     * different CVS versions of the same class
+     * 
+     * @param path path to the serialized Object
+     * @return the Object at the given path
+     * @exception IOException
+     * @exception ClassNotFoundException
+     */
+    protected Object readExternalFormFromDisk(String path) 
+    throws IOException, ClassNotFoundException {
+        FileInputStream stream = new FileInputStream(path);
+        return readExternalFormFromStream(stream);
+    }
+
+    /**
+     * Read a Serialized or Externalized Object from bytes.
+     * Useful for verifying serialization in memory.
+     * 
+     * @param b byte array containing a serialized Object
+     * @return Object contained in the bytes
+     * @exception IOException
+     * @exception ClassNotFoundException
+     */
+    protected Object readExternalFormFromBytes(byte[] b) 
+    throws IOException, ClassNotFoundException {
+        ByteArrayInputStream stream = new ByteArrayInputStream(b);
+        return readExternalFormFromStream(stream);
+    }
+
+    /**
+     * Sanity check method, makes sure that any Serializable
+     * class can be serialized and de-serialized in memory, 
+     * using the handy makeObject() method
+     * 
+     * @exception IOException
+     * @exception ClassNotFoundException
+     */
+    public void testSimpleSerialization() 
+    throws IOException, ClassNotFoundException {
+        Object o = makeObject();
+        if (o instanceof Serializable) {
+            byte[] objekt = writeExternalFormToBytes((Serializable) o);
+            Object p = readExternalFormFromBytes(objekt);
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-collections/blob/6a2c9bff/src/test/org/apache/commons/collections/TestTreeMap.java
----------------------------------------------------------------------
diff --git a/src/test/org/apache/commons/collections/TestTreeMap.java b/src/test/org/apache/commons/collections/TestTreeMap.java
index b3f07ac..ab8d6bf 100644
--- a/src/test/org/apache/commons/collections/TestTreeMap.java
+++ b/src/test/org/apache/commons/collections/TestTreeMap.java
@@ -1,7 +1,7 @@
 /*
- * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestTreeMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
- * $Revision: 1.2 $
- * $Date: 2001/07/14 23:33:27 $
+ * $Header: /home/jerenkrantz/tmp/commons/commons-convert/cvs/home/cvs/jakarta-commons//collections/src/test/org/apache/commons/collections/TestTreeMap.java,v 1.2.2.1 2002/02/26 00:51:21 morgand Exp $
+ * $Revision: 1.2.2.1 $
+ * $Date: 2002/02/26 00:51:21 $
  *
  * ====================================================================
  *
@@ -69,7 +69,7 @@ import java.util.Map;
 
 /**
  * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
- * @version $Id: TestTreeMap.java,v 1.2 2001/07/14 23:33:27 craigmcc Exp $
+ * @version $Id: TestTreeMap.java,v 1.2.2.1 2002/02/26 00:51:21 morgand Exp $
  */
 public class TestTreeMap extends TestMap
 {
@@ -89,7 +89,7 @@ public class TestTreeMap extends TestMap
         junit.textui.TestRunner.main(testCaseName);
     }
 
-    public Map makeMap() {
+    public Map makeEmptyMap() {
         TreeMap tm = new TreeMap();
         return (tm);
     }
@@ -98,7 +98,7 @@ public class TestTreeMap extends TestMap
 
     public void setUp()
     {
-        map = (TreeMap) makeMap();
+        map = (TreeMap) makeEmptyMap();
     }
 
     public void testNewMap()


Mime
View raw message