Debian Codegraph @

guava-testlib/src/com/google/common/collect/testing/testers/CollectionRetainAllTester.java

raw
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.testers;
18
19 import static com.google.common.collect.testing.features.CollectionFeature.ALLOWS_NULL_VALUES;
20 import static com.google.common.collect.testing.features.CollectionFeature.SUPPORTS_REMOVE;
21 import static com.google.common.collect.testing.features.CollectionSize.ONE;
22 import static com.google.common.collect.testing.features.CollectionSize.ZERO;
23
24 import com.google.common.annotations.GwtCompatible;
25 import com.google.common.collect.testing.AbstractCollectionTester;
26 import com.google.common.collect.testing.MinimalCollection;
27 import com.google.common.collect.testing.features.CollectionFeature;
28 import com.google.common.collect.testing.features.CollectionSize;
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Collections;
32 import java.util.List;
33 import org.junit.Ignore;
34
35 /**
36 * A generic JUnit test which tests {@code retainAll} operations on a collection. Can't be invoked
37 * directly; please see {@link com.google.common.collect.testing.CollectionTestSuiteBuilder}.
38 *
39 * @author Chris Povirk
40 */
41 @SuppressWarnings("unchecked") // too many "unchecked generic array creations"
42 @GwtCompatible
43 @Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
44 public class CollectionRetainAllTester<E> extends AbstractCollectionTester<E> {
45
46 /** A collection of elements to retain, along with a description for use in failure messages. */
47 private class Target {
48 private final Collection<E> toRetain;
49 private final String description;
50
51 private Target(Collection<E> toRetain, String description) {
52 this.toRetain = toRetain;
53 this.description = description;
54 }
55
56 @Override
57 public String toString() {
58 return description;
59 }
60 }
61
62 private Target empty;
63 private Target disjoint;
64 private Target superset;
65 private Target nonEmptyProperSubset;
66 private Target sameElements;
67 private Target partialOverlap;
68 private Target containsDuplicates;
69 private Target nullSingleton;
70
71 @Override
72 public void setUp() throws Exception {
73 super.setUp();
74
75 empty = new Target(emptyCollection(), "empty");
76 /*
77 * We test that nullSingleton.retainAll(disjointList) does NOT throw a
78 * NullPointerException when disjointList does not, so we can't use
79 * MinimalCollection, which throws NullPointerException on calls to
80 * contains(null).
81 */
82 List<E> disjointList = Arrays.asList(e3(), e4());
83 disjoint = new Target(disjointList, "disjoint");
84 superset = new Target(MinimalCollection.of(e0(), e1(), e2(), e3(), e4()), "superset");
85 nonEmptyProperSubset = new Target(MinimalCollection.of(e1()), "subset");
86 sameElements = new Target(Arrays.asList(createSamplesArray()), "sameElements");
87 containsDuplicates =
88 new Target(MinimalCollection.of(e0(), e0(), e3(), e3()), "containsDuplicates");
89 partialOverlap = new Target(MinimalCollection.of(e2(), e3()), "partialOverlap");
90 nullSingleton = new Target(Collections.<E>singleton(null), "nullSingleton");
91 }
92
93 // retainAll(empty)
94
95 @CollectionFeature.Require(SUPPORTS_REMOVE)
96 @CollectionSize.Require(ZERO)
97 public void testRetainAll_emptyPreviouslyEmpty() {
98 expectReturnsFalse(empty);
99 expectUnchanged();
100 }
101
102 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
103 @CollectionSize.Require(ZERO)
104 public void testRetainAll_emptyPreviouslyEmptyUnsupported() {
105 expectReturnsFalseOrThrows(empty);
106 expectUnchanged();
107 }
108
109 @CollectionFeature.Require(SUPPORTS_REMOVE)
110 @CollectionSize.Require(absent = ZERO)
111 public void testRetainAll_emptyPreviouslyNonEmpty() {
112 expectReturnsTrue(empty);
113 expectContents();
114 expectMissing(e0(), e1(), e2());
115 }
116
117 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
118 @CollectionSize.Require(absent = ZERO)
119 public void testRetainAll_emptyPreviouslyNonEmptyUnsupported() {
120 expectThrows(empty);
121 expectUnchanged();
122 }
123
124 // retainAll(disjoint)
125
126 @CollectionFeature.Require(SUPPORTS_REMOVE)
127 @CollectionSize.Require(ZERO)
128 public void testRetainAll_disjointPreviouslyEmpty() {
129 expectReturnsFalse(disjoint);
130 expectUnchanged();
131 }
132
133 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
134 @CollectionSize.Require(ZERO)
135 public void testRetainAll_disjointPreviouslyEmptyUnsupported() {
136 expectReturnsFalseOrThrows(disjoint);
137 expectUnchanged();
138 }
139
140 @CollectionFeature.Require(SUPPORTS_REMOVE)
141 @CollectionSize.Require(absent = ZERO)
142 public void testRetainAll_disjointPreviouslyNonEmpty() {
143 expectReturnsTrue(disjoint);
144 expectContents();
145 expectMissing(e0(), e1(), e2());
146 }
147
148 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
149 @CollectionSize.Require(absent = ZERO)
150 public void testRetainAll_disjointPreviouslyNonEmptyUnsupported() {
151 expectThrows(disjoint);
152 expectUnchanged();
153 }
154
155 // retainAll(superset)
156
157 @CollectionFeature.Require(SUPPORTS_REMOVE)
158 public void testRetainAll_superset() {
159 expectReturnsFalse(superset);
160 expectUnchanged();
161 }
162
163 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
164 public void testRetainAll_supersetUnsupported() {
165 expectReturnsFalseOrThrows(superset);
166 expectUnchanged();
167 }
168
169 // retainAll(subset)
170
171 @CollectionFeature.Require(SUPPORTS_REMOVE)
172 @CollectionSize.Require(absent = {ZERO, ONE})
173 public void testRetainAll_subset() {
174 expectReturnsTrue(nonEmptyProperSubset);
175 expectContents(nonEmptyProperSubset.toRetain);
176 }
177
178 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
179 @CollectionSize.Require(absent = {ZERO, ONE})
180 public void testRetainAll_subsetUnsupported() {
181 expectThrows(nonEmptyProperSubset);
182 expectUnchanged();
183 }
184
185 // retainAll(sameElements)
186
187 @CollectionFeature.Require(SUPPORTS_REMOVE)
188 public void testRetainAll_sameElements() {
189 expectReturnsFalse(sameElements);
190 expectUnchanged();
191 }
192
193 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
194 public void testRetainAll_sameElementsUnsupported() {
195 expectReturnsFalseOrThrows(sameElements);
196 expectUnchanged();
197 }
198
199 // retainAll(partialOverlap)
200
201 @CollectionFeature.Require(SUPPORTS_REMOVE)
202 @CollectionSize.Require(absent = {ZERO, ONE})
203 public void testRetainAll_partialOverlap() {
204 expectReturnsTrue(partialOverlap);
205 expectContents(e2());
206 }
207
208 @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
209 @CollectionSize.Require(absent = {ZERO, ONE})
210 public void testRetainAll_partialOverlapUnsupported() {
211 expectThrows(partialOverlap);
212 expectUnchanged();
213 }
214
215 // retainAll(containsDuplicates)
216
217 @CollectionFeature.Require(SUPPORTS_REMOVE)
218 @CollectionSize.Require(ONE)
219 public void testRetainAll_containsDuplicatesSizeOne() {
220 expectReturnsFalse(containsDuplicates);
221 expectContents(e0());
222 }
223
224 @CollectionFeature.Require(SUPPORTS_REMOVE)
225 @CollectionSize.Require(absent = {ZERO, ONE})
226 public void testRetainAll_containsDuplicatesSizeSeveral() {
227 expectReturnsTrue(containsDuplicates);
228 expectContents(e0());
229 }
230
231 // retainAll(nullSingleton)
232
233 @CollectionFeature.Require(SUPPORTS_REMOVE)
234 @CollectionSize.Require(ZERO)
235 public void testRetainAll_nullSingletonPreviouslyEmpty() {
236 expectReturnsFalse(nullSingleton);
237 expectUnchanged();
238 }
239
240 @CollectionFeature.Require(SUPPORTS_REMOVE)
241 @CollectionSize.Require(absent = ZERO)
242 public void testRetainAll_nullSingletonPreviouslyNonEmpty() {
243 expectReturnsTrue(nullSingleton);
244 expectContents();
245 }
246
247 @CollectionFeature.Require({SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})
248 @CollectionSize.Require(ONE)
249 public void testRetainAll_nullSingletonPreviouslySingletonWithNull() {
250 initCollectionWithNullElement();
251 expectReturnsFalse(nullSingleton);
252 expectContents(createArrayWithNullElement());
253 }
254
255 @CollectionFeature.Require({SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})
256 @CollectionSize.Require(absent = {ZERO, ONE})
257 public void testRetainAll_nullSingletonPreviouslySeveralWithNull() {
258 initCollectionWithNullElement();
259 expectReturnsTrue(nullSingleton);
260 expectContents(nullSingleton.toRetain);
261 }
262
263 // nullSingleton.retainAll()
264
265 @CollectionFeature.Require({SUPPORTS_REMOVE, ALLOWS_NULL_VALUES})
266 @CollectionSize.Require(absent = ZERO)
267 public void testRetainAll_containsNonNullWithNull() {
268 initCollectionWithNullElement();
269 expectReturnsTrue(disjoint);
270 expectContents();
271 }
272
273 // retainAll(null)
274
275 /*
276 * AbstractCollection fails the retainAll(null) test when the subject
277 * collection is empty, but we'd still like to test retainAll(null) when we
278 * can. We split the test into empty and non-empty cases. This allows us to
279 * suppress only the former.
280 */
281
282 @CollectionFeature.Require(SUPPORTS_REMOVE)
283 @CollectionSize.Require(ZERO)
284 public void testRetainAll_nullCollectionReferenceEmptySubject() {
285 try {
286 collection.retainAll(null);
287 // Returning successfully is not ideal, but tolerated.
288 } catch (NullPointerException tolerated) {
289 }
290 }
291
292 @CollectionFeature.Require(SUPPORTS_REMOVE)
293 @CollectionSize.Require(absent = ZERO)
294 public void testRetainAll_nullCollectionReferenceNonEmptySubject() {
295 try {
296 collection.retainAll(null);
297 fail("retainAll(null) should throw NullPointerException");
298 } catch (NullPointerException expected) {
299 }
300 }
301
302 private void expectReturnsTrue(Target target) {
303 String message = Platform.format("retainAll(%s) should return true", target);
304 assertTrue(message, collection.retainAll(target.toRetain));
305 }
306
307 private void expectReturnsFalse(Target target) {
308 String message = Platform.format("retainAll(%s) should return false", target);
309 assertFalse(message, collection.retainAll(target.toRetain));
310 }
311
312 private void expectThrows(Target target) {
313 try {
314 collection.retainAll(target.toRetain);
315 String message = Platform.format("retainAll(%s) should throw", target);
316 fail(message);
317 } catch (UnsupportedOperationException expected) {
318 }
319 }
320
321 private void expectReturnsFalseOrThrows(Target target) {
322 String message = Platform.format("retainAll(%s) should return false or throw", target);
323 try {
324 assertFalse(message, collection.retainAll(target.toRetain));
325 } catch (UnsupportedOperationException tolerated) {
326 }
327 }
328 }