1 /*
2 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import java.io.ByteArrayInputStream;
25 import java.io.ByteArrayOutputStream;
26 import java.io.IOException;
27 import java.io.ObjectInputStream;
28 import java.io.ObjectOutputStream;
29 import java.util.ArrayList;
30 import java.util.Arrays;
31 import java.util.Collections;
32 import java.util.Iterator;
33 import java.util.HashSet;
34 import java.util.List;
35 import java.util.Set;
36 import java.util.stream.Collectors;
37 import static org.testng.Assert.assertEquals;
38
39 import org.testng.annotations.DataProvider;
40 import org.testng.annotations.Test;
41
42 import static org.testng.Assert.assertFalse;
43 import static org.testng.Assert.assertNotEquals;
44 import static org.testng.Assert.assertNotSame;
45 import static org.testng.Assert.assertSame;
46 import static org.testng.Assert.assertTrue;
47 import static org.testng.Assert.fail;
48
49 /*
50 * @test
51 * @bug 8048330
52 * @summary Test convenience static factory methods on Set.
53 * @run testng SetFactories
54 */
55
56
57 public class SetFactories {
58
59 static final int NUM_STRINGS = 20; // should be larger than the largest fixed-arg overload
60 static final String[] stringArray;
61 static {
62 String[] sa = new String[NUM_STRINGS];
63 for (int i = 0; i < NUM_STRINGS; i++) {
64 sa[i] = String.valueOf((char)('a' + i));
65 }
66 stringArray = sa;
67 }
68
69 static Object[] a(Set<String> act, Set<String> exp) {
70 return new Object[] { act, exp };
71 }
72
73 static Set<String> hashSetOf(String... args) {
74 return new HashSet<>(Arrays.asList(args));
75 }
76
77 @DataProvider(name="empty")
78 public Iterator<Object[]> empty() {
79 return Collections.singletonList(
80 // actual, expected
81 a(Set.of(), Collections.emptySet())
82 ).iterator();
83 }
84
85 @DataProvider(name="nonempty")
86 public Iterator<Object[]> nonempty() {
87 return Arrays.asList(
88 // actual, expected
89 a( Set.of("a"),
90 hashSetOf("a")),
91 a( Set.of("a", "b"),
92 hashSetOf("a", "b")),
93 a( Set.of("a", "b", "c"),
94 hashSetOf("a", "b", "c")),
95 a( Set.of("a", "b", "c", "d"),
96 hashSetOf("a", "b", "c", "d")),
97 a( Set.of("a", "b", "c", "d", "e"),
98 hashSetOf("a", "b", "c", "d", "e")),
99 a( Set.of("a", "b", "c", "d", "e", "f"),
100 hashSetOf("a", "b", "c", "d", "e", "f")),
101 a( Set.of("a", "b", "c", "d", "e", "f", "g"),
102 hashSetOf("a", "b", "c", "d", "e", "f", "g")),
103 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h"),
104 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h")),
105 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i"),
106 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h", "i")),
107 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
108 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h", "i", "j")),
109 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
110 Set.of("j", "i", "h", "g", "f", "e", "d", "c", "b", "a")),
111 a( Set.of(stringArray),
112 hashSetOf(stringArray))
113 ).iterator();
114 }
115
116 @DataProvider(name="all")
117 public Iterator<Object[]> all() {
118 List<Object[]> all = new ArrayList<>();
119 empty().forEachRemaining(all::add);
120 nonempty().forEachRemaining(all::add);
121 return all.iterator();
122 }
123
124 @Test(dataProvider="all", expectedExceptions=UnsupportedOperationException.class)
125 public void cannotAdd(Set<String> act, Set<String> exp) {
126 act.add("x");
127 }
128
129 @Test(dataProvider="nonempty", expectedExceptions=UnsupportedOperationException.class)
130 public void cannotRemove(Set<String> act, Set<String> exp) {
131 act.remove(act.iterator().next());
132 }
133
134 @Test(dataProvider="all")
135 public void contentsMatch(Set<String> act, Set<String> exp) {
136 assertEquals(act, exp);
137 }
138
139 @Test(expectedExceptions=IllegalArgumentException.class)
140 public void dupsDisallowed2() {
141 Set<String> set = Set.of("a", "a");
142 }
143
144 @Test(expectedExceptions=IllegalArgumentException.class)
145 public void dupsDisallowed3() {
146 Set<String> set = Set.of("a", "b", "a");
147 }
148
149 @Test(expectedExceptions=IllegalArgumentException.class)
150 public void dupsDisallowed4() {
151 Set<String> set = Set.of("a", "b", "c", "a");
152 }
153
154 @Test(expectedExceptions=IllegalArgumentException.class)
155 public void dupsDisallowed5() {
156 Set<String> set = Set.of("a", "b", "c", "d", "a");
157 }
158
159 @Test(expectedExceptions=IllegalArgumentException.class)
160 public void dupsDisallowed6() {
161 Set<String> set = Set.of("a", "b", "c", "d", "e", "a");
162 }
163
164 @Test(expectedExceptions=IllegalArgumentException.class)
165 public void dupsDisallowed7() {
166 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "a");
167 }
168
169 @Test(expectedExceptions=IllegalArgumentException.class)
170 public void dupsDisallowed8() {
171 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "a");
172 }
173
174 @Test(expectedExceptions=IllegalArgumentException.class)
175 public void dupsDisallowed9() {
176 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "h", "a");
177 }
178
179 @Test(expectedExceptions=IllegalArgumentException.class)
180 public void dupsDisallowed10() {
181 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "a");
182 }
183
184 @Test(expectedExceptions=IllegalArgumentException.class)
185 public void dupsDisallowedN() {
186 String[] array = stringArray.clone();
187 array[0] = array[1];
188 Set<String> set = Set.of(array);
189 }
190
191 @Test(dataProvider="all")
192 public void hashCodeEqual(Set<String> act, Set<String> exp) {
193 assertEquals(act.hashCode(), exp.hashCode());
194 }
195
196 @Test(dataProvider="all")
197 public void containsAll(Set<String> act, Set<String> exp) {
198 assertTrue(act.containsAll(exp));
199 assertTrue(exp.containsAll(act));
200 }
201
202 @Test(expectedExceptions=NullPointerException.class)
203 public void nullDisallowed1() {
204 Set.of((String)null); // force one-arg overload
205 }
206
207 @Test(expectedExceptions=NullPointerException.class)
208 public void nullDisallowed2a() {
209 Set.of("a", null);
210 }
211
212 @Test(expectedExceptions=NullPointerException.class)
213 public void nullDisallowed2b() {
214 Set.of(null, "b");
215 }
216
217 @Test(expectedExceptions=NullPointerException.class)
218 public void nullDisallowed3() {
219 Set.of("a", "b", null);
220 }
221
222 @Test(expectedExceptions=NullPointerException.class)
223 public void nullDisallowed4() {
224 Set.of("a", "b", "c", null);
225 }
226
227 @Test(expectedExceptions=NullPointerException.class)
228 public void nullDisallowed5() {
229 Set.of("a", "b", "c", "d", null);
230 }
231
232 @Test(expectedExceptions=NullPointerException.class)
233 public void nullDisallowed6() {
234 Set.of("a", "b", "c", "d", "e", null);
235 }
236
237 @Test(expectedExceptions=NullPointerException.class)
238 public void nullDisallowed7() {
239 Set.of("a", "b", "c", "d", "e", "f", null);
240 }
241
242 @Test(expectedExceptions=NullPointerException.class)
243 public void nullDisallowed8() {
244 Set.of("a", "b", "c", "d", "e", "f", "g", null);
245 }
246
247 @Test(expectedExceptions=NullPointerException.class)
248 public void nullDisallowed9() {
249 Set.of("a", "b", "c", "d", "e", "f", "g", "h", null);
250 }
251
252 @Test(expectedExceptions=NullPointerException.class)
253 public void nullDisallowed10() {
254 Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", null);
255 }
256
257 @Test(expectedExceptions=NullPointerException.class)
258 public void nullDisallowedN() {
259 String[] array = stringArray.clone();
260 array[0] = null;
261 Set.of(array);
262 }
263
264 @Test(expectedExceptions=NullPointerException.class)
265 public void nullArrayDisallowed() {
266 Set.of((Object[])null);
267 }
268
269 @Test(dataProvider="all")
270 public void serialEquality(Set<String> act, Set<String> exp) {
271 // assume that act.equals(exp) tested elsewhere
272 Set<String> copy = serialClone(act);
273 assertEquals(act, copy);
274 assertEquals(copy, exp);
275 }
276
277 @SuppressWarnings("unchecked")
278 static <T> T serialClone(T obj) {
279 try {
280 ByteArrayOutputStream baos = new ByteArrayOutputStream();
281 try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
282 oos.writeObject(obj);
283 }
284 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
285 ObjectInputStream ois = new ObjectInputStream(bais);
286 return (T) ois.readObject();
287 } catch (IOException | ClassNotFoundException e) {
288 throw new AssertionError(e);
289 }
290 }
291
292 Set<Integer> genSet() {
293 return new HashSet<>(Arrays.asList(1, 2, 3));
294 }
295
296 @Test
297 public void copyOfResultsEqual() {
298 Set<Integer> orig = genSet();
299 Set<Integer> copy = Set.copyOf(orig);
300
301 assertEquals(orig, copy);
302 assertEquals(copy, orig);
303 }
304
305 @Test
306 public void copyOfModifiedUnequal() {
307 Set<Integer> orig = genSet();
308 Set<Integer> copy = Set.copyOf(orig);
309 orig.add(4);
310
311 assertNotEquals(orig, copy);
312 assertNotEquals(copy, orig);
313 }
314
315 @Test
316 public void copyOfIdentity() {
317 Set<Integer> orig = genSet();
318 Set<Integer> copy1 = Set.copyOf(orig);
319 Set<Integer> copy2 = Set.copyOf(copy1);
320
321 assertNotSame(orig, copy1);
322 assertSame(copy1, copy2);
323 }
324
325 @Test(expectedExceptions=NullPointerException.class)
326 public void copyOfRejectsNullCollection() {
327 Set<Integer> set = Set.copyOf(null);
328 }
329
330 @Test(expectedExceptions=NullPointerException.class)
331 public void copyOfRejectsNullElements() {
332 Set<Integer> set = Set.copyOf(Arrays.asList(1, null, 3));
333 }
334
335 @Test
336 public void copyOfAcceptsDuplicates() {
337 Set<Integer> set = Set.copyOf(Arrays.asList(1, 1, 2, 3, 3, 3));
338 assertEquals(set, Set.of(1, 2, 3));
339 }
340 }