1 files changed, 118 insertions, 106 deletions
diff --git a/guava-tests/test/com/google/common/collect/ForwardingNavigableSetTest.java b/guava-tests/test/com/google/common/collect/ForwardingNavigableSetTest.java
index fd47bf8fd..70178b1ea 100644
--- a/guava-tests/test/com/google/common/collect/ForwardingNavigableSetTest.java
+++ b/guava-tests/test/com/google/common/collect/ForwardingNavigableSetTest.java
@@ -16,14 +16,15 @@
 
 package com.google.common.collect;
 
-import com.google.common.base.Function;
 import com.google.common.collect.testing.SafeTreeSet;
 import com.google.common.collect.testing.SetTestSuiteBuilder;
 import com.google.common.collect.testing.TestStringSetGenerator;
 import com.google.common.collect.testing.features.CollectionFeature;
 import com.google.common.collect.testing.features.CollectionSize;
-import com.google.common.testing.EqualsTester;
-import com.google.common.testing.ForwardingWrapperTester;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -31,90 +32,74 @@ import java.util.List;
 import java.util.NavigableSet;
 import java.util.Set;
 import java.util.SortedSet;
-import junit.framework.Test;
-import junit.framework.TestCase;
-import junit.framework.TestSuite;
 
 /**
  * Tests for {@code ForwardingNavigableSet}.
  *
  * @author Louis Wasserman
  */
-public class ForwardingNavigableSetTest extends TestCase {
-  static class StandardImplForwardingNavigableSet<T> extends ForwardingNavigableSet<T> {
+public class ForwardingNavigableSetTest extends ForwardingSortedSetTest {
+  static class StandardImplForwardingNavigableSet<T>
+      extends ForwardingNavigableSet<T> {
     private final NavigableSet<T> backingSet;
 
     StandardImplForwardingNavigableSet(NavigableSet<T> backingSet) {
       this.backingSet = backingSet;
     }
 
-    @Override
-    protected NavigableSet<T> delegate() {
+    @Override protected NavigableSet<T> delegate() {
       return backingSet;
     }
 
-    @Override
-    public boolean equals(Object object) {
+    @Override public boolean equals(Object object) {
       return standardEquals(object);
     }
 
-    @Override
-    public int hashCode() {
+    @Override public int hashCode() {
       return standardHashCode();
     }
 
-    @Override
-    public boolean addAll(Collection<? extends T> collection) {
+    @Override public boolean addAll(Collection<? extends T> collection) {
       return standardAddAll(collection);
     }
 
-    @Override
-    public void clear() {
+    @Override public void clear() {
       standardClear();
     }
 
-    @Override
-    public boolean contains(Object object) {
+    @Override public boolean contains(Object object) {
       return standardContains(object);
     }
 
-    @Override
-    public boolean containsAll(Collection<?> collection) {
+    @Override public boolean containsAll(Collection<?> collection) {
       return standardContainsAll(collection);
     }
 
-    @Override
-    public boolean remove(Object object) {
+    @Override public boolean remove(Object object) {
       return standardRemove(object);
     }
 
-    @Override
-    public boolean removeAll(Collection<?> collection) {
+    @Override public boolean removeAll(Collection<?> collection) {
       return standardRemoveAll(collection);
     }
 
-    @Override
-    public boolean retainAll(Collection<?> collection) {
+    @Override public boolean retainAll(Collection<?> collection) {
       return standardRetainAll(collection);
     }
 
-    @Override
-    public Object[] toArray() {
+    @Override public Object[] toArray() {
       return standardToArray();
     }
 
-    @Override
-    public <T> T[] toArray(T[] array) {
+    @Override public <T> T[] toArray(T[] array) {
       return standardToArray(array);
     }
 
-    @Override
-    public String toString() {
+    @Override public String toString() {
       return standardToString();
     }
 
-    @Override
-    public SortedSet<T> subSet(T fromElement, T toElement) {
+    @Override public SortedSet<T> subSet(T fromElement, T toElement) {
       return standardSubSet(fromElement, toElement);
     }
 
@@ -158,87 +143,114 @@ public class ForwardingNavigableSetTest extends TestCase {
       return standardTailSet(fromElement);
     }
   }
-
+  
   public static Test suite() {
     TestSuite suite = new TestSuite();
-
+    
     suite.addTestSuite(ForwardingNavigableSetTest.class);
     suite.addTest(
-        SetTestSuiteBuilder.using(
-                new TestStringSetGenerator() {
-                  @Override
-                  protected Set<String> create(String[] elements) {
-                    return new StandardImplForwardingNavigableSet<>(
-                        new SafeTreeSet<String>(Arrays.asList(elements)));
-                  }
-
-                  @Override
-                  public List<String> order(List<String> insertionOrder) {
-                    return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
-                  }
-                })
-            .named("ForwardingNavigableSet[SafeTreeSet] with standard implementations")
-            .withFeatures(
-                CollectionSize.ANY,
-                CollectionFeature.KNOWN_ORDER,
-                CollectionFeature.GENERAL_PURPOSE)
-            .createTestSuite());
+        SetTestSuiteBuilder.using(new TestStringSetGenerator() {
+          @Override protected Set<String> create(String[] elements) {
+            return new StandardImplForwardingNavigableSet<String>(
+                new SafeTreeSet<String>(Arrays.asList(elements)));
+          }
+
+          @Override public List<String> order(List<String> insertionOrder) {
+            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
+          }
+        }).named(
+            "ForwardingNavigableSet[SafeTreeSet] with standard implementations")
+            .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
+                CollectionFeature.GENERAL_PURPOSE).createTestSuite());
     suite.addTest(
-        SetTestSuiteBuilder.using(
-                new TestStringSetGenerator() {
-                  @Override
-                  protected Set<String> create(String[] elements) {
-                    SafeTreeSet<String> set = new SafeTreeSet<>(Ordering.natural().nullsFirst());
-                    Collections.addAll(set, elements);
-                    return new StandardImplForwardingNavigableSet<>(set);
-                  }
-
-                  @Override
-                  public List<String> order(List<String> insertionOrder) {
-                    return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
-                  }
-                })
-            .named(
-                "ForwardingNavigableSet[SafeTreeSet[Ordering.natural.nullsFirst]]"
-                    + " with standard implementations")
-            .withFeatures(
-                CollectionSize.ANY,
-                CollectionFeature.KNOWN_ORDER,
-                CollectionFeature.GENERAL_PURPOSE,
-                CollectionFeature.ALLOWS_NULL_VALUES)
-            .createTestSuite());
-
+        SetTestSuiteBuilder.using(new TestStringSetGenerator() {
+          @Override protected Set<String> create(String[] elements) {
+            SafeTreeSet<String> set = new SafeTreeSet<String>(Ordering.natural().nullsFirst());
+            Collections.addAll(set, elements);
+            return new StandardImplForwardingNavigableSet<String>(set);
+          }
+
+          @Override public List<String> order(List<String> insertionOrder) {
+            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
+          }
+        }).named(
+            "ForwardingNavigableSet[SafeTreeSet[Ordering.natural.nullsFirst]]"
+                + " with standard implementations")
+            .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
+                CollectionFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES)
+                .createTestSuite());
+    
     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 NavigableSet<String> navigableSet
+        = createProxyInstance(NavigableSet.class);
+    forward = new ForwardingNavigableSet<String>() {
+      @Override protected NavigableSet<String> delegate() {
+        return navigableSet;
+      }
+    };
+  }
 
-  @SuppressWarnings({"rawtypes", "unchecked"})
-  public void testForwarding() {
-    new ForwardingWrapperTester()
-        .testForwarding(
-            NavigableSet.class,
-            new Function<NavigableSet, NavigableSet>() {
-              @Override
-              public NavigableSet apply(NavigableSet delegate) {
-                return wrap(delegate);
-              }
-            });
+  public void testLower() {
+    forward().lower("a");
+    assertEquals("[lower(Object)]", getCalls());
   }
 
-  public void testEquals() {
-    NavigableSet<String> set1 = ImmutableSortedSet.of("one");
-    NavigableSet<String> set2 = ImmutableSortedSet.of("two");
-    new EqualsTester()
-        .addEqualityGroup(set1, wrap(set1), wrap(set1))
-        .addEqualityGroup(set2, wrap(set2))
-        .testEquals();
+  public void testFloor() {
+    forward().floor("a");
+    assertEquals("[floor(Object)]", getCalls());
   }
 
-  private static <T> NavigableSet<T> wrap(final NavigableSet<T> delegate) {
-    return new ForwardingNavigableSet<T>() {
-      @Override
-      protected NavigableSet<T> delegate() {
-        return delegate;
-      }
-    };
+  public void testCeiling() {
+    forward().ceiling("a");
+    assertEquals("[ceiling(Object)]", getCalls());
+  }
+
+  public void testHigher() {
+    forward().higher("a");
+    assertEquals("[higher(Object)]", getCalls());
+  }
+
+  public void testPollFirst() {
+    forward().pollFirst();
+    assertEquals("[pollFirst]", getCalls());
+  }
+
+  public void testPollLast() {
+    forward().pollLast();
+    assertEquals("[pollLast]", getCalls());
+  }
+
+  public void testDescendingIterator() {
+    forward().descendingIterator();
+    assertEquals("[descendingIterator]", getCalls());
+  }
+  
+  public void testHeadSet_K_Boolean() {
+    forward().headSet("key", false);
+    assertEquals("[headSet(Object,boolean)]", getCalls());
+  }
+  
+  public void testSubSet_K_Boolean_K_Boolean() {
+    forward().subSet("a", true, "b", false);
+    assertEquals("[subSet(Object,boolean,Object,boolean)]", getCalls());
+  }
+  
+  public void testTailSet_K_Boolean() {
+    forward().tailSet("key", false);
+    assertEquals("[tailSet(Object,boolean)]", getCalls());
+  }
+
+  @Override NavigableSet<String> forward() {
+    return (NavigableSet<String>) super.forward();
   }
 }