ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.4 by jsr166, Sat Aug 1 22:09:13 2009 UTC vs.
Revision 1.9 by jsr166, Wed Aug 5 00:43:23 2009 UTC

#	Line 17 | Line 17 | import java.util.ConcurrentModificationE
17		import java.util.Iterator;
18		import java.util.NoSuchElementException;
19		import java.util.concurrent.*;
20	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21		import junit.framework.Test;
22		import junit.framework.TestSuite;
23
#	Line 31 | Line 32 | public class LinkedTransferQueueTest ext
32		}
33
34		/**
35	<	* Constructor builds new queue with size being zero and empty being true
35	>	* Constructor builds new queue with size being zero and empty
36	>	* being true
37		*/
38		public void testConstructor1() {
39		assertEquals(0, new LinkedTransferQueue().size());
#	Line 39 | Line 41 | public class LinkedTransferQueueTest ext
41		}
42
43		/**
44	<	* Initializing constructor with null collection throws NPE
44	>	* Initializing constructor with null collection throws
45	>	* NullPointerException
46		*/
47		public void testConstructor2() {
48		try {
#	Line 50 | Line 53 | public class LinkedTransferQueueTest ext
53		}
54
55		/**
56	<	* Initializing from Collection of null elements throws NPE
56	>	* Initializing from Collection of null elements throws
57	>	* NullPointerException
58		*/
59		public void testConstructor3() {
60		try {
61		Integer[] ints = new Integer[SIZE];
62	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
62	>	new LinkedTransferQueue(Arrays.asList(ints));
63		shouldThrow();
64		} catch (NullPointerException success) {
65		}
#	Line 63 | Line 67 | public class LinkedTransferQueueTest ext
67
68		/**
69		* Initializing constructor with a collection containing some null elements
70	<	* throws NPE
70	>	* throws NullPointerException
71		*/
72		public void testConstructor4() {
73		try {
74		Integer[] ints = new Integer[SIZE];
75		for (int i = 0; i < SIZE - 1; ++i) {
76	<	ints[i] = new Integer(i);
76	>	ints[i] = i;
77		}
78	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
78	>	new LinkedTransferQueue(Arrays.asList(ints));
79		shouldThrow();
80		} catch (NullPointerException success) {
81		}
#	Line 84 | Line 88 | public class LinkedTransferQueueTest ext
88		try {
89		Integer[] ints = new Integer[SIZE];
90		for (int i = 0; i < SIZE; ++i) {
91	<	ints[i] = new Integer(i);
91	>	ints[i] = i;
92		}
93	<	LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
93	>	LinkedTransferQueue q
94	>	= new LinkedTransferQueue(Arrays.asList(ints));
95		for (int i = 0; i < SIZE; ++i) {
96		assertEquals(ints[i], q.poll());
97		}
#	Line 98 | Line 103 | public class LinkedTransferQueueTest ext
103		* Remaining capacity never decrease nor increase on add or remove
104		*/
105		public void testRemainingCapacity() {
106	<	LinkedTransferQueue q = populatedQueue(SIZE);
102	<	int remainingCapacity = q.remainingCapacity();
106	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
107		for (int i = 0; i < SIZE; ++i) {
108	<	assertEquals(remainingCapacity, q.remainingCapacity());
108	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
109		assertEquals(SIZE - i, q.size());
110		q.remove();
111		}
112		for (int i = 0; i < SIZE; ++i) {
113	<	assertEquals(remainingCapacity, q.remainingCapacity());
113	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
114		assertEquals(i, q.size());
115	<	q.add(new Integer(i));
115	>	q.add(i);
116		}
117		}
118
119		/**
120	<	* offer(null) throws NPE
120	>	* offer(null) throws NullPointerException
121		*/
122		public void testOfferNull() {
123		try {
#	Line 125 | Line 129 | public class LinkedTransferQueueTest ext
129		}
130
131		/**
132	<	* add(null) throws NPE
132	>	* add(null) throws NullPointerException
133		*/
134		public void testAddNull() {
135		try {
#	Line 137 | Line 141 | public class LinkedTransferQueueTest ext
141		}
142
143		/**
144	<	* addAll(null) throws NPE
144	>	* addAll(null) throws NullPointerException
145		*/
146		public void testAddAll1() {
147		try {
#	Line 149 | Line 153 | public class LinkedTransferQueueTest ext
153		}
154
155		/**
156	<	* addAll(this) throws IAE
156	>	* addAll(this) throws IllegalArgumentException
157		*/
158		public void testAddAllSelf() {
159		try {
#	Line 161 | Line 165 | public class LinkedTransferQueueTest ext
165		}
166
167		/**
168	<	* addAll of a collection with null elements throws NPE
168	>	* addAll of a collection with null elements throws NullPointerException
169		*/
170		public void testAddAll2() {
171		try {
#	Line 174 | Line 178 | public class LinkedTransferQueueTest ext
178		}
179
180		/**
181	<	* addAll of a collection with any null elements throws NPE after
182	<	* possibly adding some elements
181	>	* addAll of a collection with any null elements throws
182	>	* NullPointerException after possibly adding some elements
183		*/
184		public void testAddAll3() {
185		try {
186		LinkedTransferQueue q = new LinkedTransferQueue();
187		Integer[] ints = new Integer[SIZE];
188		for (int i = 0; i < SIZE - 1; ++i) {
189	<	ints[i] = new Integer(i);
189	>	ints[i] = i;
190		}
191		q.addAll(Arrays.asList(ints));
192		shouldThrow();
#	Line 194 | Line 198 | public class LinkedTransferQueueTest ext
198		* Queue contains all elements, in traversal order, of successful addAll
199		*/
200		public void testAddAll5() {
201	<	try {
202	<	Integer[] empty = new Integer[0];
203	<	Integer[] ints = new Integer[SIZE];
204	<	for (int i = 0; i < SIZE; ++i) {
205	<	ints[i] = new Integer(i);
206	<	}
207	<	LinkedTransferQueue q = new LinkedTransferQueue();
208	<	assertFalse(q.addAll(Arrays.asList(empty)));
209	<	assertTrue(q.addAll(Arrays.asList(ints)));
210	<	for (int i = 0; i < SIZE; ++i) {
207	<	assertEquals(ints[i], q.poll());
208	<	}
209	<	} finally {
201	>	Integer[] empty = new Integer[0];
202	>	Integer[] ints = new Integer[SIZE];
203	>	for (int i = 0; i < SIZE; ++i) {
204	>	ints[i] = i;
205	>	}
206	>	LinkedTransferQueue q = new LinkedTransferQueue();
207	>	assertFalse(q.addAll(Arrays.asList(empty)));
208	>	assertTrue(q.addAll(Arrays.asList(ints)));
209	>	for (int i = 0; i < SIZE; ++i) {
210	>	assertEquals(ints[i], q.poll());
211		}
212		}
213
214		/**
215	<	* put(null) throws NPE
215	>	* put(null) throws NullPointerException
216		*/
217	<	public void testPutNull() {
217	>	public void testPutNull() throws InterruptedException {
218		try {
219		LinkedTransferQueue q = new LinkedTransferQueue();
220		q.put(null);
221		shouldThrow();
222	<	} catch (NullPointerException success) {
222	<	} catch (Exception ie) {
223	<	unexpectedException();
224	<	}
222	>	} catch (NullPointerException success) {}
223		}
224
225		/**
226		* all elements successfully put are contained
227		*/
228		public void testPut() {
229	<	try {
230	<	LinkedTransferQueue q = new LinkedTransferQueue();
231	<	for (int i = 0; i < SIZE; ++i) {
232	<	Integer I = new Integer(i);
235	<	q.put(I);
236	<	assertTrue(q.contains(I));
237	<	}
238	<	} catch (Exception ie) {
239	<	unexpectedException();
229	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
230	>	for (int i = 0; i < SIZE; ++i) {
231	>	q.put(i);
232	>	assertTrue(q.contains(i));
233		}
234	+	assertEquals(q.size(), SIZE);
235		}
236
237		/**
238		* take retrieves elements in FIFO order
239		*/
240	<	public void testTake() {
241	<	try {
242	<	LinkedTransferQueue q = populatedQueue(SIZE);
243	<	for (int i = 0; i < SIZE; ++i) {
250	<	assertEquals(i, ((Integer) q.take()).intValue());
251	<	}
252	<	} catch (InterruptedException e) {
253	<	unexpectedException();
240	>	public void testTake() throws InterruptedException {
241	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
242	>	for (int i = 0; i < SIZE; ++i) {
243	>	assertEquals(i, (int) q.take());
244		}
245		}
246
247		/**
248		* take blocks interruptibly when empty
249		*/
250	<	public void testTakeFromEmpty() {
250	>	public void testTakeFromEmpty() throws InterruptedException {
251		final LinkedTransferQueue q = new LinkedTransferQueue();
252	<	Thread t = new Thread(new Runnable() {
253	<
254	<	public void run() {
255	<	try {
256	<	q.take();
257	<	threadShouldThrow();
258	<	} catch (InterruptedException success) {
269	<	}
270	<	}
271	<	});
272	<	try {
273	<	t.start();
274	<	Thread.sleep(SHORT_DELAY_MS);
275	<	t.interrupt();
276	<	t.join();
277	<	} catch (Exception e) {
278	<	unexpectedException();
279	<	}
252	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
253	>	void realRun() throws InterruptedException {
254	>	q.take();
255	>	}});
256	>	Thread.sleep(SHORT_DELAY_MS);
257	>	t.interrupt();
258	>	t.join();
259		}
260
261		/**
262		* Take removes existing elements until empty, then blocks interruptibly
263		*/
264	<	public void testBlockingTake() {
265	<	Thread t = new Thread(new Runnable() {
266	<
267	<	public void run() {
268	<	try {
269	<	LinkedTransferQueue q = populatedQueue(SIZE);
291	<	for (int i = 0; i < SIZE; ++i) {
292	<	assertEquals(i, ((Integer) q.take()).intValue());
293	<	}
294	<	q.take();
295	<	threadShouldThrow();
296	<	} catch (InterruptedException success) {
264	>	public void testBlockingTake() throws InterruptedException {
265	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
266	>	void realRun() throws InterruptedException {
267	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
268	>	for (int i = 0; i < SIZE; ++i) {
269	>	threadAssertEquals(i, (int) q.take());
270		}
271	<	}
272	<	});
273	<	t.start();
274	<	try {
275	<	Thread.sleep(SHORT_DELAY_MS);
303	<	t.interrupt();
304	<	t.join();
305	<	} catch (InterruptedException ie) {
306	<	unexpectedException();
307	<	}
271	>	q.take();
272	>	}});
273	>	Thread.sleep(SHORT_DELAY_MS);
274	>	t.interrupt();
275	>	t.join();
276		}
277
278		/**
279		* poll succeeds unless empty
280		*/
281		public void testPoll() {
282	<	LinkedTransferQueue q = populatedQueue(SIZE);
282	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
283		for (int i = 0; i < SIZE; ++i) {
284	<	assertEquals(i, ((Integer) q.poll()).intValue());
284	>	assertEquals(i, (int) q.poll());
285		}
286		assertNull(q.poll());
287		}
#	Line 321 | Line 289 | public class LinkedTransferQueueTest ext
289		/**
290		* timed pool with zero timeout succeeds when non-empty, else times out
291		*/
292	<	public void testTimedPoll0() {
293	<	try {
294	<	LinkedTransferQueue q = populatedQueue(SIZE);
295	<	for (int i = 0; i < SIZE; ++i) {
328	<	assertEquals(i, ((Integer) q.poll(0, TimeUnit.MILLISECONDS)).intValue());
329	<	}
330	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
331	<	} catch (InterruptedException e) {
332	<	unexpectedException();
292	>	public void testTimedPoll0() throws InterruptedException {
293	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
294	>	for (int i = 0; i < SIZE; ++i) {
295	>	assertEquals(i, (int) q.poll(0, MILLISECONDS));
296		}
297	+	assertNull(q.poll(0, MILLISECONDS));
298		}
299
300		/**
301		* timed pool with nonzero timeout succeeds when non-empty, else times out
302		*/
303	<	public void testTimedPoll() {
304	<	try {
305	<	LinkedTransferQueue q = populatedQueue(SIZE);
306	<	for (int i = 0; i < SIZE; ++i) {
343	<	assertEquals(i, ((Integer) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
344	<	}
345	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
346	<	} catch (InterruptedException e) {
347	<	unexpectedException();
303	>	public void testTimedPoll() throws InterruptedException {
304	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
305	>	for (int i = 0; i < SIZE; ++i) {
306	>	assertEquals(i, (int) q.poll(SHORT_DELAY_MS, MILLISECONDS));
307		}
308	+	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
309		}
310
311		/**
312		* Interrupted timed poll throws InterruptedException instead of
313		* returning timeout status
314		*/
315	<	public void testInterruptedTimedPoll() {
316	<	Thread t = new Thread(new Runnable() {
317	<
318	<	public void run() {
319	<	try {
320	<	LinkedTransferQueue q = populatedQueue(SIZE);
321	<	for (int i = 0; i < SIZE; ++i) {
362	<	threadAssertEquals(i, ((Integer) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
363	<	}
364	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
365	<	} catch (InterruptedException success) {
315	>	public void testInterruptedTimedPoll() throws InterruptedException {
316	>	final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
317	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
318	>	void realRun() throws InterruptedException {
319	>	for (int i = 0; i < SIZE; ++i) {
320	>	threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
321	>	MILLISECONDS));
322		}
323	<	}
324	<	});
325	<	t.start();
326	<	try {
327	<	Thread.sleep(SHORT_DELAY_MS);
328	<	t.interrupt();
329	<	t.join();
374	<	} catch (InterruptedException ie) {
375	<	unexpectedException();
376	<	}
323	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
324	>	}});
325	>	Thread.sleep(SMALL_DELAY_MS);
326	>	t.interrupt();
327	>	t.join();
328	>	assertEquals(q.size(), 0);
329	>	assertNull(q.poll());
330		}
331
332		/**
333		* timed poll before a delayed offer fails; after offer succeeds;
334		* on interruption throws
335		*/
336	<	public void testTimedPollWithOffer() {
336	>	public void testTimedPollWithOffer() throws InterruptedException {
337		final LinkedTransferQueue q = new LinkedTransferQueue();
338	<	Thread t = new Thread(new Runnable() {
339	<
340	<	public void run() {
341	<	try {
342	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
343	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
344	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
345	<	threadShouldThrow();
346	<	} catch (InterruptedException success) {
347	<	}
395	<	}
396	<	});
397	<	try {
398	<	t.start();
399	<	Thread.sleep(SMALL_DELAY_MS);
400	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
401	<	t.interrupt();
402	<	t.join();
403	<	} catch (Exception e) {
404	<	unexpectedException();
405	<	}
338	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
339	>	void realRun() throws InterruptedException {
340	>	threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
341	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
342	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
343	>	}});
344	>	Thread.sleep(SMALL_DELAY_MS);
345	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
346	>	t.interrupt();
347	>	t.join();
348		}
349
350		/**
351		* peek returns next element, or null if empty
352		*/
353		public void testPeek() {
354	<	LinkedTransferQueue q = populatedQueue(SIZE);
354	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
355		for (int i = 0; i < SIZE; ++i) {
356	<	assertEquals(i, ((Integer) q.peek()).intValue());
357	<	q.poll();
356	>	assertEquals(i, (int) q.peek());
357	>	assertEquals(i, (int) q.poll());
358		assertTrue(q.peek() == null ||
359	<	i != ((Integer) q.peek()).intValue());
359	>	i != (int) q.peek());
360		}
361		assertNull(q.peek());
362		}
363
364		/**
365	<	* element returns next element, or throws NSEE if empty
365	>	* element returns next element, or throws NoSuchElementException if empty
366		*/
367		public void testElement() {
368	<	LinkedTransferQueue q = populatedQueue(SIZE);
368	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
369		for (int i = 0; i < SIZE; ++i) {
370	<	assertEquals(i, ((Integer) q.element()).intValue());
371	<	q.poll();
370	>	assertEquals(i, (int) q.element());
371	>	assertEquals(i, (int) q.poll());
372		}
373		try {
374		q.element();
#	Line 436 | Line 378 | public class LinkedTransferQueueTest ext
378		}
379
380		/**
381	<	* remove removes next element, or throws NSEE if empty
381	>	* remove removes next element, or throws NoSuchElementException if empty
382		*/
383		public void testRemove() {
384	<	LinkedTransferQueue q = populatedQueue(SIZE);
384	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
385		for (int i = 0; i < SIZE; ++i) {
386	<	assertEquals(i, ((Integer) q.remove()).intValue());
386	>	assertEquals(i, (int) q.remove());
387		}
388		try {
389		q.remove();
#	Line 456 | Line 398 | public class LinkedTransferQueueTest ext
398		public void testRemoveElement() {
399		LinkedTransferQueue q = populatedQueue(SIZE);
400		for (int i = 1; i < SIZE; i += 2) {
401	<	assertTrue(q.remove(new Integer(i)));
401	>	assertTrue(q.remove(i));
402		}
403		for (int i = 0; i < SIZE; i += 2) {
404	<	assertTrue(q.remove(new Integer(i)));
405	<	assertFalse(q.remove(new Integer(i + 1)));
404	>	assertTrue(q.remove(i));
405	>	assertFalse(q.remove(i + 1));
406		}
407		assertTrue(q.isEmpty());
408		}
#	Line 468 | Line 410 | public class LinkedTransferQueueTest ext
410		/**
411		* An add following remove(x) succeeds
412		*/
413	<	public void testRemoveElementAndAdd() {
414	<	try {
415	<	LinkedTransferQueue q = new LinkedTransferQueue();
416	<	assertTrue(q.add(new Integer(1)));
417	<	assertTrue(q.add(new Integer(2)));
418	<	assertTrue(q.remove(new Integer(1)));
419	<	assertTrue(q.remove(new Integer(2)));
420	<	assertTrue(q.add(new Integer(3)));
479	<	assertTrue(q.take() != null);
480	<	} catch (Exception e) {
481	<	unexpectedException();
482	<	}
413	>	public void testRemoveElementAndAdd() throws InterruptedException {
414	>	LinkedTransferQueue q = new LinkedTransferQueue();
415	>	assertTrue(q.add(one));
416	>	assertTrue(q.add(two));
417	>	assertTrue(q.remove(one));
418	>	assertTrue(q.remove(two));
419	>	assertTrue(q.add(three));
420	>	assertTrue(q.take() != null);
421		}
422
423		/**
424		* contains(x) reports true when elements added but not yet removed
425		*/
426		public void testContains() {
427	<	LinkedTransferQueue q = populatedQueue(SIZE);
427	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
428		for (int i = 0; i < SIZE; ++i) {
429	<	assertTrue(q.contains(new Integer(i)));
430	<	q.poll();
431	<	assertFalse(q.contains(new Integer(i)));
429	>	assertTrue(q.contains(i));
430	>	assertEquals(i, (int) q.poll());
431	>	assertFalse(q.contains(i));
432		}
433		}
434
#	Line 499 | Line 437 | public class LinkedTransferQueueTest ext
437		*/
438		public void testClear() {
439		LinkedTransferQueue q = populatedQueue(SIZE);
502	–	int remainingCapacity = q.remainingCapacity();
440		q.clear();
441		assertTrue(q.isEmpty());
442		assertEquals(0, q.size());
443	<	assertEquals(remainingCapacity, q.remainingCapacity());
443	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
444		q.add(one);
445		assertFalse(q.isEmpty());
446		assertTrue(q.contains(one));
#	Line 515 | Line 452 | public class LinkedTransferQueueTest ext
452		* containsAll(c) is true when c contains a subset of elements
453		*/
454		public void testContainsAll() {
455	<	LinkedTransferQueue q = populatedQueue(SIZE);
456	<	LinkedTransferQueue p = new LinkedTransferQueue();
455	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
456	>	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
457		for (int i = 0; i < SIZE; ++i) {
458		assertTrue(q.containsAll(p));
459		assertFalse(p.containsAll(q));
460	<	p.add(new Integer(i));
460	>	p.add(i);
461		}
462		assertTrue(p.containsAll(q));
463		}
464
465		/**
466	<	* retainAll(c) retains only those elements of c and reports true if changed
466	>	* retainAll(c) retains only those elements of c and reports true
467	>	* if changed
468		*/
469		public void testRetainAll() {
470		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 545 | Line 483 | public class LinkedTransferQueueTest ext
483		}
484
485		/**
486	<	* removeAll(c) removes only those elements of c and reports true if changed
486	>	* removeAll(c) removes only those elements of c and reports true
487	>	* if changed
488		*/
489		public void testRemoveAll() {
490		for (int i = 1; i < SIZE; ++i) {
#	Line 554 | Line 493 | public class LinkedTransferQueueTest ext
493		assertTrue(q.removeAll(p));
494		assertEquals(SIZE - i, q.size());
495		for (int j = 0; j < i; ++j) {
496	<	Integer I = (Integer) (p.remove());
558	<	assertFalse(q.contains(I));
496	>	assertFalse(q.contains(p.remove()));
497		}
498		}
499		}
#	Line 563 | Line 501 | public class LinkedTransferQueueTest ext
501		/**
502		* toArray contains all elements
503		*/
504	<	public void testToArray() {
504	>	public void testToArray() throws InterruptedException {
505		LinkedTransferQueue q = populatedQueue(SIZE);
506		Object[] o = q.toArray();
507	<	try {
508	<	for (int i = 0; i < o.length; i++) {
571	<	assertEquals(o[i], q.take());
572	<	}
573	<	} catch (InterruptedException e) {
574	<	unexpectedException();
507	>	for (int i = 0; i < o.length; i++) {
508	>	assertEquals(o[i], q.take());
509		}
510		}
511
512		/**
513		* toArray(a) contains all elements
514		*/
515	<	public void testToArray2() {
516	<	LinkedTransferQueue q = populatedQueue(SIZE);
515	>	public void testToArray2() throws InterruptedException {
516	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
517		Integer[] ints = new Integer[SIZE];
518	<	ints = (Integer[]) q.toArray(ints);
519	<	try {
520	<	for (int i = 0; i < ints.length; i++) {
587	<	assertEquals(ints[i], q.take());
588	<	}
589	<	} catch (InterruptedException e) {
590	<	unexpectedException();
518	>	ints = q.toArray(ints);
519	>	for (int i = 0; i < ints.length; i++) {
520	>	assertEquals(ints[i], q.take());
521		}
522		}
523
524		/**
525	<	* toArray(null) throws NPE
525	>	* toArray(null) throws NullPointerException
526		*/
527		public void testToArray_BadArg() {
528		try {
#	Line 618 | Line 548 | public class LinkedTransferQueueTest ext
548		/**
549		* iterator iterates through all elements
550		*/
551	<	public void testIterator() {
551	>	public void testIterator() throws InterruptedException {
552		LinkedTransferQueue q = populatedQueue(SIZE);
553		Iterator it = q.iterator();
554	<	try {
555	<	while (it.hasNext()) {
626	<	assertEquals(it.next(), q.take());
627	<	}
628	<	} catch (InterruptedException e) {
629	<	unexpectedException();
554	>	while (it.hasNext()) {
555	>	assertEquals(it.next(), q.take());
556		}
557		}
558
#	Line 653 | Line 579 | public class LinkedTransferQueueTest ext
579		* iterator ordering is FIFO
580		*/
581		public void testIteratorOrdering() {
582	<	final LinkedTransferQueue q = new LinkedTransferQueue();
583	<	int remainingCapacity = q.remainingCapacity();
582	>	final LinkedTransferQueue<Integer> q
583	>	= new LinkedTransferQueue<Integer>();
584	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
585		q.add(one);
586		q.add(two);
587		q.add(three);
588	<	assertEquals(remainingCapacity, q.remainingCapacity());
588	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
589		int k = 0;
590	<	for (Iterator it = q.iterator(); it.hasNext();) {
591	<	int i = ((Integer) (it.next())).intValue();
665	<	assertEquals(++k, i);
590	>	for (Integer n : q) {
591	>	assertEquals(++k, (int) n);
592		}
593		assertEquals(3, k);
594		}
#	Line 675 | Line 601 | public class LinkedTransferQueueTest ext
601		q.add(one);
602		q.add(two);
603		q.add(three);
604	<	try {
605	<	for (Iterator it = q.iterator(); it.hasNext();) {
606	<	q.remove();
681	<	it.next();
682	<	}
683	<	} catch (ConcurrentModificationException e) {
684	<	unexpectedException();
604	>	for (Iterator it = q.iterator(); it.hasNext();) {
605	>	q.remove();
606	>	it.next();
607		}
608		assertEquals(0, q.size());
609		}
#	Line 705 | Line 627 | public class LinkedTransferQueueTest ext
627		q.add(one);
628		q.add(two);
629		ExecutorService executor = Executors.newFixedThreadPool(2);
708	–	executor.execute(new Runnable() {
709	–
710	–	public void run() {
711	–	try {
712	–	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
713	–	} catch (Exception e) {
714	–	threadUnexpectedException();
715	–	}
716	–	}
717	–	});
630
631	<	executor.execute(new Runnable() {
632	<
633	<	public void run() {
634	<	try {
635	<	Thread.sleep(SMALL_DELAY_MS);
636	<	threadAssertEquals(one, q.take());
637	<	} catch (InterruptedException e) {
638	<	threadUnexpectedException();
639	<	}
640	<	}
641	<	});
631	>	executor.execute(new CheckedRunnable() {
632	>	void realRun() {
633	>	threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
634	>	MILLISECONDS));
635	>	}});
636	>
637	>	executor.execute(new CheckedRunnable() {
638	>	void realRun() throws InterruptedException {
639	>	Thread.sleep(SMALL_DELAY_MS);
640	>	threadAssertEquals(one, q.take());
641	>	}});
642
643		joinPool(executor);
644		}
#	Line 737 | Line 649 | public class LinkedTransferQueueTest ext
649		public void testPollInExecutor() {
650		final LinkedTransferQueue q = new LinkedTransferQueue();
651		ExecutorService executor = Executors.newFixedThreadPool(2);
740	–	executor.execute(new Runnable() {
652
653	<	public void run() {
653	>	executor.execute(new CheckedRunnable() {
654	>	void realRun() throws InterruptedException {
655		threadAssertNull(q.poll());
656	<	try {
657	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
658	<	threadAssertTrue(q.isEmpty());
659	<	} catch (InterruptedException e) {
660	<	threadUnexpectedException();
661	<	}
662	<	}
663	<	});
664	<
665	<	executor.execute(new Runnable() {
754	<
755	<	public void run() {
756	<	try {
757	<	Thread.sleep(SMALL_DELAY_MS);
758	<	q.put(one);
759	<	} catch (InterruptedException e) {
760	<	threadUnexpectedException();
761	<	}
762	<	}
763	<	});
656	>	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
657	>	MILLISECONDS));
658	>	threadAssertTrue(q.isEmpty());
659	>	}});
660	>
661	>	executor.execute(new CheckedRunnable() {
662	>	void realRun() throws InterruptedException {
663	>	Thread.sleep(SMALL_DELAY_MS);
664	>	q.put(one);
665	>	}});
666
667		joinPool(executor);
668		}
#	Line 768 | Line 670 | public class LinkedTransferQueueTest ext
670		/**
671		* A deserialized serialized queue has same elements in same order
672		*/
673	<	public void testSerialization() {
673	>	public void testSerialization() throws Exception {
674		LinkedTransferQueue q = populatedQueue(SIZE);
675
676	<	try {
677	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
678	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
679	<	out.writeObject(q);
680	<	out.close();
681	<
682	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
683	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
684	<	LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
685	<
686	<	assertEquals(q.size(), r.size());
687	<	while (!q.isEmpty()) {
688	<	assertEquals(q.remove(), r.remove());
689	<	}
690	<	} catch (Exception e) {
789	<	unexpectedException();
676	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
677	>	ObjectOutputStream out
678	>	= new ObjectOutputStream(new BufferedOutputStream(bout));
679	>	out.writeObject(q);
680	>	out.close();
681	>
682	>	ByteArrayInputStream bin
683	>	= new ByteArrayInputStream(bout.toByteArray());
684	>	ObjectInputStream in
685	>	= new ObjectInputStream(new BufferedInputStream(bin));
686	>	LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
687	>
688	>	assertEquals(q.size(), r.size());
689	>	while (!q.isEmpty()) {
690	>	assertEquals(q.remove(), r.remove());
691		}
692		}
693
694		/**
695	<	* drainTo(null) throws NPE
695	>	* drainTo(null) throws NullPointerException
696		*/
697		public void testDrainToNull() {
698		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 803 | Line 704 | public class LinkedTransferQueueTest ext
704		}
705
706		/**
707	<	* drainTo(this) throws IAE
707	>	* drainTo(this) throws IllegalArgumentException
708		*/
709		public void testDrainToSelf() {
710		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 824 | Line 725 | public class LinkedTransferQueueTest ext
725		assertEquals(q.size(), 0);
726		assertEquals(l.size(), SIZE);
727		for (int i = 0; i < SIZE; ++i) {
728	<	assertEquals(l.get(i), new Integer(i));
728	>	assertEquals(l.get(i), i);
729		}
730		q.add(zero);
731		q.add(one);
#	Line 836 | Line 737 | public class LinkedTransferQueueTest ext
737		assertEquals(q.size(), 0);
738		assertEquals(l.size(), 2);
739		for (int i = 0; i < 2; ++i) {
740	<	assertEquals(l.get(i), new Integer(i));
740	>	assertEquals(l.get(i), i);
741		}
742		}
743
744		/**
745		* drainTo empties full queue, unblocking a waiting put.
746		*/
747	<	public void testDrainToWithActivePut() {
747	>	public void testDrainToWithActivePut() throws InterruptedException {
748		final LinkedTransferQueue q = populatedQueue(SIZE);
749	<	Thread t = new Thread(new Runnable() {
750	<
751	<	public void run() {
752	<	try {
753	<	q.put(new Integer(SIZE + 1));
754	<	} catch (Exception ie) {
755	<	threadUnexpectedException();
756	<	}
757	<	}
857	<	});
858	<	try {
859	<	t.start();
860	<	ArrayList l = new ArrayList();
861	<	q.drainTo(l);
862	<	assertTrue(l.size() >= SIZE);
863	<	for (int i = 0; i < SIZE; ++i) {
864	<	assertEquals(l.get(i), new Integer(i));
865	<	}
866	<	t.join();
867	<	assertTrue(q.size() + l.size() >= SIZE);
868	<	} catch (Exception e) {
869	<	unexpectedException();
749	>	Thread t = newStartedThread(new CheckedRunnable() {
750	>	void realRun() {
751	>	q.put(SIZE + 1);
752	>	}});
753	>	ArrayList l = new ArrayList();
754	>	q.drainTo(l);
755	>	assertTrue(l.size() >= SIZE);
756	>	for (int i = 0; i < SIZE; ++i) {
757	>	assertEquals(l.get(i), i);
758		}
759	+	t.join();
760	+	assertTrue(q.size() + l.size() >= SIZE);
761		}
762
763		/**
764	<	* drainTo(null, n) throws NPE
764	>	* drainTo(null, n) throws NullPointerException
765		*/
766		public void testDrainToNullN() {
767		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 883 | Line 773 | public class LinkedTransferQueueTest ext
773		}
774
775		/**
776	<	* drainTo(this, n) throws IAE
776	>	* drainTo(this, n) throws IllegalArgumentException
777		*/
778		public void testDrainToSelfN() {
779		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 901 | Line 791 | public class LinkedTransferQueueTest ext
791		LinkedTransferQueue q = new LinkedTransferQueue();
792		for (int i = 0; i < SIZE + 2; ++i) {
793		for (int j = 0; j < SIZE; j++) {
794	<	assertTrue(q.offer(new Integer(j)));
794	>	assertTrue(q.offer(j));
795		}
796		ArrayList l = new ArrayList();
797		q.drainTo(l, i);
#	Line 909 | Line 799 | public class LinkedTransferQueueTest ext
799		assertEquals(l.size(), k);
800		assertEquals(q.size(), SIZE - k);
801		for (int j = 0; j < k; ++j) {
802	<	assertEquals(l.get(j), new Integer(j));
802	>	assertEquals(l.get(j), j);
803		}
804	<	while (q.poll() != null);
804	>	while (q.poll() != null)
805	>	;
806		}
807		}
808
809		/**
810	<	* poll and take should decrement the waiting consumer count
810	>	* poll and take decrement the waiting consumer count
811		*/
812	<	public void testWaitingConsumer() {
813	<	try {
814	<	final LinkedTransferQueue q = new LinkedTransferQueue();
924	<	final ConsumerObserver waiting = new ConsumerObserver();
925	<	new Thread(new Runnable() {
812	>	public void testWaitingConsumer() throws InterruptedException {
813	>	final LinkedTransferQueue q = new LinkedTransferQueue();
814	>	final ConsumerObserver waiting = new ConsumerObserver();
815
816	<	public void run() {
817	<	try {
818	<	threadAssertTrue(q.hasWaitingConsumer());
819	<	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
820	<	threadAssertTrue(q.offer(new Object()));
821	<	} catch (Exception ex) {
822	<	threadUnexpectedException();
934	<	}
816	>	Thread t = newStartedThread(new CheckedRunnable() {
817	>	void realRun() throws InterruptedException {
818	>	Thread.sleep(SMALL_DELAY_MS);
819	>	threadAssertTrue(q.hasWaitingConsumer());
820	>	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
821	>	threadAssertTrue(q.offer(new Object()));
822	>	}});
823
824	<	}
825	<	}).start();
826	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
827	<	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
940	<	} catch (Exception ex) {
941	<	this.unexpectedException();
942	<	}
824	>	assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
825	>	assertTrue(q.getWaitingConsumerCount()
826	>	< waiting.getWaitingConsumers());
827	>	t.join();
828		}
829
830		/**
831	<	* Inserts null into transfer throws NPE
831	>	* transfer(null) throws NullPointerException
832		*/
833	<	public void testTransfer1() {
833	>	public void testTransfer1() throws InterruptedException {
834		try {
835		LinkedTransferQueue q = new LinkedTransferQueue();
836		q.transfer(null);
837		shouldThrow();
838		} catch (NullPointerException ex) {
954	–	} catch (Exception ex) {
955	–	this.unexpectedException();
839		}
840		}
841
842		/**
843	<	* transfer attempts to insert into the queue then wait until that
844	<	* object is removed via take or poll.
843	>	* transfer waits until a poll occurs. The transfered element
844	>	* is returned by this associated poll.
845		*/
846	<	public void testTransfer2() {
847	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
848	<	new Thread(new Runnable() {
849	<
850	<	public void run() {
851	<	try {
852	<	q.transfer(new Integer(SIZE));
853	<	threadAssertTrue(q.isEmpty());
854	<	} catch (Exception ex) {
855	<	threadUnexpectedException();
856	<	}
857	<	}
858	<	}).start();
859	<
860	<	try {
978	<	Thread.sleep(SHORT_DELAY_MS);
979	<	assertEquals(1, q.size());
980	<	q.poll();
981	<	assertTrue(q.isEmpty());
982	<	} catch (Exception ex) {
983	<	this.unexpectedException();
984	<	}
846	>	public void testTransfer2() throws InterruptedException {
847	>	final LinkedTransferQueue<Integer> q
848	>	= new LinkedTransferQueue<Integer>();
849	>
850	>	Thread t = newStartedThread(new CheckedRunnable() {
851	>	void realRun() throws InterruptedException {
852	>	q.transfer(SIZE);
853	>	threadAssertTrue(q.isEmpty());
854	>	}});
855	>
856	>	Thread.sleep(SHORT_DELAY_MS);
857	>	assertEquals(1, q.size());
858	>	assertEquals(SIZE, (int) q.poll());
859	>	assertTrue(q.isEmpty());
860	>	t.join();
861		}
862
863		/**
864	<	* transfer will attempt to transfer in fifo order and continue
865	<	* waiting if the element being transfered is not polled or taken
866	<	*/
867	<	public void testTransfer3() {
868	<	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
869	<	new Thread(new Runnable() {
870	<	public void run() {
871	<	try {
872	<	Integer i;
873	<	q.transfer((i = new Integer(SIZE + 1)));
874	<	threadAssertTrue(!q.contains(i));
875	<	threadAssertEquals(1, q.size());
876	<	} catch (Exception ex) {
877	<	threadUnexpectedException();
878	<	}
879	<	}
880	<	}).start();
881	<	Thread interruptedThread =
882	<	new Thread(new Runnable() {
883	<	public void run() {
884	<	try {
885	<	q.transfer(new Integer(SIZE));
886	<	threadShouldThrow();
887	<	} catch (InterruptedException ex) {
888	<	}
889	<	}
890	<	});
891	<	interruptedThread.start();
892	<	try {
893	<	Thread.sleep(LONG_DELAY_MS);
894	<	assertEquals(2, q.size());
895	<	q.poll();
1020	<	Thread.sleep(LONG_DELAY_MS);
1021	<	interruptedThread.interrupt();
1022	<	assertEquals(1, q.size());
1023	<	} catch (Exception ex) {
1024	<	this.unexpectedException();
1025	<	}
864	>	* transfer waits until a poll occurs, and then transfers in fifo order
865	>	*/
866	>	public void testTransfer3() throws InterruptedException {
867	>	final LinkedTransferQueue<Integer> q
868	>	= new LinkedTransferQueue<Integer>();
869	>
870	>	Thread first = newStartedThread(new CheckedRunnable() {
871	>	void realRun() throws InterruptedException {
872	>	Integer i = SIZE + 1;
873	>	q.transfer(i);
874	>	threadAssertTrue(!q.contains(i));
875	>	threadAssertEquals(1, q.size());
876	>	}});
877	>
878	>	Thread interruptedThread = newStartedThread(
879	>	new CheckedInterruptedRunnable() {
880	>	void realRun() throws InterruptedException {
881	>	while (q.size() == 0)
882	>	Thread.yield();
883	>	q.transfer(SIZE);
884	>	}});
885	>
886	>	while (q.size() < 2)
887	>	Thread.yield();
888	>	assertEquals(2, q.size());
889	>	assertEquals(SIZE + 1, (int) q.poll());
890	>	first.join();
891	>	assertEquals(1, q.size());
892	>	interruptedThread.interrupt();
893	>	interruptedThread.join();
894	>	assertEquals(0, q.size());
895	>	assertTrue(q.isEmpty());
896		}
897
898		/**
899	<	* transfer will wait as long as a poll or take occurs if one does occur
900	<	* the waiting is finished and the thread that tries to poll/take
1031	<	* wins in retrieving the element
899	>	* transfer waits until a poll occurs, at which point the polling
900	>	* thread returns the element
901		*/
902	<	public void testTransfer4() {
902	>	public void testTransfer4() throws InterruptedException {
903		final LinkedTransferQueue q = new LinkedTransferQueue();
1035	–	new Thread(new Runnable() {
904
905	<	public void run() {
906	<	try {
907	<	q.transfer(new Integer(four));
908	<	threadAssertFalse(q.contains(new Integer(four)));
909	<	threadAssertEquals(new Integer(three), q.poll());
910	<	} catch (Exception ex) {
911	<	threadUnexpectedException();
912	<	}
913	<	}
914	<	}).start();
915	<	try {
916	<	Thread.sleep(MEDIUM_DELAY_MS);
917	<	assertTrue(q.offer(three));
918	<	assertEquals(new Integer(four), q.poll());
919	<	} catch (Exception ex) {
920	<	this.unexpectedException();
921	<	}
905	>	Thread t = newStartedThread(new CheckedRunnable() {
906	>	void realRun() throws InterruptedException {
907	>	q.transfer(four);
908	>	threadAssertFalse(q.contains(four));
909	>	threadAssertEquals(three, q.poll());
910	>	}});
911	>
912	>	Thread.sleep(SHORT_DELAY_MS);
913	>	assertTrue(q.offer(three));
914	>	assertEquals(four, q.poll());
915	>	t.join();
916	>	}
917	>
918	>	/**
919	>	* transfer waits until a take occurs. The transfered element
920	>	* is returned by this associated take.
921	>	*/
922	>	public void testTransfer5() throws InterruptedException {
923	>	final LinkedTransferQueue<Integer> q
924	>	= new LinkedTransferQueue<Integer>();
925	>
926	>	Thread t = newStartedThread(new CheckedRunnable() {
927	>	void realRun() throws InterruptedException {
928	>	q.transfer(SIZE);
929	>	threadAssertTrue(q.isEmpty());
930	>	}});
931	>
932	>	Thread.sleep(SHORT_DELAY_MS);
933	>	assertEquals(SIZE, (int) q.take());
934	>	assertTrue(q.isEmpty());
935	>	t.join();
936		}
937
938		/**
939	<	* Insert null into tryTransfer throws NPE
939	>	* tryTransfer(null) throws NullPointerException
940		*/
941		public void testTryTransfer1() {
942		try {
943		final LinkedTransferQueue q = new LinkedTransferQueue();
944		q.tryTransfer(null);
945	<	this.shouldThrow();
945	>	shouldThrow();
946		} catch (NullPointerException ex) {
1065	–	} catch (Exception ex) {
1066	–	this.unexpectedException();
947		}
948		}
949
950		/**
951	<	* tryTransfer returns false and does not enqueue if there are no consumers
952	<	* waiting to poll or take.
951	>	* tryTransfer returns false and does not enqueue if there are no
952	>	* consumers waiting to poll or take.
953		*/
954		public void testTryTransfer2() {
955	<	try {
956	<	final LinkedTransferQueue q = new LinkedTransferQueue();
957	<	assertFalse(q.tryTransfer(new Object()));
958	<	assertEquals(0, q.size());
959	<	} catch (Exception ex) {
1080	<	this.unexpectedException();
1081	<	}
955	>	final LinkedTransferQueue q = new LinkedTransferQueue();
956	>	assertFalse(q.tryTransfer(new Object()));
957	>	assertFalse(q.hasWaitingConsumer());
958	>	assertTrue(q.isEmpty());
959	>	assertEquals(0, q.size());
960		}
961
962		/**
963	<	* if there is a consumer waiting poll or take tryTransfer returns
964	<	* true while enqueueing object
963	>	* If there is a consumer waiting in timed poll, tryTransfer
964	>	* returns true while successfully transfering object.
965		*/
966	<	public void testTryTransfer3() {
967	<	try {
968	<	final LinkedTransferQueue q = new LinkedTransferQueue();
1091	<	new Thread(new Runnable() {
966	>	public void testTryTransfer3() throws InterruptedException {
967	>	final Object hotPotato = new Object();
968	>	final LinkedTransferQueue q = new LinkedTransferQueue();
969
970	<	public void run() {
971	<	try {
972	<	threadAssertTrue(q.hasWaitingConsumer());
973	<	threadAssertTrue(q.tryTransfer(new Object()));
974	<	} catch (Exception ex) {
975	<	threadUnexpectedException();
976	<	}
970	>	Thread t = newStartedThread(new CheckedRunnable() {
971	>	void realRun() {
972	>	while (! q.hasWaitingConsumer())
973	>	Thread.yield();
974	>	threadAssertTrue(q.hasWaitingConsumer());
975	>	threadAssertTrue(q.isEmpty());
976	>	threadAssertTrue(q.size() == 0);
977	>	threadAssertTrue(q.tryTransfer(hotPotato));
978	>	}});
979
980	<	}
981	<	}).start();
982	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
1104	<	assertTrue(q.isEmpty());
1105	<	} catch (Exception ex) {
1106	<	this.unexpectedException();
1107	<	}
980	>	assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
981	>	assertTrue(q.isEmpty());
982	>	t.join();
983		}
984
985		/**
986	<	* tryTransfer waits the amount given if interrupted, show an
987	<	* interrupted exception
986	>	* If there is a consumer waiting in take, tryTransfer returns
987	>	* true while successfully transfering object.
988		*/
989	<	public void testTryTransfer4() {
989	>	public void testTryTransfer4() throws InterruptedException {
990	>	final Object hotPotato = new Object();
991		final LinkedTransferQueue q = new LinkedTransferQueue();
1116	–	Thread toInterrupt = new Thread(new Runnable() {
992
993	<	public void run() {
994	<	try {
995	<	q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
996	<	threadShouldThrow();
997	<	} catch (InterruptedException ex) {
998	<	}
999	<	}
1000	<	});
1001	<	try {
1002	<	toInterrupt.start();
1003	<	Thread.sleep(SMALL_DELAY_MS);
1004	<	toInterrupt.interrupt();
1005	<	} catch (Exception ex) {
1006	<	this.unexpectedException();
1007	<	}
993	>	Thread t = newStartedThread(new CheckedRunnable() {
994	>	void realRun() {
995	>	while (! q.hasWaitingConsumer())
996	>	Thread.yield();
997	>	threadAssertTrue(q.hasWaitingConsumer());
998	>	threadAssertTrue(q.isEmpty());
999	>	threadAssertTrue(q.size() == 0);
1000	>	threadAssertTrue(q.tryTransfer(hotPotato));
1001	>	}});
1002	>
1003	>	assertTrue(q.take() == hotPotato);
1004	>	assertTrue(q.isEmpty());
1005	>	t.join();
1006	>	}
1007	>
1008	>	/**
1009	>	* tryTransfer waits the amount given if interrupted, and
1010	>	* throws interrupted exception
1011	>	*/
1012	>	public void testTryTransfer5() throws InterruptedException {
1013	>	final LinkedTransferQueue q = new LinkedTransferQueue();
1014	>
1015	>	Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1016	>	void realRun() throws InterruptedException {
1017	>	q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1018	>	}});
1019	>
1020	>	Thread.sleep(SMALL_DELAY_MS);
1021	>	toInterrupt.interrupt();
1022	>	toInterrupt.join();
1023		}
1024
1025		/**
1026		* tryTransfer gives up after the timeout and return false
1027		*/
1028	<	public void testTryTransfer5() {
1028	>	public void testTryTransfer6() throws InterruptedException {
1029		final LinkedTransferQueue q = new LinkedTransferQueue();
1140	–	try {
1141	–	new Thread(new Runnable() {
1030
1031	<	public void run() {
1032	<	try {
1033	<	threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1034	<	} catch (InterruptedException ex) {
1035	<	threadUnexpectedException();
1036	<	}
1037	<	}
1038	<	}).start();
1039	<	Thread.sleep(LONG_DELAY_MS);
1040	<	assertTrue(q.isEmpty());
1153	<	} catch (Exception ex) {
1154	<	this.unexpectedException();
1155	<	}
1031	>	Thread t = newStartedThread(new CheckedRunnable() {
1032	>	void realRun() throws InterruptedException {
1033	>	threadAssertFalse
1034	>	(q.tryTransfer(new Object(),
1035	>	SHORT_DELAY_MS, MILLISECONDS));
1036	>	}});
1037	>
1038	>	Thread.sleep(SMALL_DELAY_MS);
1039	>	assertTrue(q.isEmpty());
1040	>	t.join();
1041		}
1042
1043		/**
1044		* tryTransfer waits for any elements previously in to be removed
1045		* before transfering to a poll or take
1046		*/
1047	<	public void testTryTransfer6() {
1047	>	public void testTryTransfer7() throws InterruptedException {
1048		final LinkedTransferQueue q = new LinkedTransferQueue();
1049	<	q.offer(new Integer(four));
1165	<	new Thread(new Runnable() {
1049	>	assertTrue(q.offer(four));
1050
1051	<	public void run() {
1052	<	try {
1053	<	threadAssertTrue(q.tryTransfer(new Integer(five), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
1054	<	threadAssertTrue(q.isEmpty());
1055	<	} catch (InterruptedException ex) {
1056	<	threadUnexpectedException();
1057	<	}
1058	<	}
1059	<	}).start();
1060	<	try {
1061	<	Thread.sleep(SHORT_DELAY_MS);
1062	<	assertEquals(2, q.size());
1063	<	assertEquals(new Integer(four), q.poll());
1180	<	assertEquals(new Integer(five), q.poll());
1181	<	assertTrue(q.isEmpty());
1182	<	} catch (Exception ex) {
1183	<	this.unexpectedException();
1184	<	}
1051	>	Thread t = newStartedThread(new CheckedRunnable() {
1052	>	void realRun() throws InterruptedException {
1053	>	threadAssertTrue(q.tryTransfer(five,
1054	>	MEDIUM_DELAY_MS, MILLISECONDS));
1055	>	threadAssertTrue(q.isEmpty());
1056	>	}});
1057	>
1058	>	Thread.sleep(SHORT_DELAY_MS);
1059	>	assertEquals(2, q.size());
1060	>	assertEquals(four, q.poll());
1061	>	assertEquals(five, q.poll());
1062	>	assertTrue(q.isEmpty());
1063	>	t.join();
1064		}
1065
1066		/**
1067	<	* tryTransfer attempts to enqueue into the q and fails returning false not
1068	<	* enqueueing and the successive poll is null
1067	>	* tryTransfer attempts to enqueue into the q and fails returning
1068	>	* false not enqueueing and the successive poll is null
1069		*/
1070	<	public void testTryTransfer7() {
1070	>	public void testTryTransfer8() throws InterruptedException {
1071		final LinkedTransferQueue q = new LinkedTransferQueue();
1072	<	q.offer(new Integer(four));
1073	<	new Thread(new Runnable() {
1074	<
1075	<	public void run() {
1076	<	try {
1077	<	threadAssertFalse(q.tryTransfer(new Integer(five), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1078	<	threadAssertTrue(q.isEmpty());
1200	<	} catch (InterruptedException ex) {
1201	<	threadUnexpectedException();
1202	<	}
1203	<	}
1204	<	}).start();
1205	<	try {
1206	<	assertEquals(1, q.size());
1207	<	assertEquals(new Integer(four), q.poll());
1208	<	Thread.sleep(MEDIUM_DELAY_MS);
1209	<	assertNull(q.poll());
1210	<	} catch (Exception ex) {
1211	<	this.unexpectedException();
1212	<	}
1072	>	assertTrue(q.offer(four));
1073	>	assertEquals(1, q.size());
1074	>	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1075	>	assertEquals(1, q.size());
1076	>	assertEquals(four, q.poll());
1077	>	threadAssertTrue(q.isEmpty());
1078	>	assertNull(q.poll());
1079		}
1080
1081	<	private LinkedTransferQueue populatedQueue(
1082	<	int n) {
1217	<	LinkedTransferQueue q = new LinkedTransferQueue();
1081	>	private LinkedTransferQueue<Integer> populatedQueue(int n) {
1082	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1083		assertTrue(q.isEmpty());
1084	<	int remainingCapacity = q.remainingCapacity();
1085	<	for (int i = 0; i <
1221	<	n; i++) {
1084	>	for (int i = 0; i < n; i++) {
1085	>	assertEquals(i, q.size());
1086		assertTrue(q.offer(i));
1087	+	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
1088		}
1224	–
1089		assertFalse(q.isEmpty());
1226	–	assertEquals(remainingCapacity, q.remainingCapacity());
1227	–	assertEquals(n, q.size());
1090		return q;
1091		}
1092

Diff Legend

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