commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject cvs commit: jakarta-commons/collections/src/test/org/apache/commons/collections TestDoubleOrderedMap.java TestLRUMap.java TestMap.java TestMultiHashMap.java
Date Tue, 28 May 2002 06:51:03 GMT
mas         02/05/27 23:51:03

  Modified:    collections/src/test/org/apache/commons/collections
                        TestDoubleOrderedMap.java TestLRUMap.java
                        TestMap.java TestMultiHashMap.java
  Log:
  Added new testing code submitted by Paul Jack < pjack at sfaf dot org >
  
  Revision  Changes    Path
  1.4       +14 -3     jakarta-commons/collections/src/test/org/apache/commons/collections/TestDoubleOrderedMap.java
  
  Index: TestDoubleOrderedMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestDoubleOrderedMap.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- TestDoubleOrderedMap.java	22 Feb 2002 02:18:50 -0000	1.3
  +++ TestDoubleOrderedMap.java	28 May 2002 06:51:03 -0000	1.4
  @@ -1,7 +1,7 @@
   /*
  - * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestDoubleOrderedMap.java,v
1.3 2002/02/22 02:18:50 mas Exp $
  - * $Revision: 1.3 $
  - * $Date: 2002/02/22 02:18:50 $
  + * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestDoubleOrderedMap.java,v
1.4 2002/05/28 06:51:03 mas Exp $
  + * $Revision: 1.4 $
  + * $Date: 2002/05/28 06:51:03 $
    *
    * ====================================================================
    *
  @@ -2827,5 +2827,16 @@
        */
       public static void main(final String unusedArgs[]) {
           junit.textui.TestRunner.run(TestDoubleOrderedMap.class);
  +    }
  +
  +    /**
  +     *  Override the Map.put() test because it tries put with the same key
  +     *  which is invalid in the modified double ordered map contract. (The
  +     *  DoubleOrderedMap documentation states that an IllegalArgumentException
  +     *  is thrown when a key is tried to be put into the map again.  This
  +     *  differs from the standard Map contract which would replace the value
  +     *  for that key and return it.
  +     **/
  +    public void testMapPut() {
       }
   }
  
  
  
  1.21      +12 -4     jakarta-commons/collections/src/test/org/apache/commons/collections/TestLRUMap.java
  
  Index: TestLRUMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestLRUMap.java,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- TestLRUMap.java	9 May 2002 03:20:59 -0000	1.20
  +++ TestLRUMap.java	28 May 2002 06:51:03 -0000	1.21
  @@ -1,7 +1,7 @@
   /*
  - * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestLRUMap.java,v
1.20 2002/05/09 03:20:59 mas Exp $
  - * $Revision: 1.20 $
  - * $Date: 2002/05/09 03:20:59 $
  + * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestLRUMap.java,v
1.21 2002/05/28 06:51:03 mas Exp $
  + * $Revision: 1.21 $
  + * $Date: 2002/05/28 06:51:03 $
    *
    * ====================================================================
    *
  @@ -68,12 +68,13 @@
   import java.util.Iterator;
   import java.util.Map;
   import java.util.HashMap;
  +import java.util.Set;
   
   /**
    * 
    * @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.20 2002/05/09 03:20:59 mas Exp $
  + * @version $Id: TestLRUMap.java,v 1.21 2002/05/28 06:51:03 mas Exp $
    */
   public class TestLRUMap extends TestSequencedHashMap
   {
  @@ -219,6 +220,13 @@
   
           assertTrue("oldest key is '4'",counter.get(0).equals("4"));
           assertTrue("newest key is '2'",counter.get(1).equals("2"));
  +    }
  +
  +
  +    protected void entrySetEqualsMap(Set set, Map m) {
  +        // Overridden because LRUMap.get(Object) actually alters the map,
  +        // so there's no way to verify that the entry set and map contain
  +        // the same entries
       }
   
       private class LRUCounter extends LRUMap {
  
  
  
  1.16      +501 -49   jakarta-commons/collections/src/test/org/apache/commons/collections/TestMap.java
  
  Index: TestMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMap.java,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- TestMap.java	8 May 2002 17:54:28 -0000	1.15
  +++ TestMap.java	28 May 2002 06:51:03 -0000	1.16
  @@ -1,7 +1,7 @@
   /*
  - * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMap.java,v
1.15 2002/05/08 17:54:28 morgand Exp $
  - * $Revision: 1.15 $
  - * $Date: 2002/05/08 17:54:28 $
  + * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMap.java,v
1.16 2002/05/28 06:51:03 mas Exp $
  + * $Revision: 1.16 $
  + * $Date: 2002/05/28 06:51:03 $
    *
    * ====================================================================
    *
  @@ -64,12 +64,16 @@
   import junit.framework.*;
   import java.io.IOException;
   import java.io.Serializable;
  +import java.util.ArrayList;
  +import java.util.Arrays;
   import java.util.Collection;
   import java.util.ConcurrentModificationException;
   import java.util.Map;
   import java.util.Collection;
  +import java.util.Collections;
   import java.util.Set;
   import java.util.Iterator;
  +import java.util.HashMap;
   import java.util.HashSet;
   import java.util.NoSuchElementException;
   
  @@ -88,7 +92,7 @@
    *
    * @author Michael Smith
    * @author Rodney Waldhoff
  - * @version $Id: TestMap.java,v 1.15 2002/05/08 17:54:28 morgand Exp $
  + * @version $Id: TestMap.java,v 1.16 2002/05/28 06:51:03 mas Exp $
    */
   public abstract class TestMap extends TestObject {
   
  @@ -462,8 +466,8 @@
           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]));
  +            assertTrue("Map must contain key for a mapping in the map. " +
  +		       "Missing: " + keys[i], fm.containsKey(keys[i]));
           }
       }
   
  @@ -564,18 +568,227 @@
           }
       }
   
  -    // 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 Map.entrySet().clear() using Map.isEmpty() and
  +     *  Map.entrySet().isEmpty().  
  +     **/
  +    public void testEntrySetClear() {
  +        if (!isAddRemoveModifiable()) return;
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +        set.clear();
  +        assertTrue("entrySet should be empty after clear", set.isEmpty());
  +        assertTrue("map should be empty after entrySet.clear()", m.isEmpty());
  +    }
  +
  +
  +    /**
  +     *  Tests Map.entrySet().add(Object);
  +     **/
  +    public void testEntrySetAdd() {
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +        try {
  +            set.add(new Object());
  +            fail("entrySet().add should raise UnsupportedOperationException");
  +        } catch (UnsupportedOperationException e) {
  +            // expected
  +        }
  +    }
  +
  +
  +    /**
  +     *  Tests Map.entrySet().addAll(Collection);
  +     **/
  +    public void testEntrySetAddAll() {
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +        try {
  +            set.addAll(java.util.Collections.singleton(new Object()));
  +            fail("entrySet().addAll(Collection) should raise " +
  +		 "UnsupportedOperationException");
  +        } catch (UnsupportedOperationException e) {
  +            // expected
  +        }
  +    }
  +
  +    /**
  +     *  Tests Map.entrySetContainsAll(Collection)
  +     **/
  +    public void testEntrySetContainsAll() {
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +
  +        java.util.ArrayList list = new java.util.ArrayList();
  +        Iterator iterator = set.iterator();
  +        while (iterator.hasNext()) {
  +            Map.Entry entry = (Map.Entry)iterator.next();
  +            list.add(new DefaultMapEntry(entry.getKey(), entry.getValue()));
  +
  +	    assertTrue("entrySet().containsAll failed", set.containsAll(list));
  +        }
  +
  +        list.add(new Object());
  +        assertTrue("entrySet().containsAll failed", !set.containsAll(list));
  +    }
  +
  +
  +    /**
  +     *  Tests entrySet().equals(Object)
  +     **/
  +    public void testEntrySetEquals() {
  +        Map m = makeFullMap();
  +        Map m2 = new HashMap(m);
  +        assertTrue("Equal maps should have equal entrySets", 
  +		   m.entrySet().equals(m2.entrySet()));
  +
  +        assertTrue("entrySet.equals(null) returned true", 
  +		   !m.entrySet().equals(null));
  +        assertTrue("Unequal maps should have unequal entrySets", 
  +		   !m.entrySet().equals(Collections.EMPTY_SET));
  +    }
  +
  +
  +    /**
  +     *  Test entrySet().hashCde()
  +     **/
  +    public void testEntrySetHashCode() {
  +        Map m = makeFullMap();
  +        Map m2 = new HashMap(m);
  +        Set set = m.entrySet();
  +        Set set2 = m2.entrySet();
  +        assertTrue("hashCode of equal entrySets should be same", 
  +		   set.hashCode() == set2.hashCode());
  +    }
  +
  +
  +    /**
  +     *  Test entrySet().toArray() and entrySet().toArray(Object[])
  +     **/
  +    public void testEntrySetToArray() {
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +        Object[] a = set.toArray();
  +        assertTrue("entrySet.toArray() should be same size as map", 
  +		   a.length == m.size());
  +
  +        a = set.toArray(new Object[0]);
  +        assertTrue("entrySet.toArray(new Object[0]) should be same size " +
  +		   "as map", a.length == m.size());
  +
  +        a = new Object[m.size() * 2];
  +        a[m.size()] = new Object();
  +        a = set.toArray(a);
  +        assertTrue("entrySet.toArray(new Object[m.size * 2]) should set " +
  +		   "last element to null", a[m.size()] == null);
  +
  +        a = set.toArray(new Map.Entry[0]);
  +        assertTrue("entrySet.toArray(new Map.Entry[0]) should return " +
  +		   "instanceof Map.Entry[]", a instanceof Map.Entry[]);
  +
  +        try {
  +            a = set.toArray(new String[0]);
  +            fail("entrySet.toArray(new String[]) should raise " +
  +		 "ArrayStoreException.");
  +        } catch (ArrayStoreException e) {
  +            // expected
  +        }
  +        
  +    }
  +
  +    /**
  +     *  Tests entrySet().remove(Object)
  +     **/
  +    public void testEntrySetRemove2() {
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +
  +        boolean r = set.remove(null);
  +        assertTrue("entrySet.remove(null) should return false", !r);
  +
  +        r = set.remove("Not a Map.Entry");
  +        assertTrue("entrySet.remove should return false for non-Map.Entry", 
  +		   !r);
  +
  +	m = makeEmptyMap();
  +	set = m.entrySet();
  +
  +	Object[] keys = getSampleKeys();
  +	Object[] values = getSampleValues();
  +
  +	for(int i = 0; i < keys.length; i++) {
  +	    // remove on all elements should return false because the map is
  +	    // empty.
  +	    r = set.remove(new DefaultMapEntry(keys[i], values[i]));
  +	    assertTrue("entrySet.remove for nonexistent entry should " +
  +		       "return false", !r);
  +	}
  +
  +	// reset to full map to check actual removes
  +	m = makeFullMap();
  +	set = m.entrySet();
  +
  +        int size = m.size();
  +        Map.Entry entry = (Map.Entry)set.iterator().next();
  +        r = set.remove(entry);
  +        assertTrue("entrySet.remove for internal entry should return true", r);
  +        assertTrue("entrySet.size should shrink after successful remove", 
  +		   set.size() == size - 1);
  +        assertTrue("map size should shrink after succuessful entrySet.remove", 
  +		   m.size() == size - 1);
  +        entrySetEqualsMap(set, m);
  +
  +        size--;
  +        entry = (Map.Entry)set.iterator().next();
  +        entry = new DefaultMapEntry(entry.getKey(), entry.getValue());
  +        r = set.remove(entry);
  +        assertTrue("entrySet.remove for external entry should return true", r);
  +        assertTrue("entrySet.size should shrink after successful remove", 
  +		   set.size() == size - 1);
  +        assertTrue("map size should shrink after succuessful entrySet.remove",
  +		   m.size() == size - 1);
  +        assertTrue("After remove, entrySet should not contain element", 
  +		   !set.contains(entry));
  +        entrySetEqualsMap(set, m);
  +        r = set.remove(entry);
  +        assertTrue("second entrySet.remove should return false", !r);
  +    }
  +
  +
  +    /**
  +     *  Tests entrySet().removeAll() and entrySet().retainAll()
  +     **/
  +    public void testEntrySetBulkRemoveOperations() {
  +	if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeFullMap();
  +        Set set = m.entrySet();
  +        Map m2 = new HashMap(m);
  +        Set set2 = m2.entrySet();
  +
  +        Object[] entries = set2.toArray();
  +        Collection c = Arrays.asList(entries).subList(2, 5);
  +        boolean r = set.removeAll(c);
  +        set2.removeAll(c);
  +        assertTrue("entrySet().removeAll() returned false", r);
  +        assertTrue("entrySet().removeAll() failed", m2.equals(m));
  +        assertTrue("entrySet().removeAll() returned true", !set.removeAll(c));
  +
  +        m = makeFullMap();
  +        set = m.entrySet();
  +        m2 = new HashMap(m);
  +        set2 = m2.entrySet();
  +        entries = set2.toArray();
  +        c = Arrays.asList(entries).subList(2, 5);
  +        r = set.retainAll(c);
  +        set2.retainAll(c);
  +        assertTrue("entrySet().retainAll returned false", r);
  +        assertTrue("entrySet().retainAll() failed", m2.equals(m));
  +        assertTrue("entrySet().retainAll returned true", !set.retainAll(c));
  +    }
  +
   
       /**
        *  Tests:
  @@ -693,9 +906,9 @@
   
           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()));
  +
  +            assertTrue("Entry key from entry set iterator must exist in map: " +
  +		       entry, m.containsKey(entry.getKey()));
               try {
                   iter.remove();
                   // note: we do not check that the mapping was actually removed
  @@ -726,6 +939,25 @@
       }
   
       /**
  +     *  utility method to ensure that a set of Map.Entry objects matches those
  +     *  found in the specified map.
  +     **/
  +    protected void entrySetEqualsMap(Set set, Map m) {
  +        Iterator iterator = set.iterator();
  +        while (iterator.hasNext()) {
  +            Map.Entry entry = (Map.Entry)iterator.next();
  +            Object key = entry.getKey();
  +            Object value = entry.getValue();
  +            assertTrue("map should contain key found in entrySet", 
  +		       m.containsKey(key));
  +            Object v2 = m.get(key);
  +            assertTrue("map should contain entry found in entrySet", 
  +		       (value == null) ? v2 == null : value.equals(v2));
  +        }
  +    }
  +
  +
  +    /**
        *  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.
  @@ -742,13 +974,14 @@
                        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
  +
  +        entrySetEqualsMap(s, m);
       }
   
       /**
        *  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.
  +     *  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;
  @@ -765,13 +998,46 @@
                            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
  +            entrySetEqualsMap(s, m);
           }
       }
   
  -    // 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 clear on the map is reflected in the entrySet.  This test does
  +     *  nothing if add/remove modifications are not supported.
  +     **/
  +    public void testEntrySetChangesWithMapClear() {
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeFullMap();
  +        Set s = m.entrySet();
  +        m.clear();
  +        assertTrue("entrySet() must be empty after map.clear()", s.isEmpty());
  +    }
  +
  +
  +    /**
  +     *  Tests whether the map's entrySet() is backed by the map by making sure
  +     *  a putAll on the map is reflected in the entrySet.  This test does
  +     *  nothing if add/remove modifications are not supported.
  +     **/
  +    public void testEntrySetChangesWithMapPutAll() {
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeFullMap();
  +        Set s = m.entrySet();
  +
  +        Map m2 = new HashMap();
  +        m2.put("1", "One");
  +        m2.put("2", "Two");
  +        m2.put("3", "Three");
  +
  +        m.putAll(m2);
  +        entrySetEqualsMap(s, m);
  +    }
  +
   
       /**
        *  Tests whether the map's entrySet() is backed by the map by making sure
  @@ -801,24 +1067,89 @@
           }
       }
   
  -    // TODO: test map changes after entrySet().remove
  -    // TODO: test map changes after entrySet().removeAll
  -    // TODO: test map changes after entrySet().retainAll
  -
  +    /**
  +     *  Tests Map.equals(Object)
  +     **/
       public void testMapEquals() {
  -        // XXX finish me
  +        Map m = makeEmptyMap();
  +        assertTrue("Empty maps unequal.", m.equals(new HashMap()));
  +
  +        m = makeFullMap();
  +        Map m2 = new HashMap();
  +        m2.putAll(m);
  +        assertTrue("Full maps unequal.", m.equals(m2));
  +
  +	// modify the HashMap created from the full map and make sure this
  +	// change results in map.equals() to return false.
  +        Iterator iter = m2.keySet().iterator();
  +        iter.next();
  +        iter.remove();
  +        assertTrue("Different maps equal.", !m.equals(m2));
  +
  +        assertTrue("equals(null) returned true.", !m.equals(null));
  +        assertTrue("equals(new Object()) returned true.", 
  +		   !m.equals(new Object()));
       }
   
  +    /**
  +     *  Tests Map.get(Object)
  +     **/
       public void testMapGet() {
  -        // XXX finish me
  +        Map m = makeEmptyMap();
  +
  +        Object[] keys = getSampleKeys();
  +        Object[] values = getSampleValues();
  +
  +        for (int i = 0; i < keys.length; i++) {
  +            assertTrue("Empty map.get() should return null.", 
  +		       m.get(keys[i]) == null);
  +        }
  +
  +        m = makeFullMap();
  +        for (int i = 0; i < keys.length; i++) {
  +	    assertEquals("Full map.get() should return value from mapping.", 
  +			 values[i], m.get(keys[i]));
  +        }
       }
   
  +    /**
  +     *  Tests Map.hashCode()
  +     **/
       public void testMapHashCode() {
  -        // XXX finish me
  +        Map m = makeEmptyMap();
  +	Map m2 = new HashMap();
  +        assertTrue("Empty maps have different hashCodes.", 
  +		   m.hashCode() == m2.hashCode());
  +
  +        m = makeFullMap();
  +        m2.putAll(m);
  +        assertTrue("Equal maps have different hashCodes.", 
  +		   m.hashCode() == m2.hashCode());
  +    }
  +
  +    /**
  +     *  Tests Map.toString().  Since the format of the string returned by the
  +     *  toString() method is not defined in the Map interface, there is no
  +     *  common way to test the results of the toString() method.  Thereforce,
  +     *  it is encouraged that Map implementations override this test with one
  +     *  that checks the format matches any format defined in its API.  This
  +     *  default implementation just verifies that the toString() method does
  +     *  not return null.
  +     **/
  +    public void testMapToString() {
  +        Map m = makeEmptyMap();
  +        String s = m.toString();
  +        assertTrue("Empty map toString() should not return null", s != null);
       }
   
  +    /**
  +     *  Tests Map.keySet()
  +     **/
       public void testMapKeySet() {
  -        // XXX finish me
  +        Map m = makeFullMap();
  +        Map m2 = new HashMap(m);
  +        assertTrue("Equal maps have unequal keySets.", 
  +		   m.keySet().equals(m2.keySet()));
       }
       
       //-------TEST AGAINST OPTIONAL OPERATIONS, ENABLE IN TEST SUBCLASSES
  @@ -986,29 +1317,150 @@
           assertEquals("Map is the right size",map.size(), getSampleKeys().length);
       }
   
  -    /*
  -        // optional operation
  -public void testMapClear() {
  -    // XXX finish me
  -}
  -
  -    // optional operation
  +    /**
  +     *  Tests Map.put(Object, Object)
  +     **/
       public void testMapPut() {
  -        // XXX finish me
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeEmptyMap();
  +
  +	Object[] keys = getSampleKeys();
  +	Object[] values = getSampleValues();
  +	Object[] newValues = getNewSampleValues();
  +
  +	for(int i = 0; i < keys.length; i++) {
  +	    Object o = m.put(keys[i], values[i]);
  +	    assertTrue("First map.put should return null", o == null);
  +	    assertTrue("Map should contain key after put", 
  +		       m.containsKey(keys[i]));
  +	    assertTrue("Map should contain value after put", 
  +		       m.containsValue(values[i]));
  +	}
  +	
  +	for(int i = 0; i < keys.length; i++) {
  +	    Object o = m.put(keys[i], newValues[i]);
  +	    assertEquals("Second map.put should return previous value",
  +			 values[i], o);
  +	    assertTrue("Map should still contain key after put",
  +		       m.containsKey(keys[i]));
  +	    assertTrue("Map should contain new value after put",
  +		       m.containsValue(newValues[i]));
  +
  +	    // if duplicates are allowed, we're not guarunteed that the value
  +	    // no longer exists, so don't try checking that.
  +	    if(!useDuplicateValues()) {
  +		assertTrue("Map should not contain old value after second put",
  +			   !m.containsValue(values[i]));
  +	    }
  +	}
       }
   
  -    // optional operation
  +    /**
  +     *  Tests Map.putAll(Collection)
  +     **/
       public void testMapPutAll() {
  -        // XXX finish me
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeEmptyMap();
  +	Map m2 = makeFullMap();
  +
  +	m.putAll(m2);
  +
  +        assertTrue("Maps should be equal after putAll", m.equals(m2));
  +
  +	// repeat test with a different map implementation
  +
  +	m2 = new HashMap();
  +	Object[] keys = getSampleKeys();
  +	Object[] values = getSampleValues();
  +	for(int i = 0; i < keys.length; i++) {
  +	    m2.put(keys[i], values[i]);
  +	}
  +	
  +	m = makeEmptyMap();
  +	m.putAll(m2);
  +	
  +	assertTrue("Maps should be equal after putAll", m.equals(m2));
       }
   
  -    // optional operation
  +    /**
  +     *  Tests Map.remove(Object)
  +     **/
       public void testMapRemove() {
  -        // XXX finish me
  +        if (!isAddRemoveModifiable()) return;
  +
  +        Map m = makeEmptyMap();
  +	Object[] keys = getSampleKeys();
  +	for(int i = 0; i < keys.length; i++) {
  +	    Object o = m.remove(keys[i]);
  +	    assertTrue("First map.remove should return null", o == null);
  +	}
  +
  +	m = makeFullMap();
  +	int startSize = m.size();
  +
  +	Object[] values = getSampleValues();
  +
  +	for(int i = 0; i < keys.length; i++) {
  +	    Object o = m.remove(keys[i]);
  +
  +	    assertEquals("map.remove with valid key should return value",
  +			 values[i], o);
  +	    assertEquals("map.remove should reduce size by one",
  +			 (startSize - i) - 1, m.size());
  +	}
       }
   
  +    /**
  +     *  Tests Map.values()
  +     **/
       public void testMapValues() {
  -        // XXX finish me
  +        Map m = makeFullMap();
  +
  +        // since Collection.equals is reference-based, have to do
  +        // this the long way...
  +
  +	Object[] values = getSampleValues();
  +
  +	Collection c = m.values();
  +	
  +	assertEquals("values() should have same size as map", 
  +		     m.size(), c.size());
  +
  +	assertEquals("values() should have same number of sample values",
  +		     values.length, c.size());
  +
  +	boolean[] matched = new boolean[values.length];
  +
  +	Iterator iter = c.iterator();
  +	while(iter.hasNext()) {
  +	    Object o = iter.next();
  +	    boolean found = false;
  +
  +	    for(int i = 0; i < values.length; i++) {
  +		// skip values already matched
  +		if(matched[i]) continue;
  +		
  +		if((o == null && values[i] == null) ||
  +		   (o != null && o.equals(values[i]))) {
  +		    matched[i] = true;
  +		    found = true;
  +		    break;
  +		}
  +	    }
  +
  +	    if(!found) {
  +		// no match for this element
  +		fail("values() returned an unexpected value");
  +	    }
  +	}
  +
  +	for(int i = 0; i < matched.length; i++) {
  +	    if(!matched[i]) {
  +		fail("values() did not return all values from map");
  +	    }
  +	}
       }
   
       /**
  
  
  
  1.4       +25 -3     jakarta-commons/collections/src/test/org/apache/commons/collections/TestMultiHashMap.java
  
  Index: TestMultiHashMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMultiHashMap.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- TestMultiHashMap.java	26 Feb 2002 00:13:37 -0000	1.3
  +++ TestMultiHashMap.java	28 May 2002 06:51:03 -0000	1.4
  @@ -1,7 +1,7 @@
   /*
  - * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMultiHashMap.java,v
1.3 2002/02/26 00:13:37 morgand Exp $
  - * $Revision: 1.3 $
  - * $Date: 2002/02/26 00:13:37 $
  + * $Header: /home/cvs/jakarta-commons/collections/src/test/org/apache/commons/collections/TestMultiHashMap.java,v
1.4 2002/05/28 06:51:03 mas Exp $
  + * $Revision: 1.4 $
  + * $Date: 2002/05/28 06:51:03 $
    *
    * ====================================================================
    *
  @@ -242,4 +242,26 @@
           // for.
           return;
       }
  +
  +    // Next four are overriden 
  +    // because MultiHashMap values are always a collection
  +
  +    // TODO: implement the tests to ensure that Map.get(Object) returns the
  +    // appropriate collection of values
  +
  +    public void testMapGet() {
  +    }
  +
  +    public void testMapPut() {
  +    }
  +
  +    public void testMapPutAll() {
  +    }
  +
  +    public void testMapRemove() {
  +    }
  +
  +    public void testMapValues() {
  +    }
  +
   }
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message