guava

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

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

19
import static com.google.common.collect.testing.Helpers.castOrCopyToList;
20
import static java.util.Collections.reverse;
21

22
import com.google.common.annotations.GwtIncompatible;
23
import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
24
import com.google.common.collect.testing.DerivedCollectionGenerators.ForwardingTestMapGenerator;
25
import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
26
import com.google.common.collect.testing.features.Feature;
27
import com.google.common.collect.testing.testers.NavigableMapNavigationTester;
28
import java.util.ArrayList;
29
import java.util.List;
30
import java.util.Map;
31
import java.util.Map.Entry;
32
import java.util.NavigableMap;
33
import java.util.SortedMap;
34
import junit.framework.TestSuite;
35

36
/**
37
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap
38
 * implementation.
39
 */
40
@GwtIncompatible
41
public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {
42
  public static <K, V> NavigableMapTestSuiteBuilder<K, V> using(
43
      TestSortedMapGenerator<K, V> generator) {
44
    NavigableMapTestSuiteBuilder<K, V> result = new NavigableMapTestSuiteBuilder<>();
45
    result.usingGenerator(generator);
46
    return result;
47
  }
48

49
  @SuppressWarnings("rawtypes") // class literals
50
  @Override
51
  protected List<Class<? extends AbstractTester>> getTesters() {
52
    List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
53
    testers.add(NavigableMapNavigationTester.class);
54
    return testers;
55
  }
56

57
  @Override
58
  protected List<TestSuite> createDerivedSuites(
59
      FeatureSpecificTestSuiteBuilder<
60
              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
61
          parentBuilder) {
62
    List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
63

64
    if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
65
      derivedSuites.add(createDescendingSuite(parentBuilder));
66
    }
67

68
    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
69
      // Other combinations are inherited from SortedMapTestSuiteBuilder.
70
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
71
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
72
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
73
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
74
      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
75
    }
76

77
    return derivedSuites;
78
  }
79

80
  @Override
81
  protected NavigableSetTestSuiteBuilder<K> createDerivedKeySetSuite(
82
      TestSetGenerator<K> keySetGenerator) {
83
    return NavigableSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator);
84
  }
85

86
  public static final class NavigableMapSubmapTestMapGenerator<K, V>
87
      extends SortedMapSubmapTestMapGenerator<K, V> {
88
    public NavigableMapSubmapTestMapGenerator(
89
        TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
90
      super(delegate, to, from);
91
    }
92

93
    @Override
94
    NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive, K lastExclusive) {
95
      NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
96
      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
97
        return map.headMap(lastInclusive, true);
98
      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
99
        return map.tailMap(firstExclusive, false);
100
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
101
        return map.subMap(firstExclusive, false, lastExclusive, false);
102
      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
103
        return map.subMap(firstExclusive, false, lastInclusive, true);
104
      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
105
        return map.subMap(firstInclusive, true, lastInclusive, true);
106
      } else {
107
        return (NavigableMap<K, V>) super.createSubMap(map, firstExclusive, lastExclusive);
108
      }
109
    }
110
  }
111

112
  @Override
113
  public NavigableMapTestSuiteBuilder<K, V> newBuilderUsing(
114
      TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
115
    return subSuiteUsing(new NavigableMapSubmapTestMapGenerator<K, V>(delegate, to, from));
116
  }
117

118
  /** Create a suite whose maps are descending views of other maps. */
119
  private TestSuite createDescendingSuite(
120
      FeatureSpecificTestSuiteBuilder<
121
              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
122
          parentBuilder) {
123
    TestSortedMapGenerator<K, V> delegate =
124
        (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
125

126
    List<Feature<?>> features = new ArrayList<>();
127
    features.add(NoRecurse.DESCENDING);
128
    features.addAll(parentBuilder.getFeatures());
129

130
    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
131
        .named(parentBuilder.getName() + " descending")
132
        .withFeatures(features)
133
        .suppressing(parentBuilder.getSuppressedTests())
134
        .createTestSuite();
135
  }
136

137
  NavigableMapTestSuiteBuilder<K, V> subSuiteUsing(TestSortedMapGenerator<K, V> generator) {
138
    return using(generator);
139
  }
140

141
  static class DescendingTestMapGenerator<K, V> extends ForwardingTestMapGenerator<K, V>
142
      implements TestSortedMapGenerator<K, V> {
143
    DescendingTestMapGenerator(TestSortedMapGenerator<K, V> delegate) {
144
      super(delegate);
145
    }
146

147
    @Override
148
    public NavigableMap<K, V> create(Object... entries) {
149
      NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
150
      return map.descendingMap();
151
    }
152

153
    @Override
154
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
155
      insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
156
      reverse(insertionOrder);
157
      return insertionOrder;
158
    }
159

160
    TestSortedMapGenerator<K, V> delegate() {
161
      return (TestSortedMapGenerator<K, V>) delegate;
162
    }
163

164
    @Override
165
    public Entry<K, V> belowSamplesLesser() {
166
      return delegate().aboveSamplesGreater();
167
    }
168

169
    @Override
170
    public Entry<K, V> belowSamplesGreater() {
171
      return delegate().aboveSamplesLesser();
172
    }
173

174
    @Override
175
    public Entry<K, V> aboveSamplesLesser() {
176
      return delegate().belowSamplesGreater();
177
    }
178

179
    @Override
180
    public Entry<K, V> aboveSamplesGreater() {
181
      return delegate().belowSamplesLesser();
182
    }
183
  }
184
}
185