Coverage Summary for Class: NavigableMapTestSuiteBuilder (com.google.common.collect.testing)

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