Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 java.util.List;
 import java.util.Map;
Base class for map testers.

This class is GWT compatible. TODO: see how much of this is actually needed once Map testers are written. (It was cloned from AbstractCollectionTester.)

Parameters:
<K> the key type of the map to be tested.
<V> the value type of the map to be tested.
Author(s):
George van den Driessche
 
 public abstract class AbstractMapTester<K, V> extends
     AbstractContainerTester<Map<K, V>, Map.Entry<K, V>> {
   protected Map<K, V> getMap() {
     return ;
   }
 
   @Override public void setUp() throws Exception {
     super.setUp();
      = this.getSubjectGenerator().samples();
     resetMap();
   }
 
   @Override protected Collection<Map.Entry<K, V>> actualContents() {
     return getMap().entrySet();
   }

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

  

Returns:
an array of the proper size with null as the key of the middle element.
 
   protected Map.Entry<K, V>[] createArrayWithNullKey() {
     Map.Entry<K, V>[] array = createSamplesArray();
     final int nullKeyLocation = getNullLocation();
     final Map.Entry<K, V> oldEntry = array[nullKeyLocation];
     array[nullKeyLocation] = entry(nulloldEntry.getValue());
     return array;
   }
 
   protected V getValueForNullKey() {
     return getEntryNullReplaces().getValue();
   }
 
   protected K getKeyForNullValue() {
     return getEntryNullReplaces().getKey();
   }
 
   private Entry<K, V> getEntryNullReplaces() {
     Iterator<Entry<K, V>> entries = getSampleElements().iterator();
     for (int i = 0; i < getNullLocation(); i++) {
      entries.next();
    }
    return entries.next();
  }

  

Returns:
an array of the proper size with null as the value of the middle element.
  protected Map.Entry<K, V>[] createArrayWithNullValue() {
    Map.Entry<K, V>[] array = createSamplesArray();
    final int nullValueLocation = getNullLocation();
    final Map.Entry<K, V> oldEntry = array[nullValueLocation];
    array[nullValueLocation] = entry(oldEntry.getKey(), null);
    return array;
  }
  protected void initMapWithNullKey() {
  }
  protected void initMapWithNullValue() {
  }

  
Equivalent to expectMissingKeys (null) except that the call to contains(null) is permitted to throw a NullPointerException.

Parameters:
message message to use upon assertion failure
  protected void expectNullKeyMissingWhenNullKeysUnsupported(String message) {
    try {
      assertFalse(messagegetMap().containsKey(null));
    } catch (NullPointerException tolerated) {
      // Tolerated
    }
  }

  
Equivalent to expectMissingValues (null) except that the call to contains(null) is permitted to throw a NullPointerException.

Parameters:
message message to use upon assertion failure
      String message) {
    try {
      assertFalse(messagegetMap().containsValue(null));
    } catch (NullPointerException tolerated) {
      // Tolerated
    }
  }
  @SuppressWarnings("unchecked")
  @Override protected MinimalCollection<Map.Entry<K, V>>
    return MinimalCollection.of(..);
  }
  protected int getNumEntries() {
    return getNumElements();
  }
  protected Collection<Map.Entry<K, V>> getSampleEntries(int howMany) {
    return getSampleElements(howMany);
  }
  protected Collection<Map.Entry<K, V>> getSampleEntries() {
    return getSampleElements();
  }
  @Override protected void expectMissing(Entry<K, V>... entries) {
    for (Entry<K, V> 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 aObject b) {
    return a == b || (a != null && a.equals(b));
  }
  // This one-liner saves us from some ugly casts
  protected Entry<K, V> entry(K key, V value) {
    return Helpers.mapEntry(keyvalue);
  }
  @Override protected void expectContents(Collection<Entry<K, V>> expected) {
    // TODO: move this to invariant checks once the appropriate hook exists?
    super.expectContents(expected);
    for (Entry<K, V> entry : expected) {
      assertEquals("Wrong value for key " + entry.getKey(),
          entry.getValue(), getMap().get(entry.getKey()));
    }
  }
  protected final void expectReplacement(Entry<K, V> newEntry) {
    List<Entry<K, V>> expected = Helpers.copyToList(getSampleElements());
    replaceValue(expectednewEntry);
    expectContents(expected);
  }
  private void replaceValue(List<Entry<K, V>> expectedEntry<K, V> newEntry) {
    for (ListIterator<Entry<K, V>> 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 java.util.Map.get(java.lang.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 getMap(), it also ensures that callers don't pass an java.util.Map.Entry by mistake.
  protected V get(K key) {
    return getMap().get(key);
  }
  protected void resetMap(Entry<K, V>[] entries) {
  }
New to GrepCode? Check out our FAQ X