//CHECKSTYLE_OFF
/*
 * Copyright 1999-2004 The Apache Software Foundation
 *
 * Licensed 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 com.google.gwt.i18n;

import junit.framework.TestCase;

import org.apache.commons.collections.DefaultMapEntry;
import org.apache.commons.collections.TestCollection;
import org.apache.commons.collections.TestSet;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * Tests base {@link java.util.Map} methods and contracts.
 * <p>
 * The forces at work here are similar to those in {@link TestCollection}. If
 * your class implements the full Map interface, including optional operations,
 * simply extend this class, and implement the {@link #makeEmptyMap()} method.
 * <p>
 * On the other hand, if your map implementation is weird, you may have to
 * override one or more of the other protected methods. They're described below.
 * <P>
 * <B>Entry Population Methods</B>
 * <P>
 * Override these methods if your map requires special entries:
 * <UL>
 * <LI>{@link #getSampleKeys()}
 * <LI>{@link #getSampleValues()}
 * <LI>{@link #getNewSampleValues()}
 * <LI>{@link #getOtherKeys()}
 * <LI>{@link #getOtherValues()}
 * </UL>
 * <B>Supported Operation Methods</B>
 * <P>
 * Override these methods if your map doesn't support certain operations:
 * <UL>
 * <LI> {@link #useDuplicateValues()}
 * <LI> {@link #useNullKey()}
 * <LI> {@link #useNullValue()}
 * <LI> {@link #isRemoveModifiable()}
 * <LI> {@link #isChangeable()}
 * </UL>
 * <B>Fixture Methods</B>
 * <P>
 * For tests on modification operations (puts and removes), fixtures are used to
 * verify that that operation results in correct state for the map and its
 * collection views. Basically, the modification is performed against your map
 * implementation, and an identical modification is performed against a
 * <I>confirmed</I> map implementation. A confirmed map implementation is
 * something like <Code>java.util.HashMap</Code>, which is known to conform
 * exactly to the {@link Map} contract. After the modification takes place on
 * both your map implementation and the confirmed map implementation, the two
 * maps are compared to see if their state is identical. The comparison also
 * compares the collection views to make sure they're still the same.
 * <P>
 * The upshot of all that is that <I>any</I> test that modifies the map in
 * <I>any</I> way will verify that <I>all</I> of the map's state is still
 * correct, including the state of its collection views. So for instance if a
 * key is removed by the map's key set's iterator, then the entry set is checked
 * to make sure the key/value pair no longer appears.
 * <P>
 * The {@link #map} field holds an instance of your collection implementation.
 * The {@link #entrySet}, {@link #keySet} and {@link #collectionValues} fields
 * hold that map's collection views. And the {@link #confirmed} field holds an
 * instance of the confirmed collection implementation. The
 * {@link #resetEmpty()} and {@link #resetFull()} methods set these fields to
 * empty or full maps, so that tests can proceed from a known state.
 * <P>
 * After a modification operation to both {@link #map} and {@link #confirmed},
 * the {@link #verify()} method is invoked to compare the results. The {@link
 * verify()} method calls separate methods to verify the map and its three
 * collection views ({@link verifyMap(), {@link verifyEntrySet()}, {@link
 * verifyKeySet()}, and {@link verifyValues()}). You may want to override one
 * of the verification methodsto perform additional verifications. For instance,
 * {@link TestDoubleOrderedMap} would want override its {@link #verifyValues()}
 * method to verify that the values are unique and in ascending order.
 * <P>
 * <B>Other Notes</B>
 * <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 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
 * @author Paul Jack
 * @version $Id: TestMap.java,v 1.20.2.1 2004/05/22 12:14:05 scolebourne Exp $
 */
public abstract class MapTestBase extends TestCase {

  // These instance variables are initialized with the reset method.
  // Tests for map methods that alter the map (put, putAll, remove)
  // first call reset() to create the map and its views; then perform
  // the modification on the map; perform the same modification on the
  // confirmed; and then call verify() to ensure that the map is equal
  // to the confirmed, that the already-constructed collection views
  // are still equal to the confirmed's collection views.

  /** Map created by reset(). */
  protected Map map;

  /** Entry set of map created by reset(). */
  protected Set entrySet;

  /** Key set of map created by reset(). */
  protected Set keySet;

  /** Values collection of map created by reset(). */
  protected Collection collectionValues;

  /** HashMap created by reset(). */
  protected Map confirmed;

  /**
   * Override if your map does not allow a <code>null</code> key. The default
   * implementation returns <code>true</code>
   */
  protected boolean useNullKey() {
    return true;
  }

  /**
   * Override if your map does not allow <code>null</code> values. The default
   * implementation returns <code>true</code>.
   */
  protected boolean useNullValue() {
    return true;
  }

  /**
   * Override if your map does not allow duplicate values. The default
   * implementation returns <code>true</code>.
   */
  protected boolean useDuplicateValues() {
    return true;
  }

  /**
   * Override if your map allows its mappings to be changed to new values. The
   * default implementation returns <code>true</code>.
   */
  protected boolean isChangeable() {
    return true;
  }

  /**
   * Override if your map does not allow add/remove modifications. The default
   * implementation returns <code>true</code>.
   */
  protected abstract boolean isRemoveModifiable();

  /**
   * 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>.
   */
  protected 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;
  }

  protected Object[] getOtherKeys() {
    return TestCollection.getOtherNonNullStringElements();
  }

  protected Object[] getOtherValues() {
    return TestCollection.getOtherNonNullStringElements();
  }

  /**
   * 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>.
   */
  protected 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>.
   */
  protected 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()}.
   */
  protected 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 be used for testing.
   */
  protected abstract Map makeEmptyMap();

  /**
   * Return a new, populated map. The mappings in the map should match the keys
   * and values returned from {@link #getSampleKeys()} and {@link
   * #getSampleValues()}. The default implementation uses makeEmptyMap() and
   * calls {@link #addSampleMappings()} to add all the mappings to the map.
   */
  protected Map makeFullMap() {
    Map m = makeEmptyMap();
    addSampleMappings(m);
    return m;
  }

  public Object makeObject() {
    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();

    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.

  /**
   * 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);
  }

  /**
   * Tests Map.isEmpty()
   */
  public void testMapIsEmpty() {

    resetEmpty();
    assertEquals("Map.isEmpty() should return true with an empty map", true,
      map.isEmpty());
    verify();

    resetFull();
    assertEquals("Map.isEmpty() should return false with a non-empty map",
      false, map.isEmpty());
    verify();
  }

  /**
   * Tests Map.size()
   */
  public void testMapSize() {
    resetEmpty();
    assertEquals("Map.size() should be 0 with an empty map", 0, map.size());
    verify();

    resetFull();
    assertEquals("Map.size() should equal the number of entries "
      + "in the map", getSampleKeys().length, map.size());
    verify();
  }

  /**
   * Tests {@link Map#clear()}. If the map {@link #isRemoveModifiable() 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.
   */
  public void testMapClear() {
    if (!isRemoveModifiable())
      return;

    resetEmpty();
    map.clear();
    confirmed.clear();
    verify();

    resetFull();
    map.clear();
    confirmed.clear();
    verify();
  }

  /**
   * Tests Map.containsKey(Object) by verifying it returns false for all sample
   * keys on a map created using an empty map and returns true for all sample
   * keys returned on a full map.
   */
  public void testMapContainsKey() {
    Object[] keys = getSampleKeys();

    resetEmpty();
    for (int i = 0; i < keys.length; i++) {
      assertTrue("Map must not contain key when map is empty", !map
        .containsKey(keys[i]));
    }
    verify();

    resetFull();
    for (int i = 0; i < keys.length; i++) {
      assertTrue("Map must contain key for a mapping in the map. "
        + "Missing: " + keys[i], map.containsKey(keys[i]));
    }
    verify();
  }

  /**
   * Tests Map.containsValue(Object) by verifying it returns false for all
   * sample values on an empty map and returns true for all sample values on a
   * full map.
   */
  public void testMapContainsValue() {
    Object[] values = getSampleValues();

    resetEmpty();
    for (int i = 0; i < values.length; i++) {
      assertTrue("Empty map must not contain value", !map
        .containsValue(values[i]));
    }
    verify();

    resetFull();
    for (int i = 0; i < values.length; i++) {
      assertTrue("Map must contain value for a mapping in the map.", map
        .containsValue(values[i]));
    }
    verify();
  }

  /**
   * Tests Map.equals(Object)
   */
  public void testMapEquals() {
    resetEmpty();
    assertTrue("Empty maps unequal.", map.equals(confirmed));
    verify();

    resetFull();
    assertTrue("Full maps unequal.", map.equals(confirmed));
    verify();

    resetFull();
    // modify the HashMap created from the full map and make sure this
    // change results in map.equals() to return false.
    Iterator iter = confirmed.keySet().iterator();
    iter.next();
    iter.remove();
    assertTrue("Different maps equal.", !map.equals(confirmed));

    resetFull();
    assertTrue("equals(null) returned true.", !map.equals(null));
    assertTrue("equals(new Object()) returned true.", !map.equals(new Object()));
    verify();
  }

  /**
   * Tests Map.get(Object)
   */
  public void testMapGet() {
    resetEmpty();

    Object[] keys = getSampleKeys();
    Object[] values = getSampleValues();

    for (int i = 0; i < keys.length; i++) {
      assertTrue("Empty map.get() should return null.",
        map.get(keys[i]) == null);
    }
    verify();

    resetFull();
    for (int i = 0; i < keys.length; i++) {
      assertEquals("Full map.get() should return value from mapping.",
        values[i], map.get(keys[i]));
    }
  }

  /**
   * Tests Map.hashCode()
   */
  public void testMapHashCode() {
    resetEmpty();
    assertTrue("Empty maps have different hashCodes.",
      map.hashCode() == confirmed.hashCode());

    resetFull();
    // assertTrue("Equal maps have different hashCodes.",
    // map.hashCode() == confirmed.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() {
    resetEmpty();
    assertTrue("Empty map toString() should not return null",
      map.toString() != null);
    verify();

    resetFull();
    assertTrue("Empty map toString() should not return null",
      map.toString() != null);
    verify();
  }

  /**
   * Tests Map.put(Object, Object)
   */
  public void testMapPut() {
    if (!isRemoveModifiable())
      return;

    resetEmpty();

    Object[] keys = getSampleKeys();
    Object[] values = getSampleValues();
    Object[] newValues = getNewSampleValues();

    for (int i = 0; i < keys.length; i++) {
      Object o = map.put(keys[i], values[i]);
      confirmed.put(keys[i], values[i]);
      verify();
      assertTrue("First map.put should return null", o == null);
      assertTrue("Map should contain key after put", map.containsKey(keys[i]));
      assertTrue("Map should contain value after put", map
        .containsValue(values[i]));
    }

    for (int i = 0; i < keys.length; i++) {
      Object o = map.put(keys[i], newValues[i]);
      confirmed.put(keys[i], newValues[i]);
      verify();
      assertEquals("Second map.put should return previous value", values[i], o);
      assertTrue("Map should still contain key after put", map
        .containsKey(keys[i]));
      assertTrue("Map should contain new value after put", map
        .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", !map
          .containsValue(values[i]));
      }
    }
  }

  /**
   * Tests Map.putAll(Collection)
   */
  public void testMapPutAll() {
    if (!isRemoveModifiable())
      return;

    resetEmpty();

    Map m2 = makeFullMap();

    map.putAll(m2);
    confirmed.putAll(m2);
    verify();

    resetEmpty();

    m2 = new HashMap();
    Object[] keys = getSampleKeys();
    Object[] values = getSampleValues();
    for (int i = 0; i < keys.length; i++) {
      m2.put(keys[i], values[i]);
    }

    map.putAll(m2);
    confirmed.putAll(m2);
    verify();
  }

  /**
   * Tests Map.remove(Object)
   */
  public void testMapRemove() {
    if (!isRemoveModifiable())
      return;

    resetEmpty();

    Object[] keys = getSampleKeys();
    Object[] values = getSampleValues();
    for (int i = 0; i < keys.length; i++) {
      Object o = map.remove(keys[i]);
      assertTrue("First map.remove should return null", o == null);
    }
    verify();

    resetFull();

    for (int i = 0; i < keys.length; i++) {
      Object o = map.remove(keys[i]);
      confirmed.remove(keys[i]);
      verify();

      assertEquals("map.remove with valid key should return value", values[i],
        o);
    }

    Object[] other = getOtherKeys();

    resetFull();
    int size = map.size();
    for (int i = 0; i < other.length; i++) {
      Object o = map.remove(other[i]);
      assertEquals("map.remove for nonexistent key should return null", o, null);
      assertEquals("map.remove for nonexistent key should not " + "shrink map",
        size, map.size());
    }
    verify();
  }

  /**
   * Utility methods to create an array of Map.Entry objects out of the given
   * key and value arrays.
   * <P>
   * 
   * @param keys the array of keys
   * @param values the array of values
   * @return an array of Map.Entry of those keys to those values
   */
  private Map.Entry[] makeEntryArray(Object[] keys, Object[] values) {
    Map.Entry[] result = new Map.Entry[keys.length];
    for (int i = 0; i < keys.length; i++) {
      result[i] = new DefaultMapEntry(keys[i], values[i]);
    }
    return result;
  }

  class TestMapEntrySet extends TestSet {
    public TestMapEntrySet() {
      super("");
    }

    // Have to implement manually; entrySet doesn't support addAll
    protected Object[] getFullElements() {
      Object[] k = getSampleKeys();
      Object[] v = getSampleValues();
      return makeEntryArray(k, v);
    }

    // Have to implement manually; entrySet doesn't support addAll
    protected Object[] getOtherElements() {
      Object[] k = getOtherKeys();
      Object[] v = getOtherValues();
      return makeEntryArray(k, v);
    }

    protected Set makeEmptySet() {
      return makeEmptyMap().entrySet();
    }

    protected Set makeFullSet() {
      return makeFullMap().entrySet();
    }

    protected boolean isAddSupported() {
      // Collection views don't support add operations.
      return false;
    }

    protected boolean isRemoveSupported() {
      // Entry set should only support remove if map does
      return isRemoveModifiable();
    }

    protected void resetFull() {
      MapTestBase.this.resetFull();
      collection = map.entrySet();
      TestMapEntrySet.this.confirmed = MapTestBase.this.confirmed.entrySet();
    }

    protected void resetEmpty() {
      MapTestBase.this.resetEmpty();
      collection = map.entrySet();
      TestMapEntrySet.this.confirmed = MapTestBase.this.confirmed.entrySet();
    }

    protected void verify() {
      super.verify();
      MapTestBase.this.verify();
    }
  }

  class TestMapKeySet extends TestSet {
    public TestMapKeySet() {
      super("");
    }

    protected Object[] getFullElements() {
      return getSampleKeys();
    }

    protected Object[] getOtherElements() {
      return getOtherKeys();
    }

    protected Set makeEmptySet() {
      return makeEmptyMap().keySet();
    }

    protected Set makeFullSet() {
      return makeFullMap().keySet();
    }

    protected boolean isAddSupported() {
      return false;
    }

    protected boolean isRemoveSupported() {
      return isRemoveModifiable();
    }

    protected void resetEmpty() {
      MapTestBase.this.resetEmpty();
      collection = map.keySet();
      TestMapKeySet.this.confirmed = MapTestBase.this.confirmed.keySet();
    }

    protected void resetFull() {
      MapTestBase.this.resetFull();
      collection = map.keySet();
      TestMapKeySet.this.confirmed = MapTestBase.this.confirmed.keySet();
    }

    protected void verify() {
      super.verify();
      MapTestBase.this.verify();
    }
  }

  class TestMapValues extends TestCollection {
    public TestMapValues() {

    }

    protected Object[] getFullElements() {
      return getSampleValues();
    }

    protected Object[] getOtherElements() {
      return getOtherValues();
    }

    protected Collection makeCollection() {
      return makeEmptyMap().values();
    }

    protected Collection makeFullCollection() {
      return makeFullMap().values();
    }

    protected boolean isAddSupported() {
      return false;
    }

    protected boolean isRemoveSupported() {
      return isRemoveModifiable();
    }

    protected boolean areEqualElementsDistinguishable() {
      // equal values are associated with different keys, so they are
      // distinguishable.
      return true;
    }

    protected Collection makeConfirmedCollection() {
      // never gets called, reset methods are overridden
      return null;
    }

    protected Collection makeConfirmedFullCollection() {
      // never gets called, reset methods are overridden
      return null;
    }

    protected void resetFull() {
      MapTestBase.this.resetFull();
      collection = map.values();
      TestMapValues.this.confirmed = MapTestBase.this.confirmed.values();
    }

    protected void resetEmpty() {
      MapTestBase.this.resetEmpty();
      collection = map.values();
      TestMapValues.this.confirmed = MapTestBase.this.confirmed.values();
    }

    protected void verify() {
      super.verify();
      MapTestBase.this.verify();
    }

    // TODO: should test that a remove on the values collection view
    // removes the proper mapping and not just any mapping that may have
    // the value equal to the value returned from the values iterator.
  }

  /**
   * Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
   * {@link #collectionValues} and {@link #confirmed} fields to empty.
   */
  protected void resetEmpty() {
    this.map = makeEmptyMap();
    views();
    this.confirmed = new HashMap();
  }

  /**
   * Resets the {@link #map}, {@link #entrySet}, {@link #keySet},
   * {@link #collectionValues} and {@link #confirmed} fields to full.
   */
  protected void resetFull() {
    this.map = makeFullMap();
    views();
    this.confirmed = new HashMap();
    Object[] k = getSampleKeys();
    Object[] v = getSampleValues();
    for (int i = 0; i < k.length; i++) {
      confirmed.put(k[i], v[i]);
    }
  }

  /**
   * Resets the collection view fields.
   */
  private void views() {
    this.keySet = map.keySet();
    this.collectionValues = map.values();
    this.entrySet = map.entrySet();
  }

  /**
   * Verifies that {@link #map} is still equal to {@link #confirmed}. This
   * method checks that the map is equal to the HashMap, <I>and</I> that the
   * map's collection views are still equal to the HashMap's collection views.
   * An <Code>equals</Code> test is done on the maps and their collection
   * views; their size and <Code>isEmpty</Code> results are compared; their
   * hashCodes are compared; and <Code>containsAll</Code> tests are run on the
   * collection views.
   */
  protected void verify() {
    verifyMap();
    verifyEntrySet();
    verifyKeySet();

  }

  protected void verifyMap() {
    int size = confirmed.size();
    boolean empty = confirmed.isEmpty();
    assertEquals("Map should be same size as HashMap", size, map.size());
    assertEquals("Map should be empty if HashMap is", empty, map.isEmpty());

    // assertEquals("hashCodes should be the same",
    // confirmed.hashCode(), map.hashCode());
    // this fails for LRUMap because confirmed.equals() somehow modifies
    // map, causing concurrent modification exceptions.
    // assertEquals("Map should still equal HashMap", confirmed, map);
    // this works though and performs the same verification:
    assertTrue("Map should still equal HashMap", map.equals(confirmed));
    // TODO: this should really be rexamined to figure out why LRU map
    // behaves like it does (the equals shouldn't modify since all accesses
    // by the confirmed collection should be through an iterator, thus not
    // causing LRUMap to change).
  }

  protected void verifyEntrySet() {
    int size = confirmed.size();
    boolean empty = confirmed.isEmpty();
    assertEquals("entrySet should be same size as HashMap's", size, entrySet
      .size());
    assertEquals("entrySet should be empty if HashMap is", empty, entrySet
      .isEmpty());
    assertTrue("entrySet should contain all HashMap's elements", entrySet
      .containsAll(confirmed.entrySet()));
    // Figure out why the hashcodes are not working for constant map
    // assertEquals("entrySet hashCodes should be the same",
    // confirmed.entrySet().hashCode(), entrySet.hashCode());
    assertEquals("Map's entry set should still equal HashMap's", confirmed
      .entrySet(), entrySet);
  }

  protected void verifyKeySet() {
    int size = confirmed.size();
    boolean empty = confirmed.isEmpty();
    assertEquals("keySet should be same size as HashMap's", size, keySet.size());
    assertEquals("keySet should be empty if HashMap is", empty, keySet
      .isEmpty());
    assertTrue("keySet should contain all HashMap's elements", keySet
      .containsAll(confirmed.keySet()));
    // assertEquals("keySet hashCodes should be the same",
    // confirmed.keySet().hashCode(), keySet.hashCode());
    assertEquals("Map's key set should still equal HashMap's", confirmed
      .keySet(), keySet);
  }

}