java/util/HashtableTest.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package tests.api.java.util;

import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.TreeMap;
import java.util.Vector;

import tests.api.java.util.HashMapTest.ReusableKey;
import tests.support.Support_MapTest2;
import tests.support.Support_UnmodifiableCollectionTest;

@TestTargetClass(Hashtable.class)
public class HashtableTest extends junit.framework.TestCase {

    private Hashtable ht10;

    private Hashtable ht100;

    private Hashtable htfull;

    private Vector keyVector;

    private Vector elmVector;

    private String h10sVal;

    /**
     * @tests java.util.Hashtable#Hashtable()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Hashtable",
        args = {}
    )
    public void test_Constructor() {
        // Test for method java.util.Hashtable()
        new Support_MapTest2(new Hashtable()).runTest();

        Hashtable h = new Hashtable();

        assertEquals("Created incorrect hashtable", 0, h.size());
    }

    /**
     * @tests java.util.Hashtable#Hashtable(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Hashtable",
        args = {int.class}
    )
    public void test_ConstructorI() {
        // Test for method java.util.Hashtable(int)
        Hashtable h = new Hashtable(9);

        assertEquals("Created incorrect hashtable", 0, h.size());

        Hashtable empty = new Hashtable(0);
        assertNull("Empty hashtable access", empty.get("nothing"));
        empty.put("something", "here");
        assertTrue("cannot get element", empty.get("something") == "here");

        try {
            new Hashtable(-1);
            fail("IllegalArgumentException expected");
        } catch (IllegalArgumentException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#Hashtable(int, float)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Hashtable",
        args = {int.class, float.class}
    )
    public void test_ConstructorIF() {
        // Test for method java.util.Hashtable(int, float)
        Hashtable h = new java.util.Hashtable(10, 0.5f);
        assertEquals("Created incorrect hashtable", 0, h.size());

        Hashtable empty = new Hashtable(0, 0.75f);
        assertNull("Empty hashtable access", empty.get("nothing"));
        empty.put("something", "here");
        assertTrue("cannot get element", empty.get("something") == "here");

        try {
            new Hashtable(-1, 0.75f);
            fail("IllegalArgumentException expected");
        } catch (IllegalArgumentException e) {
            //expected
        }

        try {
            new Hashtable(0, -0.75f);
            fail("IllegalArgumentException expected");
        } catch (IllegalArgumentException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#Hashtable(java.util.Map)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Hashtable",
        args = {java.util.Map.class}
    )
    public void test_ConstructorLjava_util_Map() {
        // Test for method java.util.Hashtable(java.util.Map)
        Map map = new TreeMap();
        Object firstVal = "Gabba";
        Object secondVal = new Integer(5);
        map.put("Gah", firstVal);
        map.put("Ooga", secondVal);
        Hashtable ht = new Hashtable(map);
        assertTrue("a) Incorrect Hashtable constructed",
                ht.get("Gah") == firstVal);
        assertTrue("b) Incorrect Hashtable constructed",
                ht.get("Ooga") == secondVal);

        try {
            new Hashtable(null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#clear()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "clear",
        args = {}
    )
    public void test_clear() {
        // Test for method void java.util.Hashtable.clear()
        Hashtable h = hashtableClone(htfull);
        h.clear();
        assertEquals("Hashtable was not cleared", 0, h.size());
        Enumeration el = h.elements();
        Enumeration keys = h.keys();
        assertTrue("Hashtable improperly cleared", !el.hasMoreElements()
                && !(keys.hasMoreElements()));
    }

    /**
     * @tests java.util.Hashtable#clone()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "clone",
        args = {}
    )
    public void test_clone() {
        // Test for method java.lang.Object java.util.Hashtable.clone()

        Hashtable h = (Hashtable) htfull.clone();
        assertTrue("Clone different size than original", h.size() == htfull
                .size());

        Enumeration org = htfull.keys();
        Enumeration cpy = h.keys();

        String okey, ckey;
        while (org.hasMoreElements()) {
            assertTrue("Key comparison failed", (okey = (String) org
                    .nextElement()).equals(ckey = (String) cpy.nextElement()));
            assertTrue("Value comparison failed", ((String) htfull.get(okey))
                    .equals((String) h.get(ckey)));
        }
        assertTrue("Copy has more keys than original", !cpy.hasMoreElements());
    }

    /**
     * @tests java.util.Hashtable#contains(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "contains",
        args = {java.lang.Object.class}
    )
    public void test_containsLjava_lang_Object() {
        // Test for method boolean
        // java.util.Hashtable.contains(java.lang.Object)
        assertTrue("Element not found", ht10.contains("Val 7"));
        assertTrue("Invalid element found", !ht10.contains("ZZZZZZZZZZZZZZZZ"));

        try {
            ht10.contains(null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#containsKey(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "containsKey",
        args = {java.lang.Object.class}
    )
    public void test_containsKeyLjava_lang_Object() {
        // Test for method boolean
        // java.util.Hashtable.containsKey(java.lang.Object)

        assertTrue("Failed to find key", htfull.containsKey("FKey 4"));
        assertTrue("Failed to find key", !htfull.containsKey("FKey 99"));

        try {
            htfull.containsKey(null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#containsValue(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "containsValue",
        args = {java.lang.Object.class}
    )
    public void test_containsValueLjava_lang_Object() {
        // Test for method boolean
        // java.util.Hashtable.containsValue(java.lang.Object)
        Enumeration e = elmVector.elements();
        while (e.hasMoreElements())
            assertTrue("Returned false for valid value", ht10.containsValue(e
                    .nextElement()));
        assertTrue("Returned true for invalid value", !ht10
                .containsValue(new Object()));

        try {
            ht10.containsValue(null);
            fail("NullPointerException expected");
        } catch (NullPointerException ee) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#elements()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "elements",
        args = {}
    )
    public void test_elements() {
        // Test for method java.util.Enumeration java.util.Hashtable.elements()
        Enumeration elms = ht10.elements();
        int i = 0;
        while (elms.hasMoreElements()) {
            String s = (String) elms.nextElement();
            assertTrue("Missing key from enumeration", elmVector.contains(s));
            ++i;
        }

        assertEquals("All keys not retrieved", 10, ht10.size());
    }

    /**
     * @tests java.util.Hashtable#elements()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "elements",
        args = {}
    )
    public void test_elements_subtest0() {
        // this is the reference implementation behavior
        final Hashtable ht = new Hashtable(7);
        ht.put("1", "a");
        // these three elements hash to the same bucket in a 7 element Hashtable
        ht.put("2", "b");
        ht.put("9", "c");
        ht.put("12", "d");
        // Hashtable looks like:
        // 0: "1"
        // 1: "12" -> "9" -> "2"
        Enumeration en = ht.elements();
        // cache the first entry
        en.hasMoreElements();
        ht.remove("12");
        ht.remove("9");
        boolean exception = false;
        try {
            // cached "12"
            Object result = en.nextElement();
            assertNull("unexpected: " + result, result);
            // next is removed "9"
            result = en.nextElement();
            assertNull("unexpected: " + result, result);
            result = en.nextElement();
            assertTrue("unexpected: " + result, "b".equals(result));
        } catch (NoSuchElementException e) {
            exception = true;
        }
        assertTrue("unexpected NoSuchElementException", !exception);
    }

    /**
     * @tests java.util.Hashtable#entrySet()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "entrySet",
        args = {}
    )
    public void test_entrySet() {
        // Test for method java.util.Set java.util.Hashtable.entrySet()
        Set s = ht10.entrySet();
        Set s2 = new HashSet();
        Iterator i = s.iterator();
        while (i.hasNext())
            s2.add(((Map.Entry) i.next()).getValue());
        Enumeration e = elmVector.elements();
        while (e.hasMoreElements())
            assertTrue("Returned incorrect entry set", s2.contains(e
                    .nextElement()));

        assertEquals("Not synchronized",
                "java.util.Collections$SynchronizedSet", s.getClass().getName());

        boolean exception = false;
        try {
            ((Map.Entry) ht10.entrySet().iterator().next()).setValue(null);
        } catch (NullPointerException e1) {
            exception = true;
        }
        assertTrue(
                "Should not be able to assign null to a Hashtable entrySet() Map.Entry",
                exception);
    }

    /**
     * @tests java.util.Hashtable#equals(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "equals",
        args = {java.lang.Object.class}
    )
    public void test_equalsLjava_lang_Object() {
        // Test for method boolean java.util.Hashtable.equals(java.lang.Object)
        Hashtable h = hashtableClone(ht10);
        assertTrue("Returned false for equal tables", ht10.equals(h));
        assertTrue("Returned true for unequal tables", !ht10.equals(htfull));
    }

    /**
     * @tests java.util.Hashtable#get(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "get",
        args = {java.lang.Object.class}
    )
    public void test_getLjava_lang_Object() {
        // Test for method java.lang.Object
        // java.util.Hashtable.get(java.lang.Object)
        Hashtable h = hashtableClone(htfull);
        assertEquals("Could not retrieve element", "FVal 2", ((String) h.get("FKey 2"))
                );


        // Regression for HARMONY-262
        ReusableKey k = new ReusableKey();
        Hashtable h2 = new Hashtable();
        k.setKey(1);
        h2.put(k, "value1");

        k.setKey(13);
        assertNull(h2.get(k));

        k.setKey(12);
        assertNull(h2.get(k));

        try {
            h2.get(null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#hashCode()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "hashCode",
        args = {}
    )
    public void test_hashCode() {
        // Test for method int java.util.Hashtable.hashCode()
        Set entrySet = ht10.entrySet();
        Iterator iterator = entrySet.iterator();
        int expectedHash;
        for (expectedHash = 0; iterator.hasNext(); expectedHash += iterator
                .next().hashCode())
            ;
        assertTrue("Incorrect hashCode returned.  Wanted: " + expectedHash
                + " got: " + ht10.hashCode(), expectedHash == ht10.hashCode());
    }

    /**
     * @tests java.util.Hashtable#isEmpty()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "isEmpty",
        args = {}
    )
    public void test_isEmpty() {
        // Test for method boolean java.util.Hashtable.isEmpty()

        assertTrue("isEmpty returned incorrect value", !ht10.isEmpty());
        assertTrue("isEmpty returned incorrect value",
                new java.util.Hashtable().isEmpty());

        final Hashtable ht = new Hashtable();
        ht.put("0", "");
        Thread t1 = new Thread() {
            public void run() {
                while (!ht.isEmpty())
                    ;
                ht.put("final", "");
            }
        };
        t1.start();
        for (int i = 1; i < 10000; i++) {
            synchronized (ht) {
                ht.remove(String.valueOf(i - 1));
                ht.put(String.valueOf(i), "");
            }
            int size;
            if ((size = ht.size()) != 1) {
                String result = "Size is not 1: " + size + " " + ht;
                // terminate the thread
                ht.clear();
                fail(result);
            }
        }
        // terminate the thread
        ht.clear();
    }

    /**
     * @tests java.util.Hashtable#keys()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "keys",
        args = {}
    )
    public void test_keys() {
        // Test for method java.util.Enumeration java.util.Hashtable.keys()

        Enumeration keys = ht10.keys();
        int i = 0;
        while (keys.hasMoreElements()) {
            String s = (String) keys.nextElement();
            assertTrue("Missing key from enumeration", keyVector.contains(s));
            ++i;
        }

        assertEquals("All keys not retrieved", 10, ht10.size());
    }

    /**
     * @tests java.util.Hashtable#keys()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "keys",
        args = {}
    )
    public void test_keys_subtest0() {
        // this is the reference implementation behavior
        final Hashtable ht = new Hashtable(3);
        ht.put("initial", "");
        Enumeration en = ht.keys();
        en.hasMoreElements();
        ht.remove("initial");
        boolean exception = false;
        try {
            Object result = en.nextElement();
            assertTrue("unexpected: " + result, "initial".equals(result));
        } catch (NoSuchElementException e) {
            exception = true;
        }
        assertTrue("unexpected NoSuchElementException", !exception);
    }

    /**
     * @tests java.util.Hashtable#keySet()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "keySet",
        args = {}
    )
    public void test_keySet() {
        // Test for method java.util.Set java.util.Hashtable.keySet()
        Set s = ht10.keySet();
        Enumeration e = keyVector.elements();
        while (e.hasMoreElements())
            assertTrue("Returned incorrect key set", s
                    .contains(e.nextElement()));

        assertEquals("Not synchronized",
                "java.util.Collections$SynchronizedSet", s.getClass().getName());

        Map map = new Hashtable(101);
        map.put(new Integer(1), "1");
        map.put(new Integer(102), "102");
        map.put(new Integer(203), "203");
        Iterator it = map.keySet().iterator();
        Integer remove1 = (Integer) it.next();
        it.remove();
        Integer remove2 = (Integer) it.next();
        it.remove();
        ArrayList list = new ArrayList(Arrays.asList(new Integer[] {
                new Integer(1), new Integer(102), new Integer(203) }));
        list.remove(remove1);
        list.remove(remove2);
        assertTrue("Wrong result", it.next().equals(list.get(0)));
        assertEquals("Wrong size", 1, map.size());
        assertTrue("Wrong contents", map.keySet().iterator().next().equals(
                list.get(0)));

        Map map2 = new Hashtable(101);
        map2.put(new Integer(1), "1");
        map2.put(new Integer(4), "4");
        Iterator it2 = map2.keySet().iterator();
        Integer remove3 = (Integer) it2.next();
        Integer next;
        if (remove3.intValue() == 1)
            next = new Integer(4);
        else
            next = new Integer(1);
        it2.hasNext();
        it2.remove();
        assertTrue("Wrong result 2", it2.next().equals(next));
        assertEquals("Wrong size 2", 1, map2.size());
        assertTrue("Wrong contents 2", map2.keySet().iterator().next().equals(
                next));
    }

    /**
     * @tests java.util.Hashtable#keySet()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "keySet",
        args = {}
    )
    public void test_keySet_subtest0() {
        Set s1 = ht10.keySet();
        assertTrue("should contain key", s1.remove("Key 0"));
        assertTrue("should not contain key", !s1.remove("Key 0"));

        final int iterations = 10000;
        final Hashtable ht = new Hashtable();
        Thread t1 = new Thread() {
            public void run() {
                for (int i = 0; i < iterations; i++) {
                    ht.put(String.valueOf(i), "");
                    ht.remove(String.valueOf(i));
                }
            }
        };
        t1.start();
        Set set = ht.keySet();
        for (int i = 0; i < iterations; i++) {
            Iterator it = set.iterator();
            try {
                it.next();
                it.remove();
                int size;
                // ensure removing with the iterator doesn't corrupt the
                // Hashtable
                if ((size = ht.size()) < 0) {
                    fail("invalid size: " + size);
                }
            } catch (NoSuchElementException e) {
            } catch (ConcurrentModificationException e) {
            }
        }
    }

    /**
     * @tests java.util.Hashtable#keySet()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "keySet",
        args = {}
    )
    public void test_keySet_subtest1() {
        // this is the reference implementation behavior
        final Hashtable ht = new Hashtable(7);
        ht.put("1", "a");
        // these three elements hash to the same bucket in a 7 element Hashtable
        ht.put("2", "b");
        ht.put("9", "c");
        ht.put("12", "d");
        // Hashtable looks like:
        // 0: "1"
        // 1: "12" -> "9" -> "2"
        Enumeration en = ht.elements();
        // cache the first entry
        en.hasMoreElements();
        Iterator it = ht.keySet().iterator();
        // this is mostly a copy of the test in test_elements_subtest0()
        // test removing with the iterator does not null the values
        while (it.hasNext()) {
            String key = (String) it.next();
            if ("12".equals(key) || "9".equals(key)) {
                it.remove();
            }
        }
        it.remove();
        boolean exception = false;
        try {
            // cached "12"
            Object result = en.nextElement();
            assertTrue("unexpected: " + result, "d".equals(result));
            // next is removed "9"
            result = en.nextElement();
            assertTrue("unexpected: " + result, "c".equals(result));
            result = en.nextElement();
            assertTrue("unexpected: " + result, "b".equals(result));
        } catch (NoSuchElementException e) {
            exception = true;
        }
        assertTrue("unexpected NoSuchElementException", !exception);
    }

    /**
     * @tests java.util.Hashtable#put(java.lang.Object, java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "put",
        args = {java.lang.Object.class, java.lang.Object.class}
    )
    public void test_putLjava_lang_ObjectLjava_lang_Object() {
        // Test for method java.lang.Object
        // java.util.Hashtable.put(java.lang.Object, java.lang.Object)
        Hashtable h = hashtableClone(ht100);
        Integer key = new Integer(100);
        h.put("Value 100", key);
        assertTrue("Key/Value not inserted", h.size() == 1 && (h.contains(key)));

        // Put into "full" table
        h = hashtableClone(htfull);
        h.put("Value 100", key);
        assertTrue("Key/Value not inserted into full table", h.size() == 8
                && (h.contains(key)));

        try {
            h.put(null, key);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }

        try {
            h.put("Value 100", null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#putAll(java.util.Map)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "putAll",
        args = {java.util.Map.class}
    )
    public void test_putAllLjava_util_Map() {
        // Test for method void java.util.Hashtable.putAll(java.util.Map)
        Hashtable h = new Hashtable();
        h.putAll(ht10);
        Enumeration e = keyVector.elements();
        while (e.hasMoreElements()) {
            Object x = e.nextElement();
            assertTrue("Failed to put all elements", h.get(x).equals(
                    ht10.get(x)));
        }

        try {
            h.putAll(null);
            fail("NullPointerException expected");
        } catch (NullPointerException ee) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#remove(java.lang.Object)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "remove",
        args = {java.lang.Object.class}
    )
    public void test_removeLjava_lang_Object() {
        // Test for method java.lang.Object
        // java.util.Hashtable.remove(java.lang.Object)
        Hashtable h = hashtableClone(htfull);
        Object k = h.remove("FKey 0");
        assertTrue("Remove failed", !h.containsKey("FKey 0") || k == null);
        assertNull(h.remove("FKey 0"));

        try {
            h.remove(null);
            fail("NullPointerException expected");
        } catch (NullPointerException e) {
            //expected
        }
    }

    /**
     * @tests java.util.Hashtable#size()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "size",
        args = {}
    )
    public void test_size() {
        // Test for method int java.util.Hashtable.size()
        assertTrue("Returned invalid size", ht10.size() == 10
                && (ht100.size() == 0));

        final Hashtable ht = new Hashtable();
        ht.put("0", "");
        Thread t1 = new Thread() {
            public void run() {
                while (ht.size() > 0)
                    ;
                ht.put("final", "");
            }
        };
        t1.start();
        for (int i = 1; i < 10000; i++) {
            synchronized (ht) {
                ht.remove(String.valueOf(i - 1));
                ht.put(String.valueOf(i), "");
            }
            int size;
            if ((size = ht.size()) != 1) {
                String result = "Size is not 1: " + size + " " + ht;
                // terminate the thread
                ht.clear();
                fail(result);
            }
        }
        // terminate the thread
        ht.clear();
    }

    /**
     * @tests java.util.Hashtable#toString()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {}
    )
    public void test_toString() {
        // Test for method java.lang.String java.util.Hashtable.toString()
        Hashtable h = new Hashtable();
        assertEquals("Incorrect toString for Empty table",
                "{}", h.toString());

        h.put("one", "1");
        h.put("two", h);
        h.put(h, "3");
        h.put(h, h);
        String result = h.toString();
        assertTrue("should contain self ref", result.indexOf("(this") > -1);
    }

    /**
     * @tests java.util.Hashtable#values()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "values",
        args = {}
    )
    public void test_values() {
        // Test for method java.util.Collection java.util.Hashtable.values()
        Collection c = ht10.values();
        Enumeration e = elmVector.elements();
        while (e.hasMoreElements())
            assertTrue("Returned incorrect values", c.contains(e.nextElement()));

        assertEquals("Not synchronized",
                "java.util.Collections$SynchronizedCollection", c.getClass().getName());

        Hashtable myHashtable = new Hashtable();
        for (int i = 0; i < 100; i++)
            myHashtable.put(new Integer(i), new Integer(i));
        Collection values = myHashtable.values();
        new Support_UnmodifiableCollectionTest(
                "Test Returned Collection From Hashtable.values()", values)
                .runTest();
        values.remove(new Integer(0));
        assertTrue(
                "Removing from the values collection should remove from the original map",
                !myHashtable.containsValue(new Integer(0)));
    }

    /**
     * Regression Test for JIRA 2181
     */
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "entrySet",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "remove",
            args = {java.lang.Object.class}
        )
    })
    public void test_entrySet_remove()
    {
        Hashtable<String,String> hashtable = new Hashtable<String,String>();
        hashtable.put("my.nonexistent.prop", "AAA");
        hashtable.put( "parse.error", "BBB" );
        Iterator<Map.Entry<String,String>> iterator =
            hashtable.entrySet().iterator();
        while(iterator.hasNext())
        {
            Map.Entry entry = iterator.next();
            final Object value = entry.getValue();
            if(value.equals("AAA"))
            {
               iterator.remove();
            }
        }
        assertFalse(hashtable.containsKey("my.nonexistent.prop"));
    }

    class Mock_Hashtable extends Hashtable {
        boolean flag = false;

        public Mock_Hashtable(int i) {
            super(i);
        }

        @Override
        protected void rehash() {
            flag = true;
            super.rehash();
        }

        public boolean isRehashed() {
            return flag;
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "rehash",
        args = {}
    )
    public void test_rehash() {
        Mock_Hashtable mht = new Mock_Hashtable(5);

        assertFalse(mht.isRehashed());
        for(int i = 0; i < 10; i++) {
            mht.put(i, "New value");
        }
        assertTrue(mht.isRehashed());
    }

    protected Hashtable hashtableClone(Hashtable s) {
        return (Hashtable) s.clone();
    }

    /**
     * Sets up the fixture, for example, open a network connection. This method
     * is called before a test is executed.
     */
    protected void setUp() {

        ht10 = new Hashtable(10);
        ht100 = new Hashtable(100);
        htfull = new Hashtable(10);
        keyVector = new Vector(10);
        elmVector = new Vector(10);

        for (int i = 0; i < 10; i++) {
            ht10.put("Key " + i, "Val " + i);
            keyVector.addElement("Key " + i);
            elmVector.addElement("Val " + i);
        }

        for (int i = 0; i < 7; i++)
            htfull.put("FKey " + i, "FVal " + i);
    }

    /**
     * Tears down the fixture, for example, close a network connection. This
     * method is called after a test is executed.
     */
    protected void tearDown() {
    }
}