1 /*
2 * Copyright (c) 2015, 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.assertTrue;
44 import static org.testng.Assert.fail;
45
46 /*
47 * @test
48 * @bug 8048330
49 * @summary Test convenience static factory methods on Set.
50 * @run testng SetFactories
51 */
52
53
54 public class SetFactories {
55
56 static final int NUM_STRINGS = 20; // should be larger than the largest fixed-arg overload
57 static final String[] stringArray;
58 static {
59 String[] sa = new String[NUM_STRINGS];
60 for (int i = 0; i < NUM_STRINGS; i++) {
61 sa[i] = String.valueOf((char)('a' + i));
62 }
63 stringArray = sa;
64 }
65
66 static Object[] a(Set<String> act, Set<String> exp) {
67 return new Object[] { act, exp };
68 }
69
70 static Set<String> hashSetOf(String... args) {
71 return new HashSet<>(Arrays.asList(args));
72 }
73
74 @DataProvider(name="empty")
75 public Iterator<Object[]> empty() {
76 return Collections.singletonList(
77 // actual, expected
78 a(Set.of(), Collections.emptySet())
79 ).iterator();
80 }
81
82 @DataProvider(name="nonempty")
83 public Iterator<Object[]> nonempty() {
84 return Arrays.asList(
85 // actual, expected
86 a( Set.of("a"),
87 hashSetOf("a")),
88 a( Set.of("a", "b"),
89 hashSetOf("a", "b")),
90 a( Set.of("a", "b", "c"),
91 hashSetOf("a", "b", "c")),
92 a( Set.of("a", "b", "c", "d"),
93 hashSetOf("a", "b", "c", "d")),
94 a( Set.of("a", "b", "c", "d", "e"),
95 hashSetOf("a", "b", "c", "d", "e")),
96 a( Set.of("a", "b", "c", "d", "e", "f"),
97 hashSetOf("a", "b", "c", "d", "e", "f")),
98 a( Set.of("a", "b", "c", "d", "e", "f", "g"),
99 hashSetOf("a", "b", "c", "d", "e", "f", "g")),
100 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h"),
101 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h")),
102 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i"),
103 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h", "i")),
104 a( Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
105 hashSetOf("a", "b", "c", "d", "e", "f", "g", "h", "i", "j")),
106 a( Set.of(stringArray),
107 hashSetOf(stringArray))
108 ).iterator();
109 }
110
111 @DataProvider(name="all")
112 public Iterator<Object[]> all() {
113 List<Object[]> all = new ArrayList<>();
114 empty().forEachRemaining(all::add);
115 nonempty().forEachRemaining(all::add);
116 return all.iterator();
117 }
118
119 @Test(dataProvider="all", expectedExceptions=UnsupportedOperationException.class)
120 public void cannotAdd(Set<String> act, Set<String> exp) {
121 act.add("x");
122 }
123
124 @Test(dataProvider="nonempty", expectedExceptions=UnsupportedOperationException.class)
125 public void cannotRemove(Set<String> act, Set<String> exp) {
126 act.remove(act.iterator().next());
127 }
128
129 @Test(dataProvider="all")
130 public void contentsMatch(Set<String> act, Set<String> exp) {
131 assertEquals(act, exp);
132 }
133
134 @Test(expectedExceptions=IllegalArgumentException.class)
135 public void dupsDisallowed2() {
136 Set<String> set = Set.of("a", "a");
137 }
138
139 @Test(expectedExceptions=IllegalArgumentException.class)
140 public void dupsDisallowed3() {
141 Set<String> set = Set.of("a", "b", "a");
142 }
143
144 @Test(expectedExceptions=IllegalArgumentException.class)
145 public void dupsDisallowed4() {
146 Set<String> set = Set.of("a", "b", "c", "a");
147 }
148
149 @Test(expectedExceptions=IllegalArgumentException.class)
150 public void dupsDisallowed5() {
151 Set<String> set = Set.of("a", "b", "c", "d", "a");
152 }
153
154 @Test(expectedExceptions=IllegalArgumentException.class)
155 public void dupsDisallowed6() {
156 Set<String> set = Set.of("a", "b", "c", "d", "e", "a");
157 }
158
159 @Test(expectedExceptions=IllegalArgumentException.class)
160 public void dupsDisallowed7() {
161 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "a");
162 }
163
164 @Test(expectedExceptions=IllegalArgumentException.class)
165 public void dupsDisallowed8() {
166 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "a");
167 }
168
169 @Test(expectedExceptions=IllegalArgumentException.class)
170 public void dupsDisallowed9() {
171 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "h", "a");
172 }
173
174 @Test(expectedExceptions=IllegalArgumentException.class)
175 public void dupsDisallowed10() {
176 Set<String> set = Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", "a");
177 }
178
179 @Test(expectedExceptions=IllegalArgumentException.class)
180 public void dupsDisallowedN() {
181 String[] array = stringArray.clone();
182 array[0] = array[1];
183 Set<String> set = Set.of(array);
184 }
185
186 @Test(expectedExceptions=NullPointerException.class)
187 public void nullDisallowed1() {
188 Set.of((String)null); // force one-arg overload
189 }
190
191 @Test(expectedExceptions=NullPointerException.class)
192 public void nullDisallowed2a() {
193 Set.of("a", null);
194 }
195
196 @Test(expectedExceptions=NullPointerException.class)
197 public void nullDisallowed2b() {
198 Set.of(null, "b");
199 }
200
201 @Test(expectedExceptions=NullPointerException.class)
202 public void nullDisallowed3() {
203 Set.of("a", "b", null);
204 }
205
206 @Test(expectedExceptions=NullPointerException.class)
207 public void nullDisallowed4() {
208 Set.of("a", "b", "c", null);
209 }
210
211 @Test(expectedExceptions=NullPointerException.class)
212 public void nullDisallowed5() {
213 Set.of("a", "b", "c", "d", null);
214 }
215
216 @Test(expectedExceptions=NullPointerException.class)
217 public void nullDisallowed6() {
218 Set.of("a", "b", "c", "d", "e", null);
219 }
220
221 @Test(expectedExceptions=NullPointerException.class)
222 public void nullDisallowed7() {
223 Set.of("a", "b", "c", "d", "e", "f", null);
224 }
225
226 @Test(expectedExceptions=NullPointerException.class)
227 public void nullDisallowed8() {
228 Set.of("a", "b", "c", "d", "e", "f", "g", null);
229 }
230
231 @Test(expectedExceptions=NullPointerException.class)
232 public void nullDisallowed9() {
233 Set.of("a", "b", "c", "d", "e", "f", "g", "h", null);
234 }
235
236 @Test(expectedExceptions=NullPointerException.class)
237 public void nullDisallowed10() {
238 Set.of("a", "b", "c", "d", "e", "f", "g", "h", "i", null);
239 }
240
241 @Test(expectedExceptions=NullPointerException.class)
242 public void nullDisallowedN() {
243 String[] array = stringArray.clone();
244 array[0] = null;
245 Set.of(array);
246 }
247
248 @Test(expectedExceptions=NullPointerException.class)
249 public void nullArrayDisallowed() {
250 Set.of((Object[])null);
251 }
252
253 @Test(dataProvider="all")
254 public void serialEquality(Set<String> act, Set<String> exp) {
255 // assume that act.equals(exp) tested elsewhere
256 Set<String> copy = serialClone(act);
257 assertEquals(act, copy);
258 assertEquals(copy, exp);
259 }
260
261 @SuppressWarnings("unchecked")
262 static <T> T serialClone(T obj) {
263 try {
264 ByteArrayOutputStream baos = new ByteArrayOutputStream();
265 ObjectOutputStream oos = new ObjectOutputStream(baos);
266 oos.writeObject(obj);
267 oos.close();
268 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
269 ObjectInputStream ois = new ObjectInputStream(bais);
270 return (T) ois.readObject();
271 } catch (IOException | ClassNotFoundException e) {
272 throw new AssertionError(e);
273 }
274 }
275 }