Java
184 строки · 7.0 Кб
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.testing;
18
19import static com.google.common.collect.testing.Helpers.castOrCopyToList;
20import static java.util.Collections.reverse;
21
22import com.google.common.annotations.GwtIncompatible;
23import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
24import com.google.common.collect.testing.DerivedCollectionGenerators.ForwardingTestMapGenerator;
25import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
26import com.google.common.collect.testing.features.Feature;
27import com.google.common.collect.testing.testers.NavigableMapNavigationTester;
28import java.util.ArrayList;
29import java.util.List;
30import java.util.Map;
31import java.util.Map.Entry;
32import java.util.NavigableMap;
33import java.util.SortedMap;
34import 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
41public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {
42public static <K, V> NavigableMapTestSuiteBuilder<K, V> using(
43TestSortedMapGenerator<K, V> generator) {
44NavigableMapTestSuiteBuilder<K, V> result = new NavigableMapTestSuiteBuilder<>();
45result.usingGenerator(generator);
46return result;
47}
48
49@SuppressWarnings("rawtypes") // class literals
50@Override
51protected List<Class<? extends AbstractTester>> getTesters() {
52List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
53testers.add(NavigableMapNavigationTester.class);
54return testers;
55}
56
57@Override
58protected List<TestSuite> createDerivedSuites(
59FeatureSpecificTestSuiteBuilder<
60?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
61parentBuilder) {
62List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
63
64if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
65derivedSuites.add(createDescendingSuite(parentBuilder));
66}
67
68if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
69// Other combinations are inherited from SortedMapTestSuiteBuilder.
70derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
71derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
72derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
73derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
74derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
75}
76
77return derivedSuites;
78}
79
80@Override
81protected NavigableSetTestSuiteBuilder<K> createDerivedKeySetSuite(
82TestSetGenerator<K> keySetGenerator) {
83return NavigableSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator);
84}
85
86public static final class NavigableMapSubmapTestMapGenerator<K, V>
87extends SortedMapSubmapTestMapGenerator<K, V> {
88public NavigableMapSubmapTestMapGenerator(
89TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
90super(delegate, to, from);
91}
92
93@Override
94NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive, K lastExclusive) {
95NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
96if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
97return map.headMap(lastInclusive, true);
98} else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
99return map.tailMap(firstExclusive, false);
100} else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
101return map.subMap(firstExclusive, false, lastExclusive, false);
102} else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
103return map.subMap(firstExclusive, false, lastInclusive, true);
104} else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
105return map.subMap(firstInclusive, true, lastInclusive, true);
106} else {
107return (NavigableMap<K, V>) super.createSubMap(map, firstExclusive, lastExclusive);
108}
109}
110}
111
112@Override
113public NavigableMapTestSuiteBuilder<K, V> newBuilderUsing(
114TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
115return subSuiteUsing(new NavigableMapSubmapTestMapGenerator<K, V>(delegate, to, from));
116}
117
118/** Create a suite whose maps are descending views of other maps. */
119private TestSuite createDescendingSuite(
120FeatureSpecificTestSuiteBuilder<
121?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
122parentBuilder) {
123TestSortedMapGenerator<K, V> delegate =
124(TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
125
126List<Feature<?>> features = new ArrayList<>();
127features.add(NoRecurse.DESCENDING);
128features.addAll(parentBuilder.getFeatures());
129
130return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
131.named(parentBuilder.getName() + " descending")
132.withFeatures(features)
133.suppressing(parentBuilder.getSuppressedTests())
134.createTestSuite();
135}
136
137NavigableMapTestSuiteBuilder<K, V> subSuiteUsing(TestSortedMapGenerator<K, V> generator) {
138return using(generator);
139}
140
141static class DescendingTestMapGenerator<K, V> extends ForwardingTestMapGenerator<K, V>
142implements TestSortedMapGenerator<K, V> {
143DescendingTestMapGenerator(TestSortedMapGenerator<K, V> delegate) {
144super(delegate);
145}
146
147@Override
148public NavigableMap<K, V> create(Object... entries) {
149NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
150return map.descendingMap();
151}
152
153@Override
154public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
155insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
156reverse(insertionOrder);
157return insertionOrder;
158}
159
160TestSortedMapGenerator<K, V> delegate() {
161return (TestSortedMapGenerator<K, V>) delegate;
162}
163
164@Override
165public Entry<K, V> belowSamplesLesser() {
166return delegate().aboveSamplesGreater();
167}
168
169@Override
170public Entry<K, V> belowSamplesGreater() {
171return delegate().aboveSamplesLesser();
172}
173
174@Override
175public Entry<K, V> aboveSamplesLesser() {
176return delegate().belowSamplesGreater();
177}
178
179@Override
180public Entry<K, V> aboveSamplesGreater() {
181return delegate().belowSamplesLesser();
182}
183}
184}
185