ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedBlockingQueueTest.java (file contents):
Revision 1.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.15 by jsr166, Sat Nov 21 02:07:26 2009 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9		import junit.framework.*;
#	Line 10 | Line 11 | import java.util.*;
11		import java.util.concurrent.*;
12		import java.io.*;
13
14	<	public class LinkedBlockingQueueTest extends TestCase {
14	<
15	<	private static int N = 10;
16	<	private static long SHORT_DELAY_MS = 100;
17	<	private static long MEDIUM_DELAY_MS = 1000;
18	<	private static long LONG_DELAY_MS = 10000;
14	>	public class LinkedBlockingQueueTest extends JSR166TestCase {
15
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19
20		public static Test suite() {
21	<	return new TestSuite(LinkedBlockingQueueTest.class);
21	>	return new TestSuite(LinkedBlockingQueueTest.class);
22		}
23
24	+
25		/**
26		* Create a queue of given size containing consecutive
27		* Integers 0 ... n.
28		*/
29	<	private LinkedBlockingQueue fullQueue(int n) {
29	>	private LinkedBlockingQueue populatedQueue(int n) {
30		LinkedBlockingQueue q = new LinkedBlockingQueue(n);
31		assertTrue(q.isEmpty());
32	<	for(int i = 0; i < n; i++)
33	<	assertTrue(q.offer(new Integer(i)));
32	>	for (int i = 0; i < n; i++)
33	>	assertTrue(q.offer(new Integer(i)));
34		assertFalse(q.isEmpty());
35		assertEquals(0, q.remainingCapacity());
36	<	assertEquals(n, q.size());
36	>	assertEquals(n, q.size());
37		return q;
38		}
39	<
40	<	public void testConstructor1(){
41	<	assertEquals(N, new LinkedBlockingQueue(N).remainingCapacity());
39	>
40	>	/**
41	>	* A new queue has the indicated capacity, or Integer.MAX_VALUE if
42	>	* none given
43	>	*/
44	>	public void testConstructor1() {
45	>	assertEquals(SIZE, new LinkedBlockingQueue(SIZE).remainingCapacity());
46	>	assertEquals(Integer.MAX_VALUE, new LinkedBlockingQueue().remainingCapacity());
47		}
48
49	<	public void testConstructor2(){
49	>	/**
50	>	* Constructor throws IAE if  capacity argument nonpositive
51	>	*/
52	>	public void testConstructor2() {
53		try {
54		LinkedBlockingQueue q = new LinkedBlockingQueue(0);
55	<	fail("Cannot make zero-sized");
55	>	shouldThrow();
56		}
57		catch (IllegalArgumentException success) {}
58		}
59
60	<	public void testConstructor3(){
61	<
60	>	/**
61	>	* Initializing from null Collection throws NPE
62	>	*/
63	>	public void testConstructor3() {
64		try {
65		LinkedBlockingQueue q = new LinkedBlockingQueue(null);
66	<	fail("Cannot make from null collection");
66	>	shouldThrow();
67		}
68		catch (NullPointerException success) {}
69		}
70
71	<	public void testConstructor4(){
71	>	/**
72	>	* Initializing from Collection of null elements throws NPE
73	>	*/
74	>	public void testConstructor4() {
75		try {
76	<	Integer[] ints = new Integer[N];
76	>	Integer[] ints = new Integer[SIZE];
77		LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
78	<	fail("Cannot make with null elements");
78	>	shouldThrow();
79		}
80		catch (NullPointerException success) {}
81		}
82
83	<	public void testConstructor5(){
83	>	/**
84	>	* Initializing from Collection with some null elements throws NPE
85	>	*/
86	>	public void testConstructor5() {
87		try {
88	<	Integer[] ints = new Integer[N];
89	<	for (int i = 0; i < N-1; ++i)
88	>	Integer[] ints = new Integer[SIZE];
89	>	for (int i = 0; i < SIZE-1; ++i)
90		ints[i] = new Integer(i);
91		LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
92	<	fail("Cannot make with null elements");
92	>	shouldThrow();
93		}
94		catch (NullPointerException success) {}
95		}
96
97	<	public void testConstructor6(){
97	>	/**
98	>	* Queue contains all elements of collection used to initialize
99	>	*/
100	>	public void testConstructor6() {
101		try {
102	<	Integer[] ints = new Integer[N];
103	<	for (int i = 0; i < N; ++i)
102	>	Integer[] ints = new Integer[SIZE];
103	>	for (int i = 0; i < SIZE; ++i)
104		ints[i] = new Integer(i);
105		LinkedBlockingQueue q = new LinkedBlockingQueue(Arrays.asList(ints));
106	<	for (int i = 0; i < N; ++i)
106	>	for (int i = 0; i < SIZE; ++i)
107		assertEquals(ints[i], q.poll());
108		}
109		finally {}
110		}
111
112	+	/**
113	+	* Queue transitions from empty to full when elements added
114	+	*/
115		public void testEmptyFull() {
116		LinkedBlockingQueue q = new LinkedBlockingQueue(2);
117		assertTrue(q.isEmpty());
118		assertEquals("should have room for 2", 2, q.remainingCapacity());
119	<	q.add(new Integer(1));
119	>	q.add(one);
120		assertFalse(q.isEmpty());
121	<	q.add(new Integer(2));
121	>	q.add(two);
122		assertFalse(q.isEmpty());
123	<	assertEquals("queue should be full", 0, q.remainingCapacity());
124	<	assertFalse("offer should be rejected", q.offer(new Integer(3)));
123	>	assertEquals(0, q.remainingCapacity());
124	>	assertFalse(q.offer(three));
125		}
126
127	<	public void testRemainingCapacity(){
128	<	LinkedBlockingQueue q = fullQueue(N);
129	<	for (int i = 0; i < N; ++i) {
127	>	/**
128	>	* remainingCapacity decreases on add, increases on remove
129	>	*/
130	>	public void testRemainingCapacity() {
131	>	LinkedBlockingQueue q = populatedQueue(SIZE);
132	>	for (int i = 0; i < SIZE; ++i) {
133		assertEquals(i, q.remainingCapacity());
134	<	assertEquals(N-i, q.size());
134	>	assertEquals(SIZE-i, q.size());
135		q.remove();
136		}
137	<	for (int i = 0; i < N; ++i) {
138	<	assertEquals(N-i, q.remainingCapacity());
137	>	for (int i = 0; i < SIZE; ++i) {
138	>	assertEquals(SIZE-i, q.remainingCapacity());
139		assertEquals(i, q.size());
140		q.add(new Integer(i));
141		}
142		}
143
144	<	public void testOfferNull(){
145	<	try {
144	>	/**
145	>	* offer(null) throws NPE
146	>	*/
147	>	public void testOfferNull() {
148	>	try {
149		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
150		q.offer(null);
151	<	fail("should throw NPE");
152	<	} catch (NullPointerException success) { }
151	>	shouldThrow();
152	>	} catch (NullPointerException success) { }
153	>	}
154	>
155	>	/**
156	>	* add(null) throws NPE
157	>	*/
158	>	public void testAddNull() {
159	>	try {
160	>	LinkedBlockingQueue q = new LinkedBlockingQueue(1);
161	>	q.add(null);
162	>	shouldThrow();
163	>	} catch (NullPointerException success) { }
164		}
165
166	<	public void testOffer(){
166	>	/**
167	>	* Offer succeeds if not full; fails if full
168	>	*/
169	>	public void testOffer() {
170		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
171	<	assertTrue(q.offer(new Integer(0)));
172	<	assertFalse(q.offer(new Integer(1)));
171	>	assertTrue(q.offer(zero));
172	>	assertFalse(q.offer(one));
173		}
174
175	<	public void testAdd(){
176	<	try {
177	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
178	<	for (int i = 0; i < N; ++i) {
175	>	/**
176	>	* add succeeds if not full; throws ISE if full
177	>	*/
178	>	public void testAdd() {
179	>	try {
180	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
181	>	for (int i = 0; i < SIZE; ++i) {
182		assertTrue(q.add(new Integer(i)));
183		}
184		assertEquals(0, q.remainingCapacity());
185	<	q.add(new Integer(N));
186	<	} catch (IllegalStateException success){
187	<	}
185	>	q.add(new Integer(SIZE));
186	>	} catch (IllegalStateException success) {
187	>	}
188		}
189
190	<	public void testAddAll1(){
190	>	/**
191	>	* addAll(null) throws NPE
192	>	*/
193	>	public void testAddAll1() {
194		try {
195		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
196		q.addAll(null);
197	<	fail("Cannot add null collection");
197	>	shouldThrow();
198		}
199		catch (NullPointerException success) {}
200		}
201	<	public void testAddAll2(){
201	>
202	>	/**
203	>	* addAll(this) throws IAE
204	>	*/
205	>	public void testAddAllSelf() {
206		try {
207	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
208	<	Integer[] ints = new Integer[N];
207	>	LinkedBlockingQueue q = populatedQueue(SIZE);
208	>	q.addAll(q);
209	>	shouldThrow();
210	>	}
211	>	catch (IllegalArgumentException success) {}
212	>	}
213	>
214	>	/**
215	>	* addAll of a collection with null elements throws NPE
216	>	*/
217	>	public void testAddAll2() {
218	>	try {
219	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
220	>	Integer[] ints = new Integer[SIZE];
221		q.addAll(Arrays.asList(ints));
222	<	fail("Cannot add null elements");
222	>	shouldThrow();
223		}
224		catch (NullPointerException success) {}
225		}
226	<	public void testAddAll3(){
226	>	/**
227	>	* addAll of a collection with any null elements throws NPE after
228	>	* possibly adding some elements
229	>	*/
230	>	public void testAddAll3() {
231		try {
232	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
233	<	Integer[] ints = new Integer[N];
234	<	for (int i = 0; i < N-1; ++i)
232	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
233	>	Integer[] ints = new Integer[SIZE];
234	>	for (int i = 0; i < SIZE-1; ++i)
235		ints[i] = new Integer(i);
236		q.addAll(Arrays.asList(ints));
237	<	fail("Cannot add null elements");
237	>	shouldThrow();
238		}
239		catch (NullPointerException success) {}
240		}
241	<	public void testAddAll4(){
241	>	/**
242	>	* addAll throws ISE if not enough room
243	>	*/
244	>	public void testAddAll4() {
245		try {
246		LinkedBlockingQueue q = new LinkedBlockingQueue(1);
247	<	Integer[] ints = new Integer[N];
248	<	for (int i = 0; i < N; ++i)
247	>	Integer[] ints = new Integer[SIZE];
248	>	for (int i = 0; i < SIZE; ++i)
249		ints[i] = new Integer(i);
250		q.addAll(Arrays.asList(ints));
251	<	fail("Cannot add with insufficient capacity");
251	>	shouldThrow();
252		}
253		catch (IllegalStateException success) {}
254		}
255	<	public void testAddAll5(){
255	>	/**
256	>	* Queue contains all elements, in traversal order, of successful addAll
257	>	*/
258	>	public void testAddAll5() {
259		try {
260		Integer[] empty = new Integer[0];
261	<	Integer[] ints = new Integer[N];
262	<	for (int i = 0; i < N; ++i)
261	>	Integer[] ints = new Integer[SIZE];
262	>	for (int i = 0; i < SIZE; ++i)
263		ints[i] = new Integer(i);
264	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
264	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
265		assertFalse(q.addAll(Arrays.asList(empty)));
266		assertTrue(q.addAll(Arrays.asList(ints)));
267	<	for (int i = 0; i < N; ++i)
267	>	for (int i = 0; i < SIZE; ++i)
268		assertEquals(ints[i], q.poll());
269		}
270		finally {}
271		}
272
273	+	/**
274	+	* put(null) throws NPE
275	+	*/
276		public void testPutNull() {
277	<	try {
278	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
277	>	try {
278	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
279		q.put(null);
280	<	fail("put should throw NPE");
281	<	}
282	<	catch (NullPointerException success){
283	<	}
280	>	shouldThrow();
281	>	}
282	>	catch (NullPointerException success) {
283	>	}
284		catch (InterruptedException ie) {
285	<	fail("Unexpected exception");
285	>	unexpectedException();
286		}
287		}
288
289	+	/**
290	+	* all elements successfully put are contained
291	+	*/
292		public void testPut() {
293		try {
294	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
295	<	for (int i = 0; i < N; ++i) {
294	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
295	>	for (int i = 0; i < SIZE; ++i) {
296		Integer I = new Integer(i);
297		q.put(I);
298		assertTrue(q.contains(I));
#	Line 223 | Line 300 | public class LinkedBlockingQueueTest ext
300		assertEquals(0, q.remainingCapacity());
301		}
302		catch (InterruptedException ie) {
303	<	fail("Unexpected exception");
303	>	unexpectedException();
304		}
305		}
306
307	<	public void testBlockingPut(){
307	>	/**
308	>	* put blocks interruptibly if full
309	>	*/
310	>	public void testBlockingPut() {
311		Thread t = new Thread(new Runnable() {
312		public void run() {
313		int added = 0;
314		try {
315	<	LinkedBlockingQueue q = new LinkedBlockingQueue(N);
316	<	for (int i = 0; i < N; ++i) {
315	>	LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
316	>	for (int i = 0; i < SIZE; ++i) {
317		q.put(new Integer(i));
318		++added;
319		}
320	<	q.put(new Integer(N));
321	<	fail("put should block");
322	<	} catch (InterruptedException ie){
323	<	assertEquals(added, N);
324	<	}
320	>	q.put(new Integer(SIZE));
321	>	threadShouldThrow();
322	>	} catch (InterruptedException ie) {
323	>	threadAssertEquals(added, SIZE);
324	>	}
325		}});
326		t.start();
327	<	try {
328	<	Thread.sleep(SHORT_DELAY_MS);
327	>	try {
328	>	Thread.sleep(SHORT_DELAY_MS);
329		t.interrupt();
330		t.join();
331		}
332		catch (InterruptedException ie) {
333	<	fail("Unexpected exception");
333	>	unexpectedException();
334		}
335		}
336
337	+	/**
338	+	* put blocks waiting for take when full
339	+	*/
340		public void testPutWithTake() {
341		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
342		Thread t = new Thread(new Runnable() {
343	<	public void run(){
343	>	public void run() {
344		int added = 0;
345		try {
346		q.put(new Object());
#	Line 268 | Line 351 | public class LinkedBlockingQueueTest ext
351		++added;
352		q.put(new Object());
353		++added;
354	<	fail("Should block");
355	<	} catch (InterruptedException e){
356	<	assertTrue(added >= 2);
354	>	threadShouldThrow();
355	>	} catch (InterruptedException e) {
356	>	threadAssertTrue(added >= 2);
357		}
358		}
359		});
#	Line 280 | Line 363 | public class LinkedBlockingQueueTest ext
363		q.take();
364		t.interrupt();
365		t.join();
366	<	} catch (Exception e){
367	<	fail("Unexpected exception");
366	>	} catch (Exception e) {
367	>	unexpectedException();
368		}
369		}
370
371	+	/**
372	+	* timed offer times out if full and elements not taken
373	+	*/
374		public void testTimedOffer() {
375		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
376		Thread t = new Thread(new Runnable() {
377	<	public void run(){
377	>	public void run() {
378		try {
379		q.put(new Object());
380		q.put(new Object());
381	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
381	>	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
382		q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
383	<	fail("Should block");
384	<	} catch (InterruptedException success){}
383	>	threadShouldThrow();
384	>	} catch (InterruptedException success) {}
385		}
386		});
387	<
387	>
388		try {
389		t.start();
390	<	Thread.sleep(SHORT_DELAY_MS);
390	>	Thread.sleep(SMALL_DELAY_MS);
391		t.interrupt();
392		t.join();
393	<	} catch (Exception e){
394	<	fail("Unexpected exception");
393	>	} catch (Exception e) {
394	>	unexpectedException();
395		}
396		}
397
398	<	public void testTake(){
399	<	try {
400	<	LinkedBlockingQueue q = fullQueue(N);
401	<	for (int i = 0; i < N; ++i) {
398	>	/**
399	>	* take retrieves elements in FIFO order
400	>	*/
401	>	public void testTake() {
402	>	try {
403	>	LinkedBlockingQueue q = populatedQueue(SIZE);
404	>	for (int i = 0; i < SIZE; ++i) {
405		assertEquals(i, ((Integer)q.take()).intValue());
406		}
407	<	} catch (InterruptedException e){
408	<	fail("Unexpected exception");
409	<	}
407	>	} catch (InterruptedException e) {
408	>	unexpectedException();
409	>	}
410		}
411
412	+	/**
413	+	* take blocks interruptibly when empty
414	+	*/
415		public void testTakeFromEmpty() {
416		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
417		Thread t = new Thread(new Runnable() {
418	<	public void run(){
418	>	public void run() {
419		try {
420		q.take();
421	<	fail("Should block");
422	<	} catch (InterruptedException success){ }
421	>	threadShouldThrow();
422	>	} catch (InterruptedException success) { }
423		}
424		});
425		try {
#	Line 335 | Line 427 | public class LinkedBlockingQueueTest ext
427		Thread.sleep(SHORT_DELAY_MS);
428		t.interrupt();
429		t.join();
430	<	} catch (Exception e){
431	<	fail("Unexpected exception");
430	>	} catch (Exception e) {
431	>	unexpectedException();
432		}
433		}
434
435	<	public void testBlockingTake(){
435	>	/**
436	>	* Take removes existing elements until empty, then blocks interruptibly
437	>	*/
438	>	public void testBlockingTake() {
439		Thread t = new Thread(new Runnable() {
440		public void run() {
441		try {
442	<	LinkedBlockingQueue q = fullQueue(N);
443	<	for (int i = 0; i < N; ++i) {
442	>	LinkedBlockingQueue q = populatedQueue(SIZE);
443	>	for (int i = 0; i < SIZE; ++i) {
444		assertEquals(i, ((Integer)q.take()).intValue());
445		}
446		q.take();
447	<	fail("take should block");
448	<	} catch (InterruptedException success){
449	<	}
447	>	threadShouldThrow();
448	>	} catch (InterruptedException success) {
449	>	}
450		}});
451		t.start();
452	<	try {
453	<	Thread.sleep(SHORT_DELAY_MS);
452	>	try {
453	>	Thread.sleep(SHORT_DELAY_MS);
454		t.interrupt();
455		t.join();
456		}
457		catch (InterruptedException ie) {
458	<	fail("Unexpected exception");
458	>	unexpectedException();
459		}
460		}
461
462
463	<	public void testPoll(){
464	<	LinkedBlockingQueue q = fullQueue(N);
465	<	for (int i = 0; i < N; ++i) {
463	>	/**
464	>	* poll succeeds unless empty
465	>	*/
466	>	public void testPoll() {
467	>	LinkedBlockingQueue q = populatedQueue(SIZE);
468	>	for (int i = 0; i < SIZE; ++i) {
469		assertEquals(i, ((Integer)q.poll()).intValue());
470		}
471	<	assertNull(q.poll());
471	>	assertNull(q.poll());
472		}
473
474	+	/**
475	+	* timed pool with zero timeout succeeds when non-empty, else times out
476	+	*/
477		public void testTimedPoll0() {
478		try {
479	<	LinkedBlockingQueue q = fullQueue(N);
480	<	for (int i = 0; i < N; ++i) {
479	>	LinkedBlockingQueue q = populatedQueue(SIZE);
480	>	for (int i = 0; i < SIZE; ++i) {
481		assertEquals(i, ((Integer)q.poll(0, TimeUnit.MILLISECONDS)).intValue());
482		}
483		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
484	<	} catch (InterruptedException e){
485	<	fail("Unexpected exception");
486	<	}
484	>	} catch (InterruptedException e) {
485	>	unexpectedException();
486	>	}
487		}
488
489	+	/**
490	+	* timed pool with nonzero timeout succeeds when non-empty, else times out
491	+	*/
492		public void testTimedPoll() {
493		try {
494	<	LinkedBlockingQueue q = fullQueue(N);
495	<	for (int i = 0; i < N; ++i) {
494	>	LinkedBlockingQueue q = populatedQueue(SIZE);
495	>	for (int i = 0; i < SIZE; ++i) {
496		assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
497		}
498		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
499	<	} catch (InterruptedException e){
500	<	fail("Unexpected exception");
501	<	}
499	>	} catch (InterruptedException e) {
500	>	unexpectedException();
501	>	}
502		}
503
504	<	public void testInterruptedTimedPoll(){
504	>	/**
505	>	* Interrupted timed poll throws InterruptedException instead of
506	>	* returning timeout status
507	>	*/
508	>	public void testInterruptedTimedPoll() {
509		Thread t = new Thread(new Runnable() {
510		public void run() {
511		try {
512	<	LinkedBlockingQueue q = fullQueue(N);
513	<	for (int i = 0; i < N; ++i) {
514	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
512	>	LinkedBlockingQueue q = populatedQueue(SIZE);
513	>	for (int i = 0; i < SIZE; ++i) {
514	>	threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
515		}
516	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
517	<	} catch (InterruptedException success){
518	<	}
516	>	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
517	>	} catch (InterruptedException success) {
518	>	}
519		}});
520		t.start();
521	<	try {
522	<	Thread.sleep(SHORT_DELAY_MS);
521	>	try {
522	>	Thread.sleep(SHORT_DELAY_MS);
523		t.interrupt();
524		t.join();
525		}
526		catch (InterruptedException ie) {
527	<	fail("Unexpected exception");
527	>	unexpectedException();
528		}
529		}
530
531	<	public void testTimedPollWithOffer(){
531	>	/**
532	>	*  timed poll before a delayed offer fails; after offer succeeds;
533	>	*  on interruption throws
534	>	*/
535	>	public void testTimedPollWithOffer() {
536		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
537		Thread t = new Thread(new Runnable() {
538	<	public void run(){
538	>	public void run() {
539		try {
540	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
540	>	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
541		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
542		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
543	<	fail("Should block");
544	<	} catch (InterruptedException success) { }
543	>	threadShouldThrow();
544	>	} catch (InterruptedException success) { }
545		}
546		});
547		try {
548		t.start();
549	<	Thread.sleep(SHORT_DELAY_MS * 2);
550	<	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
549	>	Thread.sleep(SMALL_DELAY_MS);
550	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
551		t.interrupt();
552		t.join();
553	<	} catch (Exception e){
554	<	fail("Unexpected exception");
553	>	} catch (Exception e) {
554	>	unexpectedException();
555		}
556	<	}
445	<
556	>	}
557
558	<	public void testPeek(){
559	<	LinkedBlockingQueue q = fullQueue(N);
560	<	for (int i = 0; i < N; ++i) {
558	>	/**
559	>	* peek returns next element, or null if empty
560	>	*/
561	>	public void testPeek() {
562	>	LinkedBlockingQueue q = populatedQueue(SIZE);
563	>	for (int i = 0; i < SIZE; ++i) {
564		assertEquals(i, ((Integer)q.peek()).intValue());
565		q.poll();
566		assertTrue(q.peek() == null ||
567		i != ((Integer)q.peek()).intValue());
568		}
569	<	assertNull(q.peek());
569	>	assertNull(q.peek());
570		}
571
572	<	public void testElement(){
573	<	LinkedBlockingQueue q = fullQueue(N);
574	<	for (int i = 0; i < N; ++i) {
572	>	/**
573	>	* element returns next element, or throws NSEE if empty
574	>	*/
575	>	public void testElement() {
576	>	LinkedBlockingQueue q = populatedQueue(SIZE);
577	>	for (int i = 0; i < SIZE; ++i) {
578		assertEquals(i, ((Integer)q.element()).intValue());
579		q.poll();
580		}
581		try {
582		q.element();
583	<	fail("no such element");
583	>	shouldThrow();
584		}
585		catch (NoSuchElementException success) {}
586		}
587
588	<	public void testRemove(){
589	<	LinkedBlockingQueue q = fullQueue(N);
590	<	for (int i = 0; i < N; ++i) {
588	>	/**
589	>	* remove removes next element, or throws NSEE if empty
590	>	*/
591	>	public void testRemove() {
592	>	LinkedBlockingQueue q = populatedQueue(SIZE);
593	>	for (int i = 0; i < SIZE; ++i) {
594		assertEquals(i, ((Integer)q.remove()).intValue());
595		}
596		try {
597		q.remove();
598	<	fail("remove should throw");
599	<	} catch (NoSuchElementException success){
600	<	}
598	>	shouldThrow();
599	>	} catch (NoSuchElementException success) {
600	>	}
601		}
602
603	<	public void testRemoveElement(){
604	<	LinkedBlockingQueue q = fullQueue(N);
605	<	for (int i = 1; i < N; i+=2) {
603	>	/**
604	>	* remove(x) removes x and returns true if present
605	>	*/
606	>	public void testRemoveElement() {
607	>	LinkedBlockingQueue q = populatedQueue(SIZE);
608	>	for (int i = 1; i < SIZE; i+=2) {
609		assertTrue(q.remove(new Integer(i)));
610		}
611	<	for (int i = 0; i < N; i+=2) {
611	>	for (int i = 0; i < SIZE; i+=2) {
612		assertTrue(q.remove(new Integer(i)));
613		assertFalse(q.remove(new Integer(i+1)));
614		}
615		assertTrue(q.isEmpty());
616		}
617	<
618	<	public void testContains(){
619	<	LinkedBlockingQueue q = fullQueue(N);
620	<	for (int i = 0; i < N; ++i) {
617	>
618	>	/**
619	>	* An add following remove(x) succeeds
620	>	*/
621	>	public void testRemoveElementAndAdd() {
622	>	try {
623	>	LinkedBlockingQueue q = new LinkedBlockingQueue();
624	>	assertTrue(q.add(new Integer(1)));
625	>	assertTrue(q.add(new Integer(2)));
626	>	assertTrue(q.remove(new Integer(1)));
627	>	assertTrue(q.remove(new Integer(2)));
628	>	assertTrue(q.add(new Integer(3)));
629	>	assertTrue(q.take() != null);
630	>	} catch (Exception e) {
631	>	unexpectedException();
632	>	}
633	>	}
634	>
635	>	/**
636	>	* contains(x) reports true when elements added but not yet removed
637	>	*/
638	>	public void testContains() {
639	>	LinkedBlockingQueue q = populatedQueue(SIZE);
640	>	for (int i = 0; i < SIZE; ++i) {
641		assertTrue(q.contains(new Integer(i)));
642		q.poll();
643		assertFalse(q.contains(new Integer(i)));
644		}
645		}
646
647	<	public void testClear(){
648	<	LinkedBlockingQueue q = fullQueue(N);
647	>	/**
648	>	* clear removes all elements
649	>	*/
650	>	public void testClear() {
651	>	LinkedBlockingQueue q = populatedQueue(SIZE);
652		q.clear();
653		assertTrue(q.isEmpty());
654		assertEquals(0, q.size());
655	<	assertEquals(N, q.remainingCapacity());
656	<	q.add(new Integer(1));
655	>	assertEquals(SIZE, q.remainingCapacity());
656	>	q.add(one);
657		assertFalse(q.isEmpty());
658	+	assertTrue(q.contains(one));
659		q.clear();
660		assertTrue(q.isEmpty());
661		}
662
663	<	public void testContainsAll(){
664	<	LinkedBlockingQueue q = fullQueue(N);
665	<	LinkedBlockingQueue p = new LinkedBlockingQueue(N);
666	<	for (int i = 0; i < N; ++i) {
663	>	/**
664	>	* containsAll(c) is true when c contains a subset of elements
665	>	*/
666	>	public void testContainsAll() {
667	>	LinkedBlockingQueue q = populatedQueue(SIZE);
668	>	LinkedBlockingQueue p = new LinkedBlockingQueue(SIZE);
669	>	for (int i = 0; i < SIZE; ++i) {
670		assertTrue(q.containsAll(p));
671		assertFalse(p.containsAll(q));
672		p.add(new Integer(i));
#	Line 524 | Line 674 | public class LinkedBlockingQueueTest ext
674		assertTrue(p.containsAll(q));
675		}
676
677	<	public void testRetainAll(){
678	<	LinkedBlockingQueue q = fullQueue(N);
679	<	LinkedBlockingQueue p = fullQueue(N);
680	<	for (int i = 0; i < N; ++i) {
677	>	/**
678	>	* retainAll(c) retains only those elements of c and reports true if changed
679	>	*/
680	>	public void testRetainAll() {
681	>	LinkedBlockingQueue q = populatedQueue(SIZE);
682	>	LinkedBlockingQueue p = populatedQueue(SIZE);
683	>	for (int i = 0; i < SIZE; ++i) {
684		boolean changed = q.retainAll(p);
685		if (i == 0)
686		assertFalse(changed);
#	Line 535 | Line 688 | public class LinkedBlockingQueueTest ext
688		assertTrue(changed);
689
690		assertTrue(q.containsAll(p));
691	<	assertEquals(N-i, q.size());
691	>	assertEquals(SIZE-i, q.size());
692		p.remove();
693		}
694		}
695
696	<	public void testRemoveAll(){
697	<	for (int i = 1; i < N; ++i) {
698	<	LinkedBlockingQueue q = fullQueue(N);
699	<	LinkedBlockingQueue p = fullQueue(i);
696	>	/**
697	>	* removeAll(c) removes only those elements of c and reports true if changed
698	>	*/
699	>	public void testRemoveAll() {
700	>	for (int i = 1; i < SIZE; ++i) {
701	>	LinkedBlockingQueue q = populatedQueue(SIZE);
702	>	LinkedBlockingQueue p = populatedQueue(i);
703		assertTrue(q.removeAll(p));
704	<	assertEquals(N-i, q.size());
704	>	assertEquals(SIZE-i, q.size());
705		for (int j = 0; j < i; ++j) {
706		Integer I = (Integer)(p.remove());
707		assertFalse(q.contains(I));
#	Line 553 | Line 709 | public class LinkedBlockingQueueTest ext
709		}
710		}
711
712	+	/**
713	+	* toArray contains all elements
714	+	*/
715	+	public void testToArray() {
716	+	LinkedBlockingQueue q = populatedQueue(SIZE);
717	+	Object[] o = q.toArray();
718	+	try {
719	+	for (int i = 0; i < o.length; i++)
720	+	assertEquals(o[i], q.take());
721	+	} catch (InterruptedException e) {
722	+	unexpectedException();
723	+	}
724	+	}
725
726	<	public void testToArray(){
727	<	LinkedBlockingQueue q = fullQueue(N);
728	<	Object[] o = q.toArray();
729	<	try {
730	<	for(int i = 0; i < o.length; i++)
731	<	assertEquals(o[i], q.take());
732	<	} catch (InterruptedException e){
733	<	fail("Unexpected exception");
734	<	}
735	<	}
736	<
737	<	public void testToArray2(){
738	<	LinkedBlockingQueue q = fullQueue(N);
570	<	Integer[] ints = new Integer[N];
571	<	ints = (Integer[])q.toArray(ints);
572	<	try {
573	<	for(int i = 0; i < ints.length; i++)
574	<	assertEquals(ints[i], q.take());
575	<	} catch (InterruptedException e){
576	<	fail("Unexpected exception");
577	<	}
578	<	}
579	<
580	<	public void testIterator(){
581	<	LinkedBlockingQueue q = fullQueue(N);
582	<	Iterator it = q.iterator();
583	<	try {
584	<	while(it.hasNext()){
585	<	assertEquals(it.next(), q.take());
586	<	}
587	<	} catch (InterruptedException e){
588	<	fail("Unexpected exception");
589	<	}
726	>	/**
727	>	* toArray(a) contains all elements
728	>	*/
729	>	public void testToArray2() {
730	>	LinkedBlockingQueue q = populatedQueue(SIZE);
731	>	Integer[] ints = new Integer[SIZE];
732	>	ints = (Integer[])q.toArray(ints);
733	>	try {
734	>	for (int i = 0; i < ints.length; i++)
735	>	assertEquals(ints[i], q.take());
736	>	} catch (InterruptedException e) {
737	>	unexpectedException();
738	>	}
739		}
740
741	<	public void testIteratorOrdering() {
741	>	/**
742	>	* toArray(null) throws NPE
743	>	*/
744	>	public void testToArray_BadArg() {
745	>	try {
746	>	LinkedBlockingQueue q = populatedQueue(SIZE);
747	>	Object o[] = q.toArray(null);
748	>	shouldThrow();
749	>	} catch (NullPointerException success) {}
750	>	}
751
752	<	final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
752	>	/**
753	>	* toArray with incompatible array type throws CCE
754	>	*/
755	>	public void testToArray1_BadArg() {
756	>	try {
757	>	LinkedBlockingQueue q = populatedQueue(SIZE);
758	>	Object o[] = q.toArray(new String[10] );
759	>	shouldThrow();
760	>	} catch (ArrayStoreException  success) {}
761	>	}
762
596	–	q.add(new Integer(1));
597	–	q.add(new Integer(2));
598	–	q.add(new Integer(3));
763
764	<	assertEquals("queue should be full", 0, q.remainingCapacity());
764	>	/**
765	>	* iterator iterates through all elements
766	>	*/
767	>	public void testIterator() {
768	>	LinkedBlockingQueue q = populatedQueue(SIZE);
769	>	Iterator it = q.iterator();
770	>	try {
771	>	while (it.hasNext()) {
772	>	assertEquals(it.next(), q.take());
773	>	}
774	>	} catch (InterruptedException e) {
775	>	unexpectedException();
776	>	}
777	>	}
778
779	+	/**
780	+	* iterator.remove removes current element
781	+	*/
782	+	public void testIteratorRemove () {
783	+	final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
784	+	q.add(two);
785	+	q.add(one);
786	+	q.add(three);
787	+
788	+	Iterator it = q.iterator();
789	+	it.next();
790	+	it.remove();
791	+
792	+	it = q.iterator();
793	+	assertEquals(it.next(), one);
794	+	assertEquals(it.next(), three);
795	+	assertFalse(it.hasNext());
796	+	}
797	+
798	+
799	+	/**
800	+	* iterator ordering is FIFO
801	+	*/
802	+	public void testIteratorOrdering() {
803	+	final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
804	+	q.add(one);
805	+	q.add(two);
806	+	q.add(three);
807	+	assertEquals(0, q.remainingCapacity());
808		int k = 0;
809		for (Iterator it = q.iterator(); it.hasNext();) {
810		int i = ((Integer)(it.next())).intValue();
811	<	assertEquals("items should come out in order", ++k, i);
811	>	assertEquals(++k, i);
812		}
813	<
608	<	assertEquals("should go through 3 elements", 3, k);
813	>	assertEquals(3, k);
814		}
815
816	+	/**
817	+	* Modifications do not cause iterators to fail
818	+	*/
819		public void testWeaklyConsistentIteration () {
612	–
820		final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
821	<
822	<	q.add(new Integer(1));
823	<	q.add(new Integer(2));
617	<	q.add(new Integer(3));
618	<
821	>	q.add(one);
822	>	q.add(two);
823	>	q.add(three);
824		try {
825		for (Iterator it = q.iterator(); it.hasNext();) {
826		q.remove();
#	Line 623 | Line 828 | public class LinkedBlockingQueueTest ext
828		}
829		}
830		catch (ConcurrentModificationException e) {
831	<	fail("weakly consistent iterator; should not get CME");
831	>	unexpectedException();
832		}
833	<
629	<	assertEquals("queue should be empty again", 0, q.size());
833	>	assertEquals(0, q.size());
834		}
835
836
837	<	public void testToString(){
838	<	LinkedBlockingQueue q = fullQueue(N);
837	>	/**
838	>	* toString contains toStrings of elements
839	>	*/
840	>	public void testToString() {
841	>	LinkedBlockingQueue q = populatedQueue(SIZE);
842		String s = q.toString();
843	<	for (int i = 0; i < N; ++i) {
843	>	for (int i = 0; i < SIZE; ++i) {
844		assertTrue(s.indexOf(String.valueOf(i)) >= 0);
845		}
846	<	}
846	>	}
847
848
849	+	/**
850	+	* offer transfers elements across Executor tasks
851	+	*/
852		public void testOfferInExecutor() {
643	–
853		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
854	<
855	<	q.add(new Integer(1));
647	<	q.add(new Integer(2));
648	<
854	>	q.add(one);
855	>	q.add(two);
856		ExecutorService executor = Executors.newFixedThreadPool(2);
650	–
857		executor.execute(new Runnable() {
858		public void run() {
859	<	assertFalse("offer should be rejected", q.offer(new Integer(3)));
859	>	threadAssertFalse(q.offer(three));
860		try {
861	<	assertTrue("offer should be accepted", q.offer(new Integer(3), MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
862	<	assertEquals(0, q.remainingCapacity());
861	>	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
862	>	threadAssertEquals(0, q.remainingCapacity());
863		}
864		catch (InterruptedException e) {
865	<	fail("should not be interrupted");
865	>	threadUnexpectedException();
866		}
867		}
868		});
#	Line 664 | Line 870 | public class LinkedBlockingQueueTest ext
870		executor.execute(new Runnable() {
871		public void run() {
872		try {
873	<	Thread.sleep(MEDIUM_DELAY_MS);
874	<	assertEquals("first item in queue should be 1", new Integer(1), q.take());
873	>	Thread.sleep(SMALL_DELAY_MS);
874	>	threadAssertEquals(one, q.take());
875		}
876		catch (InterruptedException e) {
877	<	fail("should not be interrupted");
877	>	threadUnexpectedException();
878		}
879		}
880		});
675	–
676	–	executor.shutdown();
881
882	+	joinPool(executor);
883		}
884
885	+	/**
886	+	* poll retrieves elements across Executor threads
887	+	*/
888		public void testPollInExecutor() {
681	–
889		final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
683	–
890		ExecutorService executor = Executors.newFixedThreadPool(2);
685	–
891		executor.execute(new Runnable() {
892		public void run() {
893	<	assertNull("poll should fail", q.poll());
893	>	threadAssertNull(q.poll());
894		try {
895	<	assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
896	<	assertTrue(q.isEmpty());
895	>	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
896	>	threadAssertTrue(q.isEmpty());
897		}
898		catch (InterruptedException e) {
899	<	fail("should not be interrupted");
899	>	threadUnexpectedException();
900		}
901		}
902		});
#	Line 699 | Line 904 | public class LinkedBlockingQueueTest ext
904		executor.execute(new Runnable() {
905		public void run() {
906		try {
907	<	Thread.sleep(MEDIUM_DELAY_MS);
908	<	q.put(new Integer(1));
907	>	Thread.sleep(SMALL_DELAY_MS);
908	>	q.put(one);
909		}
910		catch (InterruptedException e) {
911	<	fail("should not be interrupted");
911	>	threadUnexpectedException();
912		}
913		}
914		});
710	–
711	–	executor.shutdown();
915
916	+	joinPool(executor);
917		}
918
919	+	/**
920	+	* A deserialized serialized queue has same elements in same order
921	+	*/
922		public void testSerialization() {
923	<	LinkedBlockingQueue q = fullQueue(N);
923	>	LinkedBlockingQueue q = populatedQueue(SIZE);
924
925		try {
926		ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
#	Line 725 | Line 932 | public class LinkedBlockingQueueTest ext
932		ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
933		LinkedBlockingQueue r = (LinkedBlockingQueue)in.readObject();
934		assertEquals(q.size(), r.size());
935	<	while (!q.isEmpty())
935	>	while (!q.isEmpty())
936		assertEquals(q.remove(), r.remove());
937	<	} catch(Exception e){
938	<	e.printStackTrace();
939	<	fail("unexpected exception");
937	>	} catch (Exception e) {
938	>	unexpectedException();
939	>	}
940	>	}
941	>
942	>	/**
943	>	* drainTo(null) throws NPE
944	>	*/
945	>	public void testDrainToNull() {
946	>	LinkedBlockingQueue q = populatedQueue(SIZE);
947	>	try {
948	>	q.drainTo(null);
949	>	shouldThrow();
950	>	} catch (NullPointerException success) {
951	>	}
952	>	}
953	>
954	>	/**
955	>	* drainTo(this) throws IAE
956	>	*/
957	>	public void testDrainToSelf() {
958	>	LinkedBlockingQueue q = populatedQueue(SIZE);
959	>	try {
960	>	q.drainTo(q);
961	>	shouldThrow();
962	>	} catch (IllegalArgumentException success) {
963	>	}
964	>	}
965	>
966	>	/**
967	>	* drainTo(c) empties queue into another collection c
968	>	*/
969	>	public void testDrainTo() {
970	>	LinkedBlockingQueue q = populatedQueue(SIZE);
971	>	ArrayList l = new ArrayList();
972	>	q.drainTo(l);
973	>	assertEquals(q.size(), 0);
974	>	assertEquals(l.size(), SIZE);
975	>	for (int i = 0; i < SIZE; ++i)
976	>	assertEquals(l.get(i), new Integer(i));
977	>	q.add(zero);
978	>	q.add(one);
979	>	assertFalse(q.isEmpty());
980	>	assertTrue(q.contains(zero));
981	>	assertTrue(q.contains(one));
982	>	l.clear();
983	>	q.drainTo(l);
984	>	assertEquals(q.size(), 0);
985	>	assertEquals(l.size(), 2);
986	>	for (int i = 0; i < 2; ++i)
987	>	assertEquals(l.get(i), new Integer(i));
988	>	}
989	>
990	>	/**
991	>	* drainTo empties full queue, unblocking a waiting put.
992	>	*/
993	>	public void testDrainToWithActivePut() {
994	>	final LinkedBlockingQueue q = populatedQueue(SIZE);
995	>	Thread t = new Thread(new Runnable() {
996	>	public void run() {
997	>	try {
998	>	q.put(new Integer(SIZE+1));
999	>	} catch (InterruptedException ie) {
1000	>	threadUnexpectedException();
1001	>	}
1002	>	}
1003	>	});
1004	>	try {
1005	>	t.start();
1006	>	ArrayList l = new ArrayList();
1007	>	q.drainTo(l);
1008	>	assertTrue(l.size() >= SIZE);
1009	>	for (int i = 0; i < SIZE; ++i)
1010	>	assertEquals(l.get(i), new Integer(i));
1011	>	t.join();
1012	>	assertTrue(q.size() + l.size() >= SIZE);
1013	>	} catch (Exception e) {
1014	>	unexpectedException();
1015	>	}
1016	>	}
1017	>
1018	>	/**
1019	>	* drainTo(null, n) throws NPE
1020	>	*/
1021	>	public void testDrainToNullN() {
1022	>	LinkedBlockingQueue q = populatedQueue(SIZE);
1023	>	try {
1024	>	q.drainTo(null, 0);
1025	>	shouldThrow();
1026	>	} catch (NullPointerException success) {
1027	>	}
1028	>	}
1029	>
1030	>	/**
1031	>	* drainTo(this, n) throws IAE
1032	>	*/
1033	>	public void testDrainToSelfN() {
1034	>	LinkedBlockingQueue q = populatedQueue(SIZE);
1035	>	try {
1036	>	q.drainTo(q, 0);
1037	>	shouldThrow();
1038	>	} catch (IllegalArgumentException success) {
1039	>	}
1040	>	}
1041	>
1042	>	/**
1043	>	* drainTo(c, n) empties first max {n, size} elements of queue into c
1044	>	*/
1045	>	public void testDrainToN() {
1046	>	LinkedBlockingQueue q = new LinkedBlockingQueue();
1047	>	for (int i = 0; i < SIZE + 2; ++i) {
1048	>	for (int j = 0; j < SIZE; j++)
1049	>	assertTrue(q.offer(new Integer(j)));
1050	>	ArrayList l = new ArrayList();
1051	>	q.drainTo(l, i);
1052	>	int k = (i < SIZE)? i : SIZE;
1053	>	assertEquals(l.size(), k);
1054	>	assertEquals(q.size(), SIZE-k);
1055	>	for (int j = 0; j < k; ++j)
1056	>	assertEquals(l.get(j), new Integer(j));
1057	>	while (q.poll() != null) ;
1058		}
1059		}
1060

Diff Legend

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