com.google.common.collect.testing.AbstractMapTester Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of guava-testlib-jdk5 Show documentation
Guava testlib is a set of java classes used for more convenient unit testing - particularly to assist the tests for Guava itself.
There is a newer version: 17.0
Show newest version
/*
 * Copyright (C) 2007 The Guava Authors
 *
 * 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.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;

/**
 * Base class for map testers.
 *
 * TODO: see how much of this is actually needed once Map testers are written.
 * (It was cloned from AbstractCollectionTester.)
 *
 * @param  the key type of the map to be tested.
 * @param  the value type of the map to be tested.
 *
 * @author George van den Driessche
 */
@GwtCompatible
public abstract class AbstractMapTester extends
    AbstractContainerTester, Map.Entry> {
  protected Map getMap() {
    return container;
  }

  @Override public void setUp() throws Exception {
    super.setUp();
    samples = this.getSubjectGenerator().samples();
    resetMap();
  }

  @Override protected Collection> actualContents() {
    return getMap().entrySet();
  }

  /** @see AbstractContainerTester#resetContainer() */
  protected void resetMap() {
    resetContainer();
  }

  protected void expectMissingKeys(K... elements) {
    for (K element : elements) {
      assertFalse("Should not contain key " + element,
          getMap().containsKey(element));
    }
  }

  protected void expectMissingValues(V... elements) {
    for (V element : elements) {
      assertFalse("Should not contain value " + element,
          getMap().containsValue(element));
    }
  }

  /**
   * @return an array of the proper size with {@code null} as the key of the
   * middle element.
   */
  protected Map.Entry[] createArrayWithNullKey() {
    Map.Entry[] array = createSamplesArray();
    final int nullKeyLocation = getNullLocation();
    final Map.Entry oldEntry = array[nullKeyLocation];
    array[nullKeyLocation] = entry(null, oldEntry.getValue());
    return array;
  }

  protected V getValueForNullKey() {
    return getEntryNullReplaces().getValue();
  }

  protected K getKeyForNullValue() {
    return getEntryNullReplaces().getKey();
  }

  private Entry getEntryNullReplaces() {
    Iterator> entries = getSampleElements().iterator();
    for (int i = 0; i < getNullLocation(); i++) {
      entries.next();
    }
    return entries.next();
  }

  /**
   * @return an array of the proper size with {@code null} as the value of the
   * middle element.
   */
  protected Map.Entry[] createArrayWithNullValue() {
    Map.Entry[] array = createSamplesArray();
    final int nullValueLocation = getNullLocation();
    final Map.Entry oldEntry = array[nullValueLocation];
    array[nullValueLocation] = entry(oldEntry.getKey(), null);
    return array;
  }

  protected void initMapWithNullKey() {
    resetMap(createArrayWithNullKey());
  }

  protected void initMapWithNullValue() {
    resetMap(createArrayWithNullValue());
  }

  /**
   * Equivalent to {@link #expectMissingKeys(Object[]) expectMissingKeys}
   * {@code (null)}
   * except that the call to {@code contains(null)} is permitted to throw a
   * {@code NullPointerException}.
   * @param message message to use upon assertion failure
   */
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {
      assertFalse(message, getMap().containsKey(null));
    } catch (NullPointerException tolerated) {
      // Tolerated
    }
  }

  /**
   * Equivalent to {@link #expectMissingValues(Object[]) expectMissingValues}
   * {@code (null)}
   * except that the call to {@code contains(null)} is permitted to throw a
   * {@code NullPointerException}.
   * @param message message to use upon assertion failure
   */
  protected void expectNullValueMissingWhenNullValuesUnsupported(
      String message) {
    try {
      assertFalse(message, getMap().containsValue(null));
    } catch (NullPointerException tolerated) {
      // Tolerated
    }
  }

  @SuppressWarnings("unchecked")
  @Override protected MinimalCollection>
      createDisjointCollection() {
    return MinimalCollection.of(samples.e3, samples.e4);
  }

  protected int getNumEntries() {
    return getNumElements();
  }

  protected Collection> getSampleEntries(int howMany) {
    return getSampleElements(howMany);
  }

  protected Collection> getSampleEntries() {
    return getSampleElements();
  }

  @Override protected void expectMissing(Entry... entries) {
    for (Entry entry : entries) {
      assertFalse("Should not contain entry " + entry,
          actualContents().contains(entry));
      assertFalse("Should not contain key " + entry.getKey() + " mapped to"
          + " value " + entry.getValue(),
          equal(getMap().get(entry.getKey()), entry.getValue()));
    }
  }

  private static boolean equal(Object a, Object b) {
    return a == b || (a != null && a.equals(b));
  }

  // This one-liner saves us from some ugly casts
  protected Entry entry(K key, V value) {
    return Helpers.mapEntry(key, value);
  }

  @Override protected void expectContents(Collection> expected) {
    // TODO: move this to invariant checks once the appropriate hook exists?
    super.expectContents(expected);
    for (Entry entry : expected) {
      assertEquals("Wrong value for key " + entry.getKey(),
          entry.getValue(), getMap().get(entry.getKey()));
    }
  }

  protected final void expectReplacement(Entry newEntry) {
    List> expected = Helpers.copyToList(getSampleElements());
    replaceValue(expected, newEntry);
    expectContents(expected);
  }

  private void replaceValue(List> expected, Entry newEntry) {
    for (ListIterator> i = expected.listIterator(); i.hasNext();) {
      if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
        i.set(newEntry);
        return;
      }
    }

    throw new IllegalArgumentException(Platform.format(
        "key %s not found in entries %s", newEntry.getKey(), expected));
  }

  /**
   * Wrapper for {@link Map#get(Object)} that forces the caller to pass in a key
   * of the same type as the map. Besides being slightly shorter than code that
   * uses {@link #getMap()}, it also ensures that callers don't pass an
   * {@link Entry} by mistake.
   */
  protected V get(K key) {
    return getMap().get(key);
  }

  protected void resetMap(Entry[] entries) {
    resetContainer(getSubjectGenerator().create((Object[]) entries));
  }
}