ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentLinkedQueueTest.java (file contents):
Revision 1.34 by jsr166, Wed Dec 31 20:17:39 2014 UTC vs.
Revision 1.39 by jsr166, Sat May 23 00:53:08 2015 UTC

#	Line 19 | Line 19 | import junit.framework.TestSuite;
19		public class ConcurrentLinkedQueueTest extends JSR166TestCase {
20
21		public static void main(String[] args) {
22	<	junit.textui.TestRunner.run(suite());
22	>	main(suite(), args);
23		}
24
25		public static Test suite() {
#	Line 52 | Line 52 | public class ConcurrentLinkedQueueTest e
52		*/
53		public void testConstructor3() {
54		try {
55	<	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
55	>	new ConcurrentLinkedQueue((Collection)null);
56		shouldThrow();
57		} catch (NullPointerException success) {}
58		}
#	Line 62 | Line 62 | public class ConcurrentLinkedQueueTest e
62		*/
63		public void testConstructor4() {
64		try {
65	<	Integer[] ints = new Integer[SIZE];
66	<	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
65	>	new ConcurrentLinkedQueue(Arrays.asList(new Integer[SIZE]));
66		shouldThrow();
67		} catch (NullPointerException success) {}
68		}
#	Line 72 | Line 71 | public class ConcurrentLinkedQueueTest e
71		* Initializing from Collection with some null elements throws NPE
72		*/
73		public void testConstructor5() {
74	+	Integer[] ints = new Integer[SIZE];
75	+	for (int i = 0; i < SIZE - 1; ++i)
76	+	ints[i] = new Integer(i);
77		try {
78	<	Integer[] ints = new Integer[SIZE];
77	<	for (int i = 0; i < SIZE-1; ++i)
78	<	ints[i] = new Integer(i);
79	<	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
78	>	new ConcurrentLinkedQueue(Arrays.asList(ints));
79		shouldThrow();
80		} catch (NullPointerException success) {}
81		}
#	Line 113 | Line 112 | public class ConcurrentLinkedQueueTest e
112		public void testSize() {
113		ConcurrentLinkedQueue q = populatedQueue(SIZE);
114		for (int i = 0; i < SIZE; ++i) {
115	<	assertEquals(SIZE-i, q.size());
115	>	assertEquals(SIZE - i, q.size());
116		q.remove();
117		}
118		for (int i = 0; i < SIZE; ++i) {
#	Line 126 | Line 125 | public class ConcurrentLinkedQueueTest e
125		* offer(null) throws NPE
126		*/
127		public void testOfferNull() {
128	+	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
129		try {
130	–	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
130		q.offer(null);
131		shouldThrow();
132		} catch (NullPointerException success) {}
#	Line 137 | Line 136 | public class ConcurrentLinkedQueueTest e
136		* add(null) throws NPE
137		*/
138		public void testAddNull() {
139	+	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
140		try {
141	–	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
141		q.add(null);
142		shouldThrow();
143		} catch (NullPointerException success) {}
#	Line 168 | Line 167 | public class ConcurrentLinkedQueueTest e
167		* addAll(null) throws NPE
168		*/
169		public void testAddAll1() {
170	+	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
171		try {
172	–	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
172		q.addAll(null);
173		shouldThrow();
174		} catch (NullPointerException success) {}
#	Line 179 | Line 178 | public class ConcurrentLinkedQueueTest e
178		* addAll(this) throws IAE
179		*/
180		public void testAddAllSelf() {
181	+	ConcurrentLinkedQueue q = populatedQueue(SIZE);
182		try {
183	–	ConcurrentLinkedQueue q = populatedQueue(SIZE);
183		q.addAll(q);
184		shouldThrow();
185		} catch (IllegalArgumentException success) {}
#	Line 190 | Line 189 | public class ConcurrentLinkedQueueTest e
189		* addAll of a collection with null elements throws NPE
190		*/
191		public void testAddAll2() {
192	+	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
193		try {
194	<	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
195	<	Integer[] ints = new Integer[SIZE];
196	<	q.addAll(Arrays.asList(ints));
194	>	q.addAll(Arrays.asList(new Integer[SIZE]));
195		shouldThrow();
196		} catch (NullPointerException success) {}
197		}
#	Line 203 | Line 201 | public class ConcurrentLinkedQueueTest e
201		* possibly adding some elements
202		*/
203		public void testAddAll3() {
204	+	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
205	+	Integer[] ints = new Integer[SIZE];
206	+	for (int i = 0; i < SIZE - 1; ++i)
207	+	ints[i] = new Integer(i);
208		try {
207	–	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
208	–	Integer[] ints = new Integer[SIZE];
209	–	for (int i = 0; i < SIZE-1; ++i)
210	–	ints[i] = new Integer(i);
209		q.addAll(Arrays.asList(ints));
210		shouldThrow();
211		} catch (NullPointerException success) {}
#	Line 357 | Line 355 | public class ConcurrentLinkedQueueTest e
355		assertTrue(changed);
356
357		assertTrue(q.containsAll(p));
358	<	assertEquals(SIZE-i, q.size());
358	>	assertEquals(SIZE - i, q.size());
359		p.remove();
360		}
361		}
#	Line 370 | Line 368 | public class ConcurrentLinkedQueueTest e
368		ConcurrentLinkedQueue q = populatedQueue(SIZE);
369		ConcurrentLinkedQueue p = populatedQueue(i);
370		assertTrue(q.removeAll(p));
371	<	assertEquals(SIZE-i, q.size());
371	>	assertEquals(SIZE - i, q.size());
372		for (int j = 0; j < i; ++j) {
373		Integer x = (Integer)(p.remove());
374		assertFalse(q.contains(x));
#	Line 427 | Line 425 | public class ConcurrentLinkedQueueTest e
425		*/
426		public void testIterator() {
427		ConcurrentLinkedQueue q = populatedQueue(SIZE);
430	–	int i = 0;
428		Iterator it = q.iterator();
429	<	while (it.hasNext()) {
429	>	int i;
430	>	for (i = 0; it.hasNext(); i++)
431		assertTrue(q.contains(it.next()));
434	–	++i;
435	–	}
432		assertEquals(i, SIZE);
433	+	assertIteratorExhausted(it);
434	+	}
435	+
436	+	/**
437	+	* iterator of empty collection has no elements
438	+	*/
439	+	public void testEmptyIterator() {
440	+	assertIteratorExhausted(new ConcurrentLinkedQueue().iterator());
441		}
442
443		/**

Diff Legend

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