ForwardingSortedMapTest.java revision 1d580d0f6ee4f21eb309ba7b509d2c6d671c4044 
1/*
2 * Copyright (C) 2007 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.MapTestSuiteBuilder;
20import com.google.common.collect.testing.SafeTreeMap;
21import com.google.common.collect.testing.TestStringMapGenerator;
22import com.google.common.collect.testing.features.CollectionFeature;
23import com.google.common.collect.testing.features.CollectionSize;
24import com.google.common.collect.testing.features.MapFeature;
25
26import junit.framework.Test;
27import junit.framework.TestSuite;
28
29import java.util.Collection;
30import java.util.Comparator;
31import java.util.Iterator;
32import java.util.List;
33import java.util.Map;
34import java.util.Map.Entry;
35import java.util.Set;
36import java.util.SortedMap;
37
38/**
39 * Tests for {@code ForwardingSortedMap}.
40 *
41 * @author Robert Konigsberg
42 */
43public class ForwardingSortedMapTest extends ForwardingMapTest {
44  static class StandardImplForwardingSortedMap<K, V>
45      extends ForwardingSortedMap<K, V> {
46    private final SortedMap<K, V> backingMap;
47
48    StandardImplForwardingSortedMap(SortedMap<K, V> backingMap) {
49      this.backingMap = backingMap;
50    }
51
52    @Override protected SortedMap<K, V> delegate() {
53      return backingMap;
54    }
55
56    @Override public boolean containsKey(Object key) {
57      return standardContainsKey(key);
58    }
59
60    @Override public boolean containsValue(Object value) {
61      return standardContainsValue(value);
62    }
63
64    @Override public void putAll(Map<? extends K, ? extends V> map) {
65      standardPutAll(map);
66    }
67
68    @Override public V remove(Object object) {
69      return standardRemove(object);
70    }
71
72    @Override public boolean equals(Object object) {
73      return standardEquals(object);
74    }
75
76    @Override public int hashCode() {
77      return standardHashCode();
78    }
79
80    @Override public Set<K> keySet() {
81      return new StandardKeySet();
82    }
83
84    @Override public Collection<V> values() {
85      return new StandardValues();
86    }
87
88    @Override public String toString() {
89      return standardToString();
90    }
91
92    @Override public Set<Entry<K, V>> entrySet() {
93      return new StandardEntrySet() {
94        @Override
95        public Iterator<Entry<K, V>> iterator() {
96          return backingMap.entrySet().iterator();
97        }
98      };
99    }
100
101    @Override public void clear() {
102      standardClear();
103    }
104
105    @Override public boolean isEmpty() {
106      return standardIsEmpty();
107    }
108
109    @Override public SortedMap<K, V> subMap(K fromKey, K toKey) {
110      return standardSubMap(fromKey, toKey);
111    }
112  }
113
114  public static Test suite() {
115    TestSuite suite = new TestSuite();
116
117    suite.addTestSuite(ForwardingSortedMapTest.class);
118    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
119      @Override protected Map<String, String> create(
120          Entry<String, String>[] entries) {
121        SortedMap<String, String> map = new SafeTreeMap<String, String>();
122        for (Entry<String, String> entry : entries) {
123          map.put(entry.getKey(), entry.getValue());
124        }
125        return new StandardImplForwardingSortedMap<String, String>(map);
126      }
127
128      @Override public Iterable<Entry<String, String>> order(
129          List<Entry<String, String>> insertionOrder) {
130        return sort(insertionOrder);
131      }
132    }).named("ForwardingSortedMap[SafeTreeMap] with no comparator and standard "
133        + "implementations").withFeatures(CollectionSize.ANY,
134        CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
135        MapFeature.GENERAL_PURPOSE).createTestSuite());
136    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
137      private final Comparator<String> comparator =
138          Ordering.natural().nullsFirst();
139
140      @Override protected Map<String, String> create(
141          Entry<String, String>[] entries) {
142        SortedMap<String, String> map =
143            new SafeTreeMap<String, String>(comparator);
144        for (Entry<String, String> entry : entries) {
145          map.put(entry.getKey(), entry.getValue());
146        }
147        return new StandardImplForwardingSortedMap<String, String>(map);
148      }
149
150      @Override public Iterable<Entry<String, String>> order(
151          List<Entry<String, String>> insertionOrder) {
152        return sort(insertionOrder);
153      }
154    }).named("ForwardingSortedMap[SafeTreeMap] with natural comparator and "
155        + "standard implementations").withFeatures(CollectionSize.ANY,
156        CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
157        MapFeature.ALLOWS_NULL_KEYS, MapFeature.GENERAL_PURPOSE)
158        .createTestSuite());
159    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
160      @Override protected Map<String, String> create(
161          Entry<String, String>[] entries) {
162        ImmutableSortedMap.Builder<String, String> builder =
163            ImmutableSortedMap.naturalOrder();
164        for (Entry<String, String> entry : entries) {
165          builder.put(entry.getKey(), entry.getValue());
166        }
167        return new StandardImplForwardingSortedMap<String, String>(
168            builder.build());
169      }
170
171      @Override public Iterable<Entry<String, String>> order(
172          List<Entry<String, String>> insertionOrder) {
173        return sort(insertionOrder);
174      }
175    }).named("ForwardingSortedMap[ImmutableSortedMap] with standard "
176        + "implementations").withFeatures(
177        CollectionSize.ANY, MapFeature.REJECTS_DUPLICATES_AT_CREATION,
178        MapFeature.ALLOWS_NULL_QUERIES)
179        .createTestSuite());
180
181    return suite;
182  }
183
184  private static Iterable<Entry<String, String>> sort(
185      List<Entry<String, String>> entries) {
186    SortedMap<String, String> map =
187        new SafeTreeMap<String, String>(Ordering.natural().nullsFirst());
188    for (Entry<String, String> entry : entries) {
189      map.put(entry.getKey(), entry.getValue());
190    }
191    return map.entrySet();
192  }
193
194  @Override public void setUp() throws Exception {
195    super.setUp();
196    /*
197     * Class parameters must be raw, so we can't create a proxy with generic
198     * type arguments. The created proxy only records calls and returns null, so
199     * the type is irrelevant at runtime.
200     */
201    @SuppressWarnings("unchecked")
202    final SortedMap<String, Boolean> sortedMap =
203        createProxyInstance(SortedMap.class);
204    forward = new ForwardingSortedMap<String, Boolean>() {
205      @Override protected SortedMap<String, Boolean> delegate() {
206        return sortedMap;
207      }
208    };
209  }
210
211  public void testComparator() {
212    forward().comparator();
213    assertEquals("[comparator]", getCalls());
214  }
215
216  public void testFirstKey() {
217    forward().firstKey();
218    assertEquals("[firstKey]", getCalls());
219  }
220
221  public void testHeadMap_K() {
222    forward().headMap("asdf");
223    assertEquals("[headMap(Object)]", getCalls());
224  }
225
226  public void testLastKey() {
227    forward().lastKey();
228    assertEquals("[lastKey]", getCalls());
229  }
230
231  public void testSubMap_K_K() {
232    forward().subMap("first", "last");
233    assertEquals("[subMap(Object,Object)]", getCalls());
234  }
235
236  public void testTailMap_K() {
237    forward().tailMap("last");
238    assertEquals("[tailMap(Object)]", getCalls());
239  }
240
241  @Override SortedMap<String, Boolean> forward() {
242    return (SortedMap<String, Boolean>) super.forward();
243  }
244}
245