guava-tests/test/com/google/common/collect/ForwardingNavigableMapTest.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2011 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;

 import static com.google.common.collect.Maps.immutableEntry;

 import com.google.common.collect.testing.NavigableMapTestSuiteBuilder;
 import com.google.common.collect.testing.SafeTreeMap;
 import com.google.common.collect.testing.TestStringSortedMapGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
 import com.google.common.collect.testing.features.MapFeature;

 import junit.framework.Test;
 import junit.framework.TestSuite;

 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NavigableMap;
 import java.util.NavigableSet;
 import java.util.Set;
 import java.util.SortedMap;

 /**
  * Tests for {@code ForwardingNavigableMap}.
  *
  * @author Robert Konigsberg
  * @author Louis Wasserman
  */
 public class ForwardingNavigableMapTest extends ForwardingSortedMapTest {
   static class StandardImplForwardingNavigableMap<K, V>
       extends ForwardingNavigableMap<K, V> {
     private final NavigableMap<K, V> backingMap;

     StandardImplForwardingNavigableMap(NavigableMap<K, V> backingMap) {
       this.backingMap = backingMap;
     }

     @Override protected NavigableMap<K, V> delegate() {
       return backingMap;
     }

     @Override public boolean containsKey(Object key) {
       return standardContainsKey(key);
     }

     @Override public boolean containsValue(Object value) {
       return standardContainsValue(value);
     }

     @Override public void putAll(Map<? extends K, ? extends V> map) {
       standardPutAll(map);
     }

     @Override public V remove(Object object) {
       return standardRemove(object);
     }

     @Override public boolean equals(Object object) {
       return standardEquals(object);
     }

     @Override public int hashCode() {
       return standardHashCode();
     }

     @Override public Set<K> keySet() {
       /*
        * We can't use StandardKeySet, as NavigableMapTestSuiteBuilder assumes that our keySet is a
        * NavigableSet. We test StandardKeySet in the superclass, so it's still covered.
        */
       return navigableKeySet();
     }

     @Override public Collection<V> values() {
       return new StandardValues();
     }

     @Override public String toString() {
       return standardToString();
     }

     @Override public Set<Entry<K, V>> entrySet() {
       return new StandardEntrySet() {
         @Override
         public Iterator<Entry<K, V>> iterator() {
           return backingMap.entrySet().iterator();
         }
       };
     }

     @Override public void clear() {
       standardClear();
     }

     @Override public boolean isEmpty() {
       return standardIsEmpty();
     }

     @Override public SortedMap<K, V> subMap(K fromKey, K toKey) {
       return standardSubMap(fromKey, toKey);
     }

     @Override
     public Entry<K, V> lowerEntry(K key) {
       return standardLowerEntry(key);
     }

     @Override
     public K lowerKey(K key) {
       return standardLowerKey(key);
     }

     @Override
     public Entry<K, V> floorEntry(K key) {
       return standardFloorEntry(key);
     }

     @Override
     public K floorKey(K key) {
       return standardFloorKey(key);
     }

     @Override
     public Entry<K, V> ceilingEntry(K key) {
       return standardCeilingEntry(key);
     }

     @Override
     public K ceilingKey(K key) {
       return standardCeilingKey(key);
     }

     @Override
     public Entry<K, V> higherEntry(K key) {
       return standardHigherEntry(key);
     }

     @Override
     public K higherKey(K key) {
       return standardHigherKey(key);
     }

     @Override
     public Entry<K, V> firstEntry() {
       return standardFirstEntry();
     }

     /*
      * We can't override lastEntry to delegate to standardLastEntry, as it would create an infinite
      * loop. Instead, we test standardLastEntry manually below.
      */

     @Override
     public Entry<K, V> pollFirstEntry() {
       return standardPollFirstEntry();
     }

     @Override
     public Entry<K, V> pollLastEntry() {
       return standardPollLastEntry();
     }

     @Override
     public NavigableMap<K, V> descendingMap() {
       return new StandardDescendingMap();
     }

     @Override
     public NavigableSet<K> navigableKeySet() {
       return new StandardNavigableKeySet();
     }

     @Override
     public NavigableSet<K> descendingKeySet() {
       return standardDescendingKeySet();
     }

     @Override
     public K firstKey() {
       return standardFirstKey();
     }

     @Override
     public SortedMap<K, V> headMap(K toKey) {
       return standardHeadMap(toKey);
     }

     @Override
     public K lastKey() {
       return standardLastKey();
     }

     @Override
     public SortedMap<K, V> tailMap(K fromKey) {
       return standardTailMap(fromKey);
     }
   }

   static class StandardLastEntryForwardingNavigableMap<K, V>
       extends ForwardingNavigableMap<K, V> {
     private final NavigableMap<K, V> backingMap;

     StandardLastEntryForwardingNavigableMap(NavigableMap<K, V> backingMap) {
       this.backingMap = backingMap;
     }

     @Override protected NavigableMap<K, V> delegate() {
       return backingMap;
     }

     @Override
     public Entry<K, V> lastEntry() {
       return standardLastEntry();
     }
   }

   public static Test suite() {
     TestSuite suite = new TestSuite();

     suite.addTestSuite(ForwardingNavigableMapTest.class);
     suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() {
       @Override protected SortedMap<String, String> create(
           Entry<String, String>[] entries) {
         NavigableMap<String, String> map = new SafeTreeMap<String, String>();
         for (Entry<String, String> entry : entries) {
           map.put(entry.getKey(), entry.getValue());
         }
         return new StandardImplForwardingNavigableMap<String, String>(map);
       }
     }).named("ForwardingNavigableMap[SafeTreeMap] with no comparator and standard "
         + "implementations").withFeatures(CollectionSize.ANY,
         CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
         CollectionFeature.SUPPORTS_ITERATOR_REMOVE, MapFeature.GENERAL_PURPOSE)
         .createTestSuite());
     // TODO(user): add forwarding-to-ImmutableSortedMap test
     return suite;
   }

   @Override public void setUp() throws Exception {
     super.setUp();
     /*
      * Class parameters must be raw, so we can't create a proxy with generic
      * type arguments. The created proxy only records calls and returns null, so
      * the type is irrelevant at runtime.
      */
     @SuppressWarnings("unchecked")
     final NavigableMap<String, Boolean> sortedMap =
         createProxyInstance(NavigableMap.class);
     forward = new ForwardingNavigableMap<String, Boolean>() {
       @Override protected NavigableMap<String, Boolean> delegate() {
         return sortedMap;
       }
     };
   }

   public void testStandardLastEntry() {
     NavigableMap<String, Integer> forwarding =
         new StandardLastEntryForwardingNavigableMap<String, Integer>(
             new SafeTreeMap<String, Integer>());
     assertNull(forwarding.lastEntry());
     forwarding.put("b", 2);
     assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
     forwarding.put("c", 3);
     assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
     forwarding.put("a", 1);
     assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
     forwarding.remove("c");
     assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
   }

   public void testLowerEntry() {
     forward().lowerEntry("key");
     assertEquals("[lowerEntry(Object)]", getCalls());
   }

   public void testLowerKey() {
     forward().lowerKey("key");
     assertEquals("[lowerKey(Object)]", getCalls());
   }

   public void testFloorEntry() {
     forward().floorEntry("key");
     assertEquals("[floorEntry(Object)]", getCalls());
   }

   public void testFloorKey() {
     forward().floorKey("key");
     assertEquals("[floorKey(Object)]", getCalls());
   }

   public void testCeilingEntry() {
     forward().ceilingEntry("key");
     assertEquals("[ceilingEntry(Object)]", getCalls());
   }

   public void testCeilingKey() {
     forward().ceilingKey("key");
     assertEquals("[ceilingKey(Object)]", getCalls());
   }

   public void testHigherEntry() {
     forward().higherEntry("key");
     assertEquals("[higherEntry(Object)]", getCalls());
   }

   public void testHigherKey() {
     forward().higherKey("key");
     assertEquals("[higherKey(Object)]", getCalls());
   }

   public void testPollFirstEntry() {
     forward().pollFirstEntry();
     assertEquals("[pollFirstEntry]", getCalls());
   }

   public void testPollLastEntry() {
     forward().pollLastEntry();
     assertEquals("[pollLastEntry]", getCalls());
   }

   public void testFirstEntry() {
     forward().firstEntry();
     assertEquals("[firstEntry]", getCalls());
   }

   public void testLastEntry() {
     forward().lastEntry();
     assertEquals("[lastEntry]", getCalls());
   }

   public void testDescendingMap() {
     forward().descendingMap();
     assertEquals("[descendingMap]", getCalls());
   }

   public void testNavigableKeySet() {
     forward().navigableKeySet();
     assertEquals("[navigableKeySet]", getCalls());
   }

   public void testDescendingKeySet() {
     forward().descendingKeySet();
     assertEquals("[descendingKeySet]", getCalls());
   }

   public void testSubMap_K_Bool_K_Bool() {
     forward().subMap("a", false, "b", true);
     assertEquals("[subMap(Object,boolean,Object,boolean)]", getCalls());
   }

   public void testHeadMap_K_Bool() {
     forward().headMap("a", false);
     assertEquals("[headMap(Object,boolean)]", getCalls());
   }

   public void testTailMap_K_Bool() {
     forward().tailMap("a", false);
     assertEquals("[tailMap(Object,boolean)]", getCalls());
   }

   @Override NavigableMap<String, Boolean> forward() {
     return (NavigableMap<String, Boolean>) super.forward();
   }
 }
	/*
	* Copyright (C) 2011 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;

	import static com.google.common.collect.Maps.immutableEntry;

	import com.google.common.collect.testing.NavigableMapTestSuiteBuilder;
	import com.google.common.collect.testing.SafeTreeMap;
	import com.google.common.collect.testing.TestStringSortedMapGenerator;
	import com.google.common.collect.testing.features.CollectionFeature;
	import com.google.common.collect.testing.features.CollectionSize;
	import com.google.common.collect.testing.features.MapFeature;

	import junit.framework.Test;
	import junit.framework.TestSuite;

	import java.util.Collection;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.NavigableMap;
	import java.util.NavigableSet;
	import java.util.Set;
	import java.util.SortedMap;

	/**
	* Tests for {@code ForwardingNavigableMap}.
	*
	* @author Robert Konigsberg
	* @author Louis Wasserman
	*/
	public class ForwardingNavigableMapTest extends ForwardingSortedMapTest {
	static class StandardImplForwardingNavigableMap<K, V>
	extends ForwardingNavigableMap<K, V> {
	private final NavigableMap<K, V> backingMap;

	StandardImplForwardingNavigableMap(NavigableMap<K, V> backingMap) {
	this.backingMap = backingMap;
	}

	@Override protected NavigableMap<K, V> delegate() {
	return backingMap;
	}

	@Override public boolean containsKey(Object key) {
	return standardContainsKey(key);
	}

	@Override public boolean containsValue(Object value) {
	return standardContainsValue(value);
	}

	@Override public void putAll(Map<? extends K, ? extends V> map) {
	standardPutAll(map);
	}

	@Override public V remove(Object object) {
	return standardRemove(object);
	}

	@Override public boolean equals(Object object) {
	return standardEquals(object);
	}

	@Override public int hashCode() {
	return standardHashCode();
	}

	@Override public Set<K> keySet() {
	/*
	* We can't use StandardKeySet, as NavigableMapTestSuiteBuilder assumes that our keySet is a
	* NavigableSet. We test StandardKeySet in the superclass, so it's still covered.
	*/
	return navigableKeySet();
	}

	@Override public Collection<V> values() {
	return new StandardValues();
	}

	@Override public String toString() {
	return standardToString();
	}

	@Override public Set<Entry<K, V>> entrySet() {
	return new StandardEntrySet() {
	@Override
	public Iterator<Entry<K, V>> iterator() {
	return backingMap.entrySet().iterator();
	}
	};
	}

	@Override public void clear() {
	standardClear();
	}

	@Override public boolean isEmpty() {
	return standardIsEmpty();
	}

	@Override public SortedMap<K, V> subMap(K fromKey, K toKey) {
	return standardSubMap(fromKey, toKey);
	}

	@Override
	public Entry<K, V> lowerEntry(K key) {
	return standardLowerEntry(key);
	}

	@Override
	public K lowerKey(K key) {
	return standardLowerKey(key);
	}

	@Override
	public Entry<K, V> floorEntry(K key) {
	return standardFloorEntry(key);
	}

	@Override
	public K floorKey(K key) {
	return standardFloorKey(key);
	}

	@Override
	public Entry<K, V> ceilingEntry(K key) {
	return standardCeilingEntry(key);
	}

	@Override
	public K ceilingKey(K key) {
	return standardCeilingKey(key);
	}

	@Override
	public Entry<K, V> higherEntry(K key) {
	return standardHigherEntry(key);
	}

	@Override
	public K higherKey(K key) {
	return standardHigherKey(key);
	}

	@Override
	public Entry<K, V> firstEntry() {
	return standardFirstEntry();
	}

	/*
	* We can't override lastEntry to delegate to standardLastEntry, as it would create an infinite
	* loop. Instead, we test standardLastEntry manually below.
	*/

	@Override
	public Entry<K, V> pollFirstEntry() {
	return standardPollFirstEntry();
	}

	@Override
	public Entry<K, V> pollLastEntry() {
	return standardPollLastEntry();
	}

	@Override
	public NavigableMap<K, V> descendingMap() {
	return new StandardDescendingMap();
	}

	@Override
	public NavigableSet<K> navigableKeySet() {
	return new StandardNavigableKeySet();
	}

	@Override
	public NavigableSet<K> descendingKeySet() {
	return standardDescendingKeySet();
	}

	@Override
	public K firstKey() {
	return standardFirstKey();
	}

	@Override
	public SortedMap<K, V> headMap(K toKey) {
	return standardHeadMap(toKey);
	}

	@Override
	public K lastKey() {
	return standardLastKey();
	}

	@Override
	public SortedMap<K, V> tailMap(K fromKey) {
	return standardTailMap(fromKey);
	}
	}

	static class StandardLastEntryForwardingNavigableMap<K, V>
	extends ForwardingNavigableMap<K, V> {
	private final NavigableMap<K, V> backingMap;

	StandardLastEntryForwardingNavigableMap(NavigableMap<K, V> backingMap) {
	this.backingMap = backingMap;
	}

	@Override protected NavigableMap<K, V> delegate() {
	return backingMap;
	}

	@Override
	public Entry<K, V> lastEntry() {
	return standardLastEntry();
	}
	}

	public static Test suite() {
	TestSuite suite = new TestSuite();

	suite.addTestSuite(ForwardingNavigableMapTest.class);
	suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() {
	@Override protected SortedMap<String, String> create(
	Entry<String, String>[] entries) {
	NavigableMap<String, String> map = new SafeTreeMap<String, String>();
	for (Entry<String, String> entry : entries) {
	map.put(entry.getKey(), entry.getValue());
	}
	return new StandardImplForwardingNavigableMap<String, String>(map);
	}
	}).named("ForwardingNavigableMap[SafeTreeMap] with no comparator and standard "
	+ "implementations").withFeatures(CollectionSize.ANY,
	CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
	CollectionFeature.SUPPORTS_ITERATOR_REMOVE, MapFeature.GENERAL_PURPOSE)
	.createTestSuite());
	// TODO(user): add forwarding-to-ImmutableSortedMap test
	return suite;
	}

	@Override public void setUp() throws Exception {
	super.setUp();
	/*
	* Class parameters must be raw, so we can't create a proxy with generic
	* type arguments. The created proxy only records calls and returns null, so
	* the type is irrelevant at runtime.
	*/
	@SuppressWarnings("unchecked")
	final NavigableMap<String, Boolean> sortedMap =
	createProxyInstance(NavigableMap.class);
	forward = new ForwardingNavigableMap<String, Boolean>() {
	@Override protected NavigableMap<String, Boolean> delegate() {
	return sortedMap;
	}
	};
	}

	public void testStandardLastEntry() {
	NavigableMap<String, Integer> forwarding =
	new StandardLastEntryForwardingNavigableMap<String, Integer>(
	new SafeTreeMap<String, Integer>());
	assertNull(forwarding.lastEntry());
	forwarding.put("b", 2);
	assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
	forwarding.put("c", 3);
	assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
	forwarding.put("a", 1);
	assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
	forwarding.remove("c");
	assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
	}

	public void testLowerEntry() {
	forward().lowerEntry("key");
	assertEquals("[lowerEntry(Object)]", getCalls());
	}

	public void testLowerKey() {
	forward().lowerKey("key");
	assertEquals("[lowerKey(Object)]", getCalls());
	}

	public void testFloorEntry() {
	forward().floorEntry("key");
	assertEquals("[floorEntry(Object)]", getCalls());
	}

	public void testFloorKey() {
	forward().floorKey("key");
	assertEquals("[floorKey(Object)]", getCalls());
	}

	public void testCeilingEntry() {
	forward().ceilingEntry("key");
	assertEquals("[ceilingEntry(Object)]", getCalls());
	}

	public void testCeilingKey() {
	forward().ceilingKey("key");
	assertEquals("[ceilingKey(Object)]", getCalls());
	}

	public void testHigherEntry() {
	forward().higherEntry("key");
	assertEquals("[higherEntry(Object)]", getCalls());
	}

	public void testHigherKey() {
	forward().higherKey("key");
	assertEquals("[higherKey(Object)]", getCalls());
	}

	public void testPollFirstEntry() {
	forward().pollFirstEntry();
	assertEquals("[pollFirstEntry]", getCalls());
	}

	public void testPollLastEntry() {
	forward().pollLastEntry();
	assertEquals("[pollLastEntry]", getCalls());
	}

	public void testFirstEntry() {
	forward().firstEntry();
	assertEquals("[firstEntry]", getCalls());
	}

	public void testLastEntry() {
	forward().lastEntry();
	assertEquals("[lastEntry]", getCalls());
	}

	public void testDescendingMap() {
	forward().descendingMap();
	assertEquals("[descendingMap]", getCalls());
	}

	public void testNavigableKeySet() {
	forward().navigableKeySet();
	assertEquals("[navigableKeySet]", getCalls());
	}

	public void testDescendingKeySet() {
	forward().descendingKeySet();
	assertEquals("[descendingKeySet]", getCalls());
	}

	public void testSubMap_K_Bool_K_Bool() {
	forward().subMap("a", false, "b", true);
	assertEquals("[subMap(Object,boolean,Object,boolean)]", getCalls());
	}

	public void testHeadMap_K_Bool() {
	forward().headMap("a", false);
	assertEquals("[headMap(Object,boolean)]", getCalls());
	}

	public void testTailMap_K_Bool() {
	forward().tailMap("a", false);
	assertEquals("[tailMap(Object,boolean)]", getCalls());
	}

	@Override NavigableMap<String, Boolean> forward() {
	return (NavigableMap<String, Boolean>) super.forward();
	}
	}