Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2009 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;
 
 
Tests representing the contract of java.util.SortedMap. Concrete subclasses of this base class test conformance of concrete java.util.SortedMap subclasses to that contract.

Author(s):
Jared Levy
 
 // TODO: Use this class to test classes besides ImmutableSortedMap.
 public abstract class SortedMapInterfaceTest<K, V>
     extends MapInterfaceTest<K, V> {
 
   protected SortedMapInterfaceTest(boolean allowsNullKeys,
       boolean allowsNullValuesboolean supportsPutboolean supportsRemove,
       boolean supportsClear) {
     super(allowsNullKeysallowsNullValuessupportsPutsupportsRemove,
         supportsClear);
   }
 
   @Override protected abstract SortedMap<K, V> makeEmptyMap()
       throws UnsupportedOperationException;
 
   @Override protected abstract SortedMap<K, V> makePopulatedMap()
       throws UnsupportedOperationException;
 
   @Override protected SortedMap<K, V> makeEitherMap() {
     try {
       return makePopulatedMap();
     } catch (UnsupportedOperationException e) {
       return makeEmptyMap();
     }
   }
 
   public void testTailMapWriteThrough() {
     final SortedMap<K, V> map;
     try {
       map = makePopulatedMap();
     } catch (UnsupportedOperationException e) {
       return;
     }
     if (map.size() < 2 || !) {
       return;
     }
     Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
     Entry<K, V> firstEntry = iterator.next();
     Entry<K, V> secondEntry = iterator.next();
     K key = secondEntry.getKey();
     SortedMap<K, V> subMap = map.tailMap(key);
     V value = getValueNotInPopulatedMap();
     subMap.put(keyvalue);
     assertEquals(secondEntry.getValue(), value);
     assertEquals(map.get(key), value);
     try {
       subMap.put(firstEntry.getKey(), value);
       fail("Expected IllegalArgumentException");
     } catch (IllegalArgumentException expected) {
     }
   }
 
   public void testTailMapRemoveThrough() {
     final SortedMap<K, V> map;
     try {
       map = makePopulatedMap();
     } catch (UnsupportedOperationException e) {
       return;
     }
     int oldSize = map.size();
     if (map.size() < 2 || !) {
       return;
     }
     Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
     Entry<K, V> firstEntry = iterator.next();
     Entry<K, V> secondEntry = iterator.next();
     K key = secondEntry.getKey();
     SortedMap<K, V> subMap = map.tailMap(key);
    subMap.remove(key);
    assertNull(subMap.remove(firstEntry.getKey()));
    assertEquals(map.size(), oldSize - 1);
    assertFalse(map.containsKey(key));
    assertEquals(subMap.size(), oldSize - 2);
  }
  public void testTailMapClearThrough() {
    final SortedMap<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !) {
      return;
    }
    Iterator<Entry<K, V>> iterator = map.entrySet().iterator();
    iterator.next(); // advance
    Entry<K, V> secondEntry = iterator.next();
    K key = secondEntry.getKey();
    SortedMap<K, V> subMap = map.tailMap(key);
    int subMapSize = subMap.size();
    subMap.clear();
    assertEquals(map.size(), oldSize - subMapSize);
    assertTrue(subMap.isEmpty());
  }
New to GrepCode? Check out our FAQ X