guava

1
/*
2
 * Copyright (C) 2008 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

17
package com.google.common.collect.testing;
18

19
import static com.google.common.collect.testing.DerivedCollectionGenerators.keySetGenerator;
20

21
import com.google.common.annotations.GwtIncompatible;
22
import com.google.common.collect.testing.DerivedCollectionGenerators.MapEntrySetGenerator;
23
import com.google.common.collect.testing.DerivedCollectionGenerators.MapValueCollectionGenerator;
24
import com.google.common.collect.testing.features.CollectionFeature;
25
import com.google.common.collect.testing.features.CollectionSize;
26
import com.google.common.collect.testing.features.Feature;
27
import com.google.common.collect.testing.features.MapFeature;
28
import com.google.common.collect.testing.testers.MapClearTester;
29
import com.google.common.collect.testing.testers.MapComputeIfAbsentTester;
30
import com.google.common.collect.testing.testers.MapComputeIfPresentTester;
31
import com.google.common.collect.testing.testers.MapComputeTester;
32
import com.google.common.collect.testing.testers.MapContainsKeyTester;
33
import com.google.common.collect.testing.testers.MapContainsValueTester;
34
import com.google.common.collect.testing.testers.MapCreationTester;
35
import com.google.common.collect.testing.testers.MapEntrySetTester;
36
import com.google.common.collect.testing.testers.MapEqualsTester;
37
import com.google.common.collect.testing.testers.MapForEachTester;
38
import com.google.common.collect.testing.testers.MapGetOrDefaultTester;
39
import com.google.common.collect.testing.testers.MapGetTester;
40
import com.google.common.collect.testing.testers.MapHashCodeTester;
41
import com.google.common.collect.testing.testers.MapIsEmptyTester;
42
import com.google.common.collect.testing.testers.MapMergeTester;
43
import com.google.common.collect.testing.testers.MapPutAllTester;
44
import com.google.common.collect.testing.testers.MapPutIfAbsentTester;
45
import com.google.common.collect.testing.testers.MapPutTester;
46
import com.google.common.collect.testing.testers.MapRemoveEntryTester;
47
import com.google.common.collect.testing.testers.MapRemoveTester;
48
import com.google.common.collect.testing.testers.MapReplaceAllTester;
49
import com.google.common.collect.testing.testers.MapReplaceEntryTester;
50
import com.google.common.collect.testing.testers.MapReplaceTester;
51
import com.google.common.collect.testing.testers.MapSerializationTester;
52
import com.google.common.collect.testing.testers.MapSizeTester;
53
import com.google.common.collect.testing.testers.MapToStringTester;
54
import com.google.common.testing.SerializableTester;
55
import java.util.Arrays;
56
import java.util.HashSet;
57
import java.util.List;
58
import java.util.Map;
59
import java.util.Map.Entry;
60
import java.util.Set;
61
import junit.framework.TestSuite;
62

63
/**
64
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a Map implementation.
65
 *
66
 * @author George van den Driessche
67
 */
68
@GwtIncompatible
69
public class MapTestSuiteBuilder<K, V>
70
    extends PerCollectionSizeTestSuiteBuilder<
71
        MapTestSuiteBuilder<K, V>, TestMapGenerator<K, V>, Map<K, V>, Entry<K, V>> {
72
  public static <K, V> MapTestSuiteBuilder<K, V> using(TestMapGenerator<K, V> generator) {
73
    return new MapTestSuiteBuilder<K, V>().usingGenerator(generator);
74
  }
75

76
  @SuppressWarnings("rawtypes") // class literals
77
  @Override
78
  protected List<Class<? extends AbstractTester>> getTesters() {
79
    return Arrays.<Class<? extends AbstractTester>>asList(
80
        MapClearTester.class,
81
        MapComputeTester.class,
82
        MapComputeIfAbsentTester.class,
83
        MapComputeIfPresentTester.class,
84
        MapContainsKeyTester.class,
85
        MapContainsValueTester.class,
86
        MapCreationTester.class,
87
        MapEntrySetTester.class,
88
        MapEqualsTester.class,
89
        MapForEachTester.class,
90
        MapGetTester.class,
91
        MapGetOrDefaultTester.class,
92
        MapHashCodeTester.class,
93
        MapIsEmptyTester.class,
94
        MapMergeTester.class,
95
        MapPutTester.class,
96
        MapPutAllTester.class,
97
        MapPutIfAbsentTester.class,
98
        MapRemoveTester.class,
99
        MapRemoveEntryTester.class,
100
        MapReplaceTester.class,
101
        MapReplaceAllTester.class,
102
        MapReplaceEntryTester.class,
103
        MapSerializationTester.class,
104
        MapSizeTester.class,
105
        MapToStringTester.class);
106
  }
107

108
  @Override
109
  protected List<TestSuite> createDerivedSuites(
110
      FeatureSpecificTestSuiteBuilder<
111
              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
112
          parentBuilder) {
113
    // TODO: Once invariant support is added, supply invariants to each of the
114
    // derived suites, to check that mutations to the derived collections are
115
    // reflected in the underlying map.
116

117
    List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
118

119
    if (parentBuilder.getFeatures().contains(CollectionFeature.SERIALIZABLE)) {
120
      derivedSuites.add(
121
          MapTestSuiteBuilder.using(
122
                  new ReserializedMapGenerator<K, V>(parentBuilder.getSubjectGenerator()))
123
              .withFeatures(computeReserializedMapFeatures(parentBuilder.getFeatures()))
124
              .named(parentBuilder.getName() + " reserialized")
125
              .suppressing(parentBuilder.getSuppressedTests())
126
              .withSetUp(parentBuilder.getSetUp())
127
              .withTearDown(parentBuilder.getTearDown())
128
              .createTestSuite());
129
    }
130

131
    derivedSuites.add(
132
        createDerivedEntrySetSuite(
133
                new MapEntrySetGenerator<K, V>(parentBuilder.getSubjectGenerator()))
134
            .withFeatures(computeEntrySetFeatures(parentBuilder.getFeatures()))
135
            .named(parentBuilder.getName() + " entrySet")
136
            .suppressing(parentBuilder.getSuppressedTests())
137
            .withSetUp(parentBuilder.getSetUp())
138
            .withTearDown(parentBuilder.getTearDown())
139
            .createTestSuite());
140

141
    derivedSuites.add(
142
        createDerivedKeySetSuite(keySetGenerator(parentBuilder.getSubjectGenerator()))
143
            .withFeatures(computeKeySetFeatures(parentBuilder.getFeatures()))
144
            .named(parentBuilder.getName() + " keys")
145
            .suppressing(parentBuilder.getSuppressedTests())
146
            .withSetUp(parentBuilder.getSetUp())
147
            .withTearDown(parentBuilder.getTearDown())
148
            .createTestSuite());
149

150
    derivedSuites.add(
151
        createDerivedValueCollectionSuite(
152
                new MapValueCollectionGenerator<K, V>(parentBuilder.getSubjectGenerator()))
153
            .named(parentBuilder.getName() + " values")
154
            .withFeatures(computeValuesCollectionFeatures(parentBuilder.getFeatures()))
155
            .suppressing(parentBuilder.getSuppressedTests())
156
            .withSetUp(parentBuilder.getSetUp())
157
            .withTearDown(parentBuilder.getTearDown())
158
            .createTestSuite());
159

160
    return derivedSuites;
161
  }
162

163
  protected SetTestSuiteBuilder<Entry<K, V>> createDerivedEntrySetSuite(
164
      TestSetGenerator<Entry<K, V>> entrySetGenerator) {
165
    return SetTestSuiteBuilder.using(entrySetGenerator);
166
  }
167

168
  protected SetTestSuiteBuilder<K> createDerivedKeySetSuite(TestSetGenerator<K> keySetGenerator) {
169
    return SetTestSuiteBuilder.using(keySetGenerator);
170
  }
171

172
  protected CollectionTestSuiteBuilder<V> createDerivedValueCollectionSuite(
173
      TestCollectionGenerator<V> valueCollectionGenerator) {
174
    return CollectionTestSuiteBuilder.using(valueCollectionGenerator);
175
  }
176

177
  private static Set<Feature<?>> computeReserializedMapFeatures(Set<Feature<?>> mapFeatures) {
178
    Set<Feature<?>> derivedFeatures = Helpers.copyToSet(mapFeatures);
179
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
180
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
181
    return derivedFeatures;
182
  }
183

184
  private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {
185
    Set<Feature<?>> entrySetFeatures = computeCommonDerivedCollectionFeatures(mapFeatures);
186
    if (mapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
187
      entrySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
188
    }
189
    return entrySetFeatures;
190
  }
191

192
  private static Set<Feature<?>> computeKeySetFeatures(Set<Feature<?>> mapFeatures) {
193
    Set<Feature<?>> keySetFeatures = computeCommonDerivedCollectionFeatures(mapFeatures);
194

195
    // TODO(lowasser): make this trigger only if the map is a submap
196
    // currently, the KeySetGenerator won't work properly for a subset of a keyset of a submap
197
    keySetFeatures.add(CollectionFeature.SUBSET_VIEW);
198
    if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
199
      keySetFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
200
    } else if (mapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
201
      keySetFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
202
    }
203

204
    return keySetFeatures;
205
  }
206

207
  private static Set<Feature<?>> computeValuesCollectionFeatures(Set<Feature<?>> mapFeatures) {
208
    Set<Feature<?>> valuesCollectionFeatures = computeCommonDerivedCollectionFeatures(mapFeatures);
209
    if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
210
      valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_QUERIES);
211
    }
212
    if (mapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
213
      valuesCollectionFeatures.add(CollectionFeature.ALLOWS_NULL_VALUES);
214
    }
215

216
    return valuesCollectionFeatures;
217
  }
218

219
  public static Set<Feature<?>> computeCommonDerivedCollectionFeatures(
220
      Set<Feature<?>> mapFeatures) {
221
    mapFeatures = new HashSet<>(mapFeatures);
222
    Set<Feature<?>> derivedFeatures = new HashSet<>();
223
    mapFeatures.remove(CollectionFeature.SERIALIZABLE);
224
    if (mapFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
225
      derivedFeatures.add(CollectionFeature.SERIALIZABLE);
226
    }
227
    if (mapFeatures.contains(MapFeature.SUPPORTS_REMOVE)) {
228
      derivedFeatures.add(CollectionFeature.SUPPORTS_REMOVE);
229
    }
230
    if (mapFeatures.contains(MapFeature.REJECTS_DUPLICATES_AT_CREATION)) {
231
      derivedFeatures.add(CollectionFeature.REJECTS_DUPLICATES_AT_CREATION);
232
    }
233
    if (mapFeatures.contains(MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION)) {
234
      derivedFeatures.add(CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION);
235
    }
236
    // add the intersection of CollectionFeature.values() and mapFeatures
237
    for (CollectionFeature feature : CollectionFeature.values()) {
238
      if (mapFeatures.contains(feature)) {
239
        derivedFeatures.add(feature);
240
      }
241
    }
242
    // add the intersection of CollectionSize.values() and mapFeatures
243
    for (CollectionSize size : CollectionSize.values()) {
244
      if (mapFeatures.contains(size)) {
245
        derivedFeatures.add(size);
246
      }
247
    }
248
    return derivedFeatures;
249
  }
250

251
  private static class ReserializedMapGenerator<K, V> implements TestMapGenerator<K, V> {
252
    private final OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator;
253

254
    public ReserializedMapGenerator(
255
        OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator) {
256
      this.mapGenerator = mapGenerator;
257
    }
258

259
    @Override
260
    public SampleElements<Entry<K, V>> samples() {
261
      return mapGenerator.samples();
262
    }
263

264
    @Override
265
    public Entry<K, V>[] createArray(int length) {
266
      return mapGenerator.createArray(length);
267
    }
268

269
    @Override
270
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
271
      return mapGenerator.order(insertionOrder);
272
    }
273

274
    @Override
275
    public Map<K, V> create(Object... elements) {
276
      return SerializableTester.reserialize(mapGenerator.create(elements));
277
    }
278

279
    @Override
280
    public K[] createKeyArray(int length) {
281
      return ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator()).createKeyArray(length);
282
    }
283

284
    @Override
285
    public V[] createValueArray(int length) {
286
      return ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator()).createValueArray(length);
287
    }
288
  }
289
}
290