ForwardingSortedSetTest.java revision 1d580d0f6ee4f21eb309ba7b509d2c6d671c4044 
1/*
2 * Copyright (C) 2010 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.google.common.collect;
18
19import com.google.common.collect.testing.SafeTreeSet;
20import com.google.common.collect.testing.SetTestSuiteBuilder;
21import com.google.common.collect.testing.TestStringSetGenerator;
22import com.google.common.collect.testing.features.CollectionFeature;
23import com.google.common.collect.testing.features.CollectionSize;
24
25import junit.framework.Test;
26import junit.framework.TestSuite;
27
28import java.util.Arrays;
29import java.util.Collection;
30import java.util.List;
31import java.util.Set;
32import java.util.SortedSet;
33
34/**
35 * Tests for {@code ForwardingSortedSet}.
36 *
37 * @author Louis Wasserman
38 */
39public class ForwardingSortedSetTest extends ForwardingSetTest {
40  static class StandardImplForwardingSortedSet<T>
41      extends ForwardingSortedSet<T> {
42    private final SortedSet<T> backingSet;
43
44    StandardImplForwardingSortedSet(SortedSet<T> backingSet) {
45      this.backingSet = backingSet;
46    }
47
48    @Override protected SortedSet<T> delegate() {
49      return backingSet;
50    }
51
52    @Override public boolean equals(Object object) {
53      return standardEquals(object);
54    }
55
56    @Override public int hashCode() {
57      return standardHashCode();
58    }
59
60    @Override public boolean addAll(Collection<? extends T> collection) {
61      return standardAddAll(collection);
62    }
63
64    @Override public void clear() {
65      standardClear();
66    }
67
68    @Override public boolean contains(Object object) {
69      return standardContains(object);
70    }
71
72    @Override public boolean containsAll(Collection<?> collection) {
73      return standardContainsAll(collection);
74    }
75
76    @Override public boolean remove(Object object) {
77      return standardRemove(object);
78    }
79
80    @Override public boolean removeAll(Collection<?> collection) {
81      return standardRemoveAll(collection);
82    }
83
84    @Override public boolean retainAll(Collection<?> collection) {
85      return standardRetainAll(collection);
86    }
87
88    @Override public Object[] toArray() {
89      return standardToArray();
90    }
91
92    @Override public <T> T[] toArray(T[] array) {
93      return standardToArray(array);
94    }
95
96    @Override public String toString() {
97      return standardToString();
98    }
99
100    @Override public SortedSet<T> subSet(T fromElement, T toElement) {
101      return standardSubSet(fromElement, toElement);
102    }
103  }
104
105  public static Test suite(){
106    TestSuite suite = new TestSuite();
107
108    suite.addTestSuite(ForwardingSortedSetTest.class);
109    suite.addTest(
110        SetTestSuiteBuilder.using(new TestStringSetGenerator() {
111          @Override protected Set<String> create(String[] elements) {
112            return new StandardImplForwardingSortedSet<String>(
113                new SafeTreeSet<String>(Arrays.asList(elements)));
114          }
115
116          @Override public List<String> order(List<String> insertionOrder) {
117            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
118          }
119        }).named(
120            "ForwardingSortedSet[SafeTreeSet] with standard implementations")
121            .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
122                CollectionFeature.GENERAL_PURPOSE).createTestSuite());
123
124    return suite;
125  }
126
127  @Override public void setUp() throws Exception {
128    super.setUp();
129    /*
130     * Class parameters must be raw, so we can't create a proxy with generic
131     * type arguments. The created proxy only records calls and returns null, so
132     * the type is irrelevant at runtime.
133     */
134    @SuppressWarnings("unchecked")
135    final SortedSet<String> sortedSet
136        = createProxyInstance(SortedSet.class);
137    forward = new ForwardingSortedSet<String>() {
138      @Override protected SortedSet<String> delegate() {
139        return sortedSet;
140      }
141    };
142  }
143
144  public void testComparator() {
145    forward().comparator();
146    assertEquals("[comparator]", getCalls());
147  }
148
149  public void testFirst() {
150    forward().first();
151    assertEquals("[first]", getCalls());
152  }
153
154  public void testHeadSet_K() {
155    forward().headSet("asdf");
156    assertEquals("[headSet(Object)]", getCalls());
157  }
158
159  public void testLast() {
160    forward().last();
161    assertEquals("[last]", getCalls());
162  }
163
164  public void testSubSet_K_K() {
165    forward().subSet("first", "last");
166    assertEquals("[subSet(Object,Object)]", getCalls());
167  }
168
169  public void testTailSet_K() {
170    forward().tailSet("last");
171    assertEquals("[tailSet(Object)]", getCalls());
172  }
173
174  @Override SortedSet<String> forward() {
175    return (SortedSet<String>) super.forward();
176  }
177}
178