* Copyright 2008 Google Inc.

*

* 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.

*/

* Tests <code>TreeMap</code>.

*

* @param <K> The key type for the underlying TreeMap

* @param <V> The value type for the underlying TreeMap

*

* TODO(jat): this whole structure needs work. Ideally we would port a new

* Apache collections test to GWT, but that is not an insignificant amount of

* work.

*/

    private final String value;

    ConflictingKey(String value) {

      this.value = value;

    }

    @Override

    public int compareTo(CharSequence o) {

      return value.compareTo(o.toString());

    }

  }

  /**

   * Verify a Collection is explicitly and implicitly empty.

   *

   * @param collection

   */

  @SuppressWarnings("unchecked")

  private static void _assertEmpty(Collection collection) {

    assertNotNull(collection);

    assertTrue(collection.isEmpty());

    assertEquals(0, collection.size());

    assertNotNull(collection.iterator());

    assertFalse(collection.iterator().hasNext());

  }

  /**

   * Verify a Map is explicitly and implicitly empty.

   *

   * @param map

   */

  private static <K, V> void _assertEmpty(Map<K, V> map) {

    assertNotNull(map);

    assertTrue(map.isEmpty());

    assertEquals(0, map.size());

    _assertEmpty(map.values());

    _assertEmpty(map.keySet());

    _assertEmpty(map.entrySet());

  }

  /**

   * Verify that two Collections are deeply equivalent. Some of the Sets that

   * need to be verified do not implement a sensible equals method

   * (TreeMap.values for example).

   *

   * @param expected

   * @param actual

   */

  private static <T> void _assertEquals(Collection<T> expected,

      Collection<T> actual) {

    // verify equivalence using collection interface

    assertEquals(expected.isEmpty(), actual.isEmpty());

    assertEquals(expected.size(), actual.size());

    assertTrue(expected.containsAll(actual));

    assertTrue(actual.containsAll(expected));

    for (T expectedValue : expected) {

      assertTrue(actual.contains(expectedValue));

    }

    for (T actualValue : actual) {

      assertTrue(expected.contains(actualValue));

    }

  }

  /**

   * Verify that two Maps are deeply equivalent.

   *

   * @param expected

   * @param actual

   */

  private static <K, V> void _assertEquals(Map<K, V> expected, Map<K, V> actual) {

    assertEquals(expected.isEmpty(), actual.isEmpty());

    assertEquals(expected.size(), actual.size());

    _assertEquals(expected.keySet(), actual.keySet());

    _assertEquals(expected.entrySet(), actual.entrySet());

    _assertEquals(expected.values(), actual.values());

    // TODO: equals is broken for collection returned by values() for submaps of TreeMap.

    // assertEquals(expected.values(), actual.values());

  }

  /**

   * Verify that two SortedMaps are deeply equivalent.

   *

   * @param expected

   * @param actual

   */

  private static <K, V> void _assertEquals(SortedMap<K, V> expected,

      SortedMap<K, V> actual) {

    _assertEquals((Map<K, V>) expected, (Map<K, V>) actual);

    // verify the order of the associated collections

    assertEquals(expected.keySet().toArray(), actual.keySet().toArray());

    assertEquals(expected.entrySet().toArray(), actual.entrySet().toArray());

    assertEquals(expected.values().toArray(), actual.values().toArray());

  }

  /**

   * Create the expected return of toString for a Map containing only the passed

   * key and value.

   *

   * @param key

   * @param value

   * @return

   */

  private static <K, V> String makeEntryString(K key, V value) {

    return "{" + key + "=" + value + "}";

  }

  private static <E> Collection<E> reverseCollection(Collection<E> c) {

    List<E> reversedCollection = new ArrayList<E>(c);

    Collections.reverse(reversedCollection);

    return reversedCollection;

  }

  /**

   * Verify entry to be immutable and to have correct values of {@code Map.Entry#toString()}

   * and {@code Map.Entry#hashCode()}.

   */

  @SuppressWarnings("unchecked")

  private static void verifyEntry(Entry entry) {

    try {

      entry.setValue(new Object());

      fail("should throw UnsupportedOperationException");

    } catch (UnsupportedOperationException expected) {

    }

    Object key = entry.getKey();

    Object value = entry.getValue();

    int expectedHashCode = (key == null ? 0 : key.hashCode())

        ^ (value == null ? 0 : value.hashCode());

    assertEquals(expectedHashCode, entry.hashCode());

    assertEquals(key + "=" + value, entry.toString());

  }

  /**

   * comparator used when creating the SortedMap.

   */

  private Comparator<K> comparator = null;

  private boolean isClearSupported = true;

  private boolean isNullKeySupported = true;

  private boolean isNullValueSupported = true;

  private boolean isPutAllSupported = true;

  private boolean isPutSupported = true;

  private boolean isRemoveSupported = true;

  @Override

  public String getModuleName() {

    return "com.google.gwt.emultest.EmulSuite";

  }

  public void testCeilingEntry() {

    K[] keys = getSortedKeys();

    V[] values = getSortedValues();

    NavigableMap<K, V> map = createNavigableMap();

    // test with a single entry map

    map.put(keys[0], values[0]);

    assertEquals(keys[0], map.ceilingEntry(keys[0]).getKey());

    assertEquals(values[0], map.ceilingEntry(keys[0]).getValue());

    assertEquals(keys[0], map.ceilingEntry(getLessThanMinimumKey()).getKey());

    // is it consistent with other methods

    assertEquals(map.keySet().toArray()[0], map.ceilingEntry(getLessThanMinimumKey()).getKey());

    // test with two entry map

    map.put(keys[1], values[1]);

    assertEquals(keys[0], map.ceilingEntry(getLessThanMinimumKey()).getKey());

    Entry<K, V> entry = map.ceilingEntry(keys[0]);

    verifyEntry(entry);

    assertEquals(keys[0], entry.getKey());

    assertEquals(keys[1], map.ceilingEntry(keys[1]).getKey());

    assertEquals(values[1], map.ceilingEntry(keys[1]).getValue());

    assertNull(map.ceilingEntry(getGreaterThanMaximumKey()));

  }

  public void testCeilingKey() {

    K[] keys = getSortedKeys();

    V[] values = getSortedValues();

    NavigableMap<K, V> map = createNavigableMap();

    // test with a single entry map

    map.put(keys[0], values[0]);

    assertEquals(keys[0], map.ceilingKey(keys[0]));

    assertEquals(keys[0], map.ceilingKey(getLessThanMinimumKey()));

    // is it consistent with other methods