ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/CopyOnWriteArraySetTest.java

Comparing jsr166/src/test/tck/CopyOnWriteArraySetTest.java (file contents):
Revision 1.20 by jsr166, Sat Nov 26 07:39:02 2011 UTC vs.
Revision 1.24 by jsr166, Tue Nov 29 20:59:24 2011 UTC

#	Line 8 | Line 8
8
9		import junit.framework.*;
10		import java.util.Arrays;
11	+	import java.util.Collection;
12	+	import java.util.Collections;
13		import java.util.Iterator;
14	+	import java.util.NoSuchElementException;
15		import java.util.Set;
16		import java.util.Vector;
17		import java.util.concurrent.CopyOnWriteArraySet;
#	Line 21 | Line 24 | public class CopyOnWriteArraySetTest ext
24		return new TestSuite(CopyOnWriteArraySetTest.class);
25		}
26
27	<	static CopyOnWriteArraySet populatedSet(int n) {
28	<	CopyOnWriteArraySet a = new CopyOnWriteArraySet();
27	>	static CopyOnWriteArraySet<Integer> populatedSet(int n) {
28	>	CopyOnWriteArraySet<Integer> a = new CopyOnWriteArraySet<Integer>();
29		assertTrue(a.isEmpty());
30	<	for (int i = 0; i < n; ++i)
31	<	a.add(new Integer(i));
30	>	for (int i = 0; i < n; i++)
31	>	a.add(i);
32		assertFalse(a.isEmpty());
33		assertEquals(n, a.size());
34		return a;
35		}
36
37	+	static CopyOnWriteArraySet populatedSet(Integer[] elements) {
38	+	CopyOnWriteArraySet<Integer> a = new CopyOnWriteArraySet<Integer>();
39	+	assertTrue(a.isEmpty());
40	+	for (int i = 0; i < elements.length; i++)
41	+	a.add(elements[i]);
42	+	assertFalse(a.isEmpty());
43	+	assertEquals(elements.length, a.size());
44	+	return a;
45	+	}
46	+
47		/**
48		* Default-constructed set is empty
49		*/
#	Line 156 | Line 169 | public class CopyOnWriteArraySetTest ext
169		}
170
171		/**
172	<	* iterator() returns an iterator containing the elements of the set
172	>	* iterator() returns an iterator containing the elements of the
173	>	* set in insertion order
174		*/
175		public void testIterator() {
176	<	CopyOnWriteArraySet full = populatedSet(3);
177	<	Iterator i = full.iterator();
178	<	int j;
179	<	for (j = 0; i.hasNext(); j++)
180	<	assertEquals(j, i.next());
181	<	assertEquals(3, j);
176	>	Set empty = new CopyOnWriteArraySet();
177	>	assertFalse(empty.iterator().hasNext());
178	>	try {
179	>	empty.iterator().next();
180	>	shouldThrow();
181	>	} catch (NoSuchElementException success) {}
182	>
183	>	Integer[] elements = new Integer[SIZE];
184	>	for (int i = 0; i < SIZE; i++)
185	>	elements[i] = i;
186	>	Collections.shuffle(Arrays.asList(elements));
187	>	Collection<Integer> full = populatedSet(elements);
188	>
189	>	Iterator it = full.iterator();
190	>	for (int j = 0; j < SIZE; j++) {
191	>	assertTrue(it.hasNext());
192	>	assertEquals(elements[j], it.next());
193	>	}
194	>	assertFalse(it.hasNext());
195	>	try {
196	>	it.next();
197	>	shouldThrow();
198	>	} catch (NoSuchElementException success) {}
199		}
200
201		/**
#	Line 224 | Line 255 | public class CopyOnWriteArraySetTest ext
255		}
256
257		/**
258	<	* toArray returns an Object array containing all elements from the set
258	>	* toArray() returns an Object array containing all elements from
259	>	* the set in insertion order
260		*/
261		public void testToArray() {
262	<	CopyOnWriteArraySet<Integer> full = populatedSet(SIZE);
263	<	Object[] array = full.toArray();
264	<	Iterator<Integer> it = full.iterator();
262	>	Object[] a = new CopyOnWriteArraySet().toArray();
263	>	assertTrue(Arrays.equals(new Object[0], a));
264	>	assertSame(Object[].class, a.getClass());
265	>
266	>	Integer[] elements = new Integer[SIZE];
267		for (int i = 0; i < SIZE; i++)
268	<	assertSame(array[i], it.next());
269	<	assertFalse(it.hasNext());
268	>	elements[i] = i;
269	>	Collections.shuffle(Arrays.asList(elements));
270	>	Collection<Integer> full = populatedSet(elements);
271	>
272	>	assertTrue(Arrays.equals(elements, full.toArray()));
273	>	assertSame(Object[].class, full.toArray().getClass());
274		}
275
276		/**
277	<	* toArray returns an Integer array containing all elements from
278	<	* the set
277	>	* toArray(Integer array) returns an Integer array containing all
278	>	* elements from the set in insertion order
279		*/
280		public void testToArray2() {
281	<	CopyOnWriteArraySet<Integer> full = populatedSet(SIZE);
282	<	Integer[] ints = new Integer[SIZE];
283	<	assertSame(ints, full.toArray(ints));
284	<	Iterator<Integer> it = full.iterator();
281	>	Collection empty = new CopyOnWriteArraySet();
282	>	Integer[] a;
283	>
284	>	a = new Integer[0];
285	>	assertSame(a, empty.toArray(a));
286	>
287	>	a = new Integer[SIZE/2];
288	>	Arrays.fill(a, 42);
289	>	assertSame(a, empty.toArray(a));
290	>	assertNull(a[0]);
291	>	for (int i = 1; i < a.length; i++)
292	>	assertEquals(42, (int) a[i]);
293	>
294	>	Integer[] elements = new Integer[SIZE];
295		for (int i = 0; i < SIZE; i++)
296	<	assertSame(ints[i], it.next());
297	<	assertFalse(it.hasNext());
296	>	elements[i] = i;
297	>	Collections.shuffle(Arrays.asList(elements));
298	>	Collection<Integer> full = populatedSet(elements);
299	>
300	>	Arrays.fill(a, 42);
301	>	assertTrue(Arrays.equals(elements, full.toArray(a)));
302	>	for (int i = 0; i < a.length; i++)
303	>	assertEquals(42, (int) a[i]);
304	>	assertSame(Integer[].class, full.toArray(a).getClass());
305	>
306	>	a = new Integer[SIZE];
307	>	Arrays.fill(a, 42);
308	>	assertSame(a, full.toArray(a));
309	>	assertTrue(Arrays.equals(elements, a));
310	>
311	>	a = new Integer[2*SIZE];
312	>	Arrays.fill(a, 42);
313	>	assertSame(a, full.toArray(a));
314	>	assertTrue(Arrays.equals(elements, Arrays.copyOf(a, SIZE)));
315	>	assertNull(a[SIZE]);
316	>	for (int i = SIZE + 1; i < a.length; i++)
317	>	assertEquals(42, (int) a[i]);
318		}
319
320		/**
#	Line 272 | Line 340 | public class CopyOnWriteArraySetTest ext
340
341		assertTrue(x != y);
342		assertEquals(x.size(), y.size());
343	+	assertEquals(x.toString(), y.toString());
344	+	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
345		assertEquals(x, y);
346		assertEquals(y, x);
347		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines