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.5 by jsr166, Sun Aug 2 08:17:31 2009 UTC

#	Line 39 | Line 39 | public class LinkedTransferQueueTest ext
39		}
40
41		/**
42	<	* Initializing constructor with null collection throws NPE
42	>	* Initializing constructor with null collection throws NullPointerException
43		*/
44		public void testConstructor2() {
45		try {
#	Line 50 | Line 50 | public class LinkedTransferQueueTest ext
50		}
51
52		/**
53	<	* Initializing from Collection of null elements throws NPE
53	>	* Initializing from Collection of null elements throws NullPointerException
54		*/
55		public void testConstructor3() {
56		try {
#	Line 63 | Line 63 | public class LinkedTransferQueueTest ext
63
64		/**
65		* Initializing constructor with a collection containing some null elements
66	<	* throws NPE
66	>	* throws NullPointerException
67		*/
68		public void testConstructor4() {
69		try {
70		Integer[] ints = new Integer[SIZE];
71		for (int i = 0; i < SIZE - 1; ++i) {
72	<	ints[i] = new Integer(i);
72	>	ints[i] = i;
73		}
74		LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
75		shouldThrow();
#	Line 84 | Line 84 | public class LinkedTransferQueueTest ext
84		try {
85		Integer[] ints = new Integer[SIZE];
86		for (int i = 0; i < SIZE; ++i) {
87	<	ints[i] = new Integer(i);
87	>	ints[i] = i;
88		}
89		LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
90		for (int i = 0; i < SIZE; ++i) {
#	Line 98 | Line 98 | public class LinkedTransferQueueTest ext
98		* Remaining capacity never decrease nor increase on add or remove
99		*/
100		public void testRemainingCapacity() {
101	<	LinkedTransferQueue q = populatedQueue(SIZE);
102	<	int remainingCapacity = q.remainingCapacity();
101	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
102		for (int i = 0; i < SIZE; ++i) {
103	<	assertEquals(remainingCapacity, q.remainingCapacity());
103	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
104		assertEquals(SIZE - i, q.size());
105		q.remove();
106		}
107		for (int i = 0; i < SIZE; ++i) {
108	<	assertEquals(remainingCapacity, q.remainingCapacity());
108	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
109		assertEquals(i, q.size());
110	<	q.add(new Integer(i));
110	>	q.add(i);
111		}
112		}
113
114		/**
115	<	* offer(null) throws NPE
115	>	* offer(null) throws NullPointerException
116		*/
117		public void testOfferNull() {
118		try {
#	Line 125 | Line 124 | public class LinkedTransferQueueTest ext
124		}
125
126		/**
127	<	* add(null) throws NPE
127	>	* add(null) throws NullPointerException
128		*/
129		public void testAddNull() {
130		try {
#	Line 137 | Line 136 | public class LinkedTransferQueueTest ext
136		}
137
138		/**
139	<	* addAll(null) throws NPE
139	>	* addAll(null) throws NullPointerException
140		*/
141		public void testAddAll1() {
142		try {
#	Line 149 | Line 148 | public class LinkedTransferQueueTest ext
148		}
149
150		/**
151	<	* addAll(this) throws IAE
151	>	* addAll(this) throws IllegalArgumentException
152		*/
153		public void testAddAllSelf() {
154		try {
#	Line 161 | Line 160 | public class LinkedTransferQueueTest ext
160		}
161
162		/**
163	<	* addAll of a collection with null elements throws NPE
163	>	* addAll of a collection with null elements throws NullPointerException
164		*/
165		public void testAddAll2() {
166		try {
#	Line 174 | Line 173 | public class LinkedTransferQueueTest ext
173		}
174
175		/**
176	<	* addAll of a collection with any null elements throws NPE after
176	>	* addAll of a collection with any null elements throws NullPointerException after
177		* possibly adding some elements
178		*/
179		public void testAddAll3() {
#	Line 182 | Line 181 | public class LinkedTransferQueueTest ext
181		LinkedTransferQueue q = new LinkedTransferQueue();
182		Integer[] ints = new Integer[SIZE];
183		for (int i = 0; i < SIZE - 1; ++i) {
184	<	ints[i] = new Integer(i);
184	>	ints[i] = i;
185		}
186		q.addAll(Arrays.asList(ints));
187		shouldThrow();
#	Line 194 | Line 193 | public class LinkedTransferQueueTest ext
193		* Queue contains all elements, in traversal order, of successful addAll
194		*/
195		public void testAddAll5() {
196	<	try {
197	<	Integer[] empty = new Integer[0];
198	<	Integer[] ints = new Integer[SIZE];
199	<	for (int i = 0; i < SIZE; ++i) {
200	<	ints[i] = new Integer(i);
201	<	}
202	<	LinkedTransferQueue q = new LinkedTransferQueue();
203	<	assertFalse(q.addAll(Arrays.asList(empty)));
204	<	assertTrue(q.addAll(Arrays.asList(ints)));
205	<	for (int i = 0; i < SIZE; ++i) {
207	<	assertEquals(ints[i], q.poll());
208	<	}
209	<	} finally {
196	>	Integer[] empty = new Integer[0];
197	>	Integer[] ints = new Integer[SIZE];
198	>	for (int i = 0; i < SIZE; ++i) {
199	>	ints[i] = i;
200	>	}
201	>	LinkedTransferQueue q = new LinkedTransferQueue();
202	>	assertFalse(q.addAll(Arrays.asList(empty)));
203	>	assertTrue(q.addAll(Arrays.asList(ints)));
204	>	for (int i = 0; i < SIZE; ++i) {
205	>	assertEquals(ints[i], q.poll());
206		}
207		}
208
209		/**
210	<	* put(null) throws NPE
210	>	* put(null) throws NullPointerException
211		*/
212	<	public void testPutNull() {
212	>	public void testPutNull() throws InterruptedException {
213		try {
214		LinkedTransferQueue q = new LinkedTransferQueue();
215		q.put(null);
216		shouldThrow();
217	<	} catch (NullPointerException success) {
222	<	} catch (Exception ie) {
223	<	unexpectedException();
224	<	}
217	>	} catch (NullPointerException success) {}
218		}
219
220		/**
221		* all elements successfully put are contained
222		*/
223		public void testPut() {
224	<	try {
225	<	LinkedTransferQueue q = new LinkedTransferQueue();
226	<	for (int i = 0; i < SIZE; ++i) {
227	<	Integer I = new Integer(i);
235	<	q.put(I);
236	<	assertTrue(q.contains(I));
237	<	}
238	<	} catch (Exception ie) {
239	<	unexpectedException();
224	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
225	>	for (int i = 0; i < SIZE; ++i) {
226	>	q.put(i);
227	>	assertTrue(q.contains(i));
228		}
229	+	assertEquals(q.size(), SIZE);
230		}
231
232		/**
233		* take retrieves elements in FIFO order
234		*/
235	<	public void testTake() {
236	<	try {
237	<	LinkedTransferQueue q = populatedQueue(SIZE);
238	<	for (int i = 0; i < SIZE; ++i) {
250	<	assertEquals(i, ((Integer) q.take()).intValue());
251	<	}
252	<	} catch (InterruptedException e) {
253	<	unexpectedException();
235	>	public void testTake() throws InterruptedException {
236	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
237	>	for (int i = 0; i < SIZE; ++i) {
238	>	assertEquals(i, (int) q.take());
239		}
240		}
241
242		/**
243		* take blocks interruptibly when empty
244		*/
245	<	public void testTakeFromEmpty() {
245	>	public void testTakeFromEmpty() throws InterruptedException {
246		final LinkedTransferQueue q = new LinkedTransferQueue();
247		Thread t = new Thread(new Runnable() {
263	–
248		public void run() {
249		try {
250		q.take();
251		threadShouldThrow();
252		} catch (InterruptedException success) {
253	+	} catch (Throwable ex) {
254	+	threadUnexpectedException(ex);
255		}
256	<	}
257	<	});
258	<	try {
259	<	t.start();
260	<	Thread.sleep(SHORT_DELAY_MS);
275	<	t.interrupt();
276	<	t.join();
277	<	} catch (Exception e) {
278	<	unexpectedException();
279	<	}
256	>	}});
257	>	t.start();
258	>	Thread.sleep(SHORT_DELAY_MS);
259	>	t.interrupt();
260	>	t.join();
261		}
262
263		/**
264		* Take removes existing elements until empty, then blocks interruptibly
265		*/
266	<	public void testBlockingTake() {
266	>	public void testBlockingTake() throws InterruptedException {
267		Thread t = new Thread(new Runnable() {
287	–
268		public void run() {
269		try {
270	<	LinkedTransferQueue q = populatedQueue(SIZE);
270	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
271		for (int i = 0; i < SIZE; ++i) {
272	<	assertEquals(i, ((Integer) q.take()).intValue());
272	>	threadAssertEquals(i, (int) q.take());
273		}
274		q.take();
275		threadShouldThrow();
276		} catch (InterruptedException success) {
277	+	} catch (Throwable ex) {
278	+	threadUnexpectedException(ex);
279		}
280	<	}
299	<	});
280	>	}});
281		t.start();
282	<	try {
283	<	Thread.sleep(SHORT_DELAY_MS);
284	<	t.interrupt();
304	<	t.join();
305	<	} catch (InterruptedException ie) {
306	<	unexpectedException();
307	<	}
282	>	Thread.sleep(SHORT_DELAY_MS);
283	>	t.interrupt();
284	>	t.join();
285		}
286
287		/**
288		* poll succeeds unless empty
289		*/
290		public void testPoll() {
291	<	LinkedTransferQueue q = populatedQueue(SIZE);
291	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
292		for (int i = 0; i < SIZE; ++i) {
293	<	assertEquals(i, ((Integer) q.poll()).intValue());
293	>	assertEquals(i, (int) q.poll());
294		}
295		assertNull(q.poll());
296		}
#	Line 321 | Line 298 | public class LinkedTransferQueueTest ext
298		/**
299		* timed pool with zero timeout succeeds when non-empty, else times out
300		*/
301	<	public void testTimedPoll0() {
302	<	try {
303	<	LinkedTransferQueue q = populatedQueue(SIZE);
304	<	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();
301	>	public void testTimedPoll0() throws InterruptedException {
302	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
303	>	for (int i = 0; i < SIZE; ++i) {
304	>	assertEquals(i, (int) q.poll(0, TimeUnit.MILLISECONDS));
305		}
306	+	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
307		}
308
309		/**
310		* timed pool with nonzero timeout succeeds when non-empty, else times out
311		*/
312	<	public void testTimedPoll() {
313	<	try {
314	<	LinkedTransferQueue q = populatedQueue(SIZE);
315	<	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();
312	>	public void testTimedPoll() throws InterruptedException {
313	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
314	>	for (int i = 0; i < SIZE; ++i) {
315	>	assertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
316		}
317	+	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
318		}
319
320		/**
321		* Interrupted timed poll throws InterruptedException instead of
322		* returning timeout status
323		*/
324	<	public void testInterruptedTimedPoll() {
324	>	public void testInterruptedTimedPoll() throws InterruptedException {
325		Thread t = new Thread(new Runnable() {
357	–
326		public void run() {
327		try {
328	<	LinkedTransferQueue q = populatedQueue(SIZE);
328	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
329		for (int i = 0; i < SIZE; ++i) {
330	<	threadAssertEquals(i, ((Integer) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
330	>	threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
331		}
332		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
333		} catch (InterruptedException success) {
334	+	} catch (Throwable ex) {
335	+	threadUnexpectedException(ex);
336		}
337	<	}
368	<	});
337	>	}});
338		t.start();
339	<	try {
340	<	Thread.sleep(SHORT_DELAY_MS);
341	<	t.interrupt();
373	<	t.join();
374	<	} catch (InterruptedException ie) {
375	<	unexpectedException();
376	<	}
339	>	Thread.sleep(SHORT_DELAY_MS);
340	>	t.interrupt();
341	>	t.join();
342		}
343
344		/**
345		* timed poll before a delayed offer fails; after offer succeeds;
346		* on interruption throws
347		*/
348	<	public void testTimedPollWithOffer() {
348	>	public void testTimedPollWithOffer() throws InterruptedException {
349		final LinkedTransferQueue q = new LinkedTransferQueue();
350		Thread t = new Thread(new Runnable() {
386	–
351		public void run() {
352		try {
353		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 391 | Line 355 | public class LinkedTransferQueueTest ext
355		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
356		threadShouldThrow();
357		} catch (InterruptedException success) {
358	+	} catch (Throwable ex) {
359	+	threadUnexpectedException(ex);
360		}
361	<	}
362	<	});
363	<	try {
364	<	t.start();
365	<	Thread.sleep(SMALL_DELAY_MS);
366	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
401	<	t.interrupt();
402	<	t.join();
403	<	} catch (Exception e) {
404	<	unexpectedException();
405	<	}
361	>	}});
362	>	t.start();
363	>	Thread.sleep(SMALL_DELAY_MS);
364	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
365	>	t.interrupt();
366	>	t.join();
367		}
368
369		/**
370		* peek returns next element, or null if empty
371		*/
372		public void testPeek() {
373	<	LinkedTransferQueue q = populatedQueue(SIZE);
373	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
374		for (int i = 0; i < SIZE; ++i) {
375	<	assertEquals(i, ((Integer) q.peek()).intValue());
376	<	q.poll();
375	>	assertEquals(i, (int) q.peek());
376	>	assertEquals(i, (int) q.poll());
377		assertTrue(q.peek() == null ||
378	<	i != ((Integer) q.peek()).intValue());
378	>	i != (int) q.peek());
379		}
380		assertNull(q.peek());
381		}
382
383		/**
384	<	* element returns next element, or throws NSEE if empty
384	>	* element returns next element, or throws NoSuchElementException if empty
385		*/
386		public void testElement() {
387	<	LinkedTransferQueue q = populatedQueue(SIZE);
387	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
388		for (int i = 0; i < SIZE; ++i) {
389	<	assertEquals(i, ((Integer) q.element()).intValue());
390	<	q.poll();
389	>	assertEquals(i, (int) q.element());
390	>	assertEquals(i, (int) q.poll());
391		}
392		try {
393		q.element();
#	Line 436 | Line 397 | public class LinkedTransferQueueTest ext
397		}
398
399		/**
400	<	* remove removes next element, or throws NSEE if empty
400	>	* remove removes next element, or throws NoSuchElementException if empty
401		*/
402		public void testRemove() {
403	<	LinkedTransferQueue q = populatedQueue(SIZE);
403	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
404		for (int i = 0; i < SIZE; ++i) {
405	<	assertEquals(i, ((Integer) q.remove()).intValue());
405	>	assertEquals(i, (int) q.remove());
406		}
407		try {
408		q.remove();
#	Line 456 | Line 417 | public class LinkedTransferQueueTest ext
417		public void testRemoveElement() {
418		LinkedTransferQueue q = populatedQueue(SIZE);
419		for (int i = 1; i < SIZE; i += 2) {
420	<	assertTrue(q.remove(new Integer(i)));
420	>	assertTrue(q.remove(i));
421		}
422		for (int i = 0; i < SIZE; i += 2) {
423	<	assertTrue(q.remove(new Integer(i)));
424	<	assertFalse(q.remove(new Integer(i + 1)));
423	>	assertTrue(q.remove(i));
424	>	assertFalse(q.remove(i + 1));
425		}
426		assertTrue(q.isEmpty());
427		}
#	Line 468 | Line 429 | public class LinkedTransferQueueTest ext
429		/**
430		* An add following remove(x) succeeds
431		*/
432	<	public void testRemoveElementAndAdd() {
433	<	try {
434	<	LinkedTransferQueue q = new LinkedTransferQueue();
435	<	assertTrue(q.add(new Integer(1)));
436	<	assertTrue(q.add(new Integer(2)));
437	<	assertTrue(q.remove(new Integer(1)));
438	<	assertTrue(q.remove(new Integer(2)));
439	<	assertTrue(q.add(new Integer(3)));
479	<	assertTrue(q.take() != null);
480	<	} catch (Exception e) {
481	<	unexpectedException();
482	<	}
432	>	public void testRemoveElementAndAdd() throws InterruptedException {
433	>	LinkedTransferQueue q = new LinkedTransferQueue();
434	>	assertTrue(q.add(one));
435	>	assertTrue(q.add(two));
436	>	assertTrue(q.remove(one));
437	>	assertTrue(q.remove(two));
438	>	assertTrue(q.add(three));
439	>	assertTrue(q.take() != null);
440		}
441
442		/**
443		* contains(x) reports true when elements added but not yet removed
444		*/
445		public void testContains() {
446	<	LinkedTransferQueue q = populatedQueue(SIZE);
446	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
447		for (int i = 0; i < SIZE; ++i) {
448	<	assertTrue(q.contains(new Integer(i)));
449	<	q.poll();
450	<	assertFalse(q.contains(new Integer(i)));
448	>	assertTrue(q.contains(i));
449	>	assertEquals(i, (int) q.poll());
450	>	assertFalse(q.contains(i));
451		}
452		}
453
#	Line 499 | Line 456 | public class LinkedTransferQueueTest ext
456		*/
457		public void testClear() {
458		LinkedTransferQueue q = populatedQueue(SIZE);
502	–	int remainingCapacity = q.remainingCapacity();
459		q.clear();
460		assertTrue(q.isEmpty());
461		assertEquals(0, q.size());
462	<	assertEquals(remainingCapacity, q.remainingCapacity());
462	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
463		q.add(one);
464		assertFalse(q.isEmpty());
465		assertTrue(q.contains(one));
#	Line 515 | Line 471 | public class LinkedTransferQueueTest ext
471		* containsAll(c) is true when c contains a subset of elements
472		*/
473		public void testContainsAll() {
474	<	LinkedTransferQueue q = populatedQueue(SIZE);
475	<	LinkedTransferQueue p = new LinkedTransferQueue();
474	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
475	>	LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
476		for (int i = 0; i < SIZE; ++i) {
477		assertTrue(q.containsAll(p));
478		assertFalse(p.containsAll(q));
479	<	p.add(new Integer(i));
479	>	p.add(i);
480		}
481		assertTrue(p.containsAll(q));
482		}
#	Line 554 | Line 510 | public class LinkedTransferQueueTest ext
510		assertTrue(q.removeAll(p));
511		assertEquals(SIZE - i, q.size());
512		for (int j = 0; j < i; ++j) {
513	<	Integer I = (Integer) (p.remove());
558	<	assertFalse(q.contains(I));
513	>	assertFalse(q.contains(p.remove()));
514		}
515		}
516		}
#	Line 563 | Line 518 | public class LinkedTransferQueueTest ext
518		/**
519		* toArray contains all elements
520		*/
521	<	public void testToArray() {
521	>	public void testToArray() throws InterruptedException {
522		LinkedTransferQueue q = populatedQueue(SIZE);
523		Object[] o = q.toArray();
524	<	try {
525	<	for (int i = 0; i < o.length; i++) {
571	<	assertEquals(o[i], q.take());
572	<	}
573	<	} catch (InterruptedException e) {
574	<	unexpectedException();
524	>	for (int i = 0; i < o.length; i++) {
525	>	assertEquals(o[i], q.take());
526		}
527		}
528
529		/**
530		* toArray(a) contains all elements
531		*/
532	<	public void testToArray2() {
533	<	LinkedTransferQueue q = populatedQueue(SIZE);
532	>	public void testToArray2() throws InterruptedException {
533	>	LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
534		Integer[] ints = new Integer[SIZE];
535	<	ints = (Integer[]) q.toArray(ints);
536	<	try {
537	<	for (int i = 0; i < ints.length; i++) {
587	<	assertEquals(ints[i], q.take());
588	<	}
589	<	} catch (InterruptedException e) {
590	<	unexpectedException();
535	>	ints = q.toArray(ints);
536	>	for (int i = 0; i < ints.length; i++) {
537	>	assertEquals(ints[i], q.take());
538		}
539		}
540
541		/**
542	<	* toArray(null) throws NPE
542	>	* toArray(null) throws NullPointerException
543		*/
544		public void testToArray_BadArg() {
545		try {
#	Line 618 | Line 565 | public class LinkedTransferQueueTest ext
565		/**
566		* iterator iterates through all elements
567		*/
568	<	public void testIterator() {
568	>	public void testIterator() throws InterruptedException {
569		LinkedTransferQueue q = populatedQueue(SIZE);
570		Iterator it = q.iterator();
571	<	try {
572	<	while (it.hasNext()) {
626	<	assertEquals(it.next(), q.take());
627	<	}
628	<	} catch (InterruptedException e) {
629	<	unexpectedException();
571	>	while (it.hasNext()) {
572	>	assertEquals(it.next(), q.take());
573		}
574		}
575
#	Line 653 | Line 596 | public class LinkedTransferQueueTest ext
596		* iterator ordering is FIFO
597		*/
598		public void testIteratorOrdering() {
599	<	final LinkedTransferQueue q = new LinkedTransferQueue();
600	<	int remainingCapacity = q.remainingCapacity();
599	>	final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
600	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
601		q.add(one);
602		q.add(two);
603		q.add(three);
604	<	assertEquals(remainingCapacity, q.remainingCapacity());
604	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
605		int k = 0;
606	<	for (Iterator it = q.iterator(); it.hasNext();) {
607	<	int i = ((Integer) (it.next())).intValue();
665	<	assertEquals(++k, i);
606	>	for (Integer n : q) {
607	>	assertEquals(++k, (int) n);
608		}
609		assertEquals(3, k);
610		}
#	Line 675 | Line 617 | public class LinkedTransferQueueTest ext
617		q.add(one);
618		q.add(two);
619		q.add(three);
620	<	try {
621	<	for (Iterator it = q.iterator(); it.hasNext();) {
622	<	q.remove();
681	<	it.next();
682	<	}
683	<	} catch (ConcurrentModificationException e) {
684	<	unexpectedException();
620	>	for (Iterator it = q.iterator(); it.hasNext();) {
621	>	q.remove();
622	>	it.next();
623		}
624		assertEquals(0, q.size());
625		}
#	Line 706 | Line 644 | public class LinkedTransferQueueTest ext
644		q.add(two);
645		ExecutorService executor = Executors.newFixedThreadPool(2);
646		executor.execute(new Runnable() {
709	–
647		public void run() {
648		try {
649		threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
650	<	} catch (Exception e) {
651	<	threadUnexpectedException();
650	>	} catch (Throwable ex) {
651	>	threadUnexpectedException(ex);
652		}
653	<	}
717	<	});
653	>	}});
654
655		executor.execute(new Runnable() {
720	–
656		public void run() {
657		try {
658		Thread.sleep(SMALL_DELAY_MS);
659		threadAssertEquals(one, q.take());
660	<	} catch (InterruptedException e) {
661	<	threadUnexpectedException();
660	>	} catch (Throwable ex) {
661	>	threadUnexpectedException(ex);
662		}
663	<	}
729	<	});
663	>	}});
664
665		joinPool(executor);
666		}
#	Line 738 | Line 672 | public class LinkedTransferQueueTest ext
672		final LinkedTransferQueue q = new LinkedTransferQueue();
673		ExecutorService executor = Executors.newFixedThreadPool(2);
674		executor.execute(new Runnable() {
741	–
675		public void run() {
743	–	threadAssertNull(q.poll());
676		try {
677	+	threadAssertNull(q.poll());
678		threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
679		threadAssertTrue(q.isEmpty());
680	<	} catch (InterruptedException e) {
681	<	threadUnexpectedException();
680	>	} catch (Throwable  ex) {
681	>	threadUnexpectedException(ex);
682		}
683	<	}
751	<	});
683	>	}});
684
685		executor.execute(new Runnable() {
754	–
686		public void run() {
687		try {
688		Thread.sleep(SMALL_DELAY_MS);
689		q.put(one);
690	<	} catch (InterruptedException e) {
691	<	threadUnexpectedException();
690	>	} catch (Throwable ex) {
691	>	threadUnexpectedException(ex);
692		}
693	<	}
763	<	});
693	>	}});
694
695		joinPool(executor);
696		}
#	Line 768 | Line 698 | public class LinkedTransferQueueTest ext
698		/**
699		* A deserialized serialized queue has same elements in same order
700		*/
701	<	public void testSerialization() {
701	>	public void testSerialization() throws Exception {
702		LinkedTransferQueue q = populatedQueue(SIZE);
703
704	<	try {
705	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
706	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
707	<	out.writeObject(q);
708	<	out.close();
709	<
710	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
711	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
712	<	LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
713	<
714	<	assertEquals(q.size(), r.size());
715	<	while (!q.isEmpty()) {
786	<	assertEquals(q.remove(), r.remove());
787	<	}
788	<	} catch (Exception e) {
789	<	unexpectedException();
704	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
705	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
706	>	out.writeObject(q);
707	>	out.close();
708	>
709	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
710	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
711	>	LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
712	>
713	>	assertEquals(q.size(), r.size());
714	>	while (!q.isEmpty()) {
715	>	assertEquals(q.remove(), r.remove());
716		}
717		}
718
719		/**
720	<	* drainTo(null) throws NPE
720	>	* drainTo(null) throws NullPointerException
721		*/
722		public void testDrainToNull() {
723		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 803 | Line 729 | public class LinkedTransferQueueTest ext
729		}
730
731		/**
732	<	* drainTo(this) throws IAE
732	>	* drainTo(this) throws IllegalArgumentException
733		*/
734		public void testDrainToSelf() {
735		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 824 | Line 750 | public class LinkedTransferQueueTest ext
750		assertEquals(q.size(), 0);
751		assertEquals(l.size(), SIZE);
752		for (int i = 0; i < SIZE; ++i) {
753	<	assertEquals(l.get(i), new Integer(i));
753	>	assertEquals(l.get(i), i);
754		}
755		q.add(zero);
756		q.add(one);
#	Line 836 | Line 762 | public class LinkedTransferQueueTest ext
762		assertEquals(q.size(), 0);
763		assertEquals(l.size(), 2);
764		for (int i = 0; i < 2; ++i) {
765	<	assertEquals(l.get(i), new Integer(i));
765	>	assertEquals(l.get(i), i);
766		}
767		}
768
769		/**
770		* drainTo empties full queue, unblocking a waiting put.
771		*/
772	<	public void testDrainToWithActivePut() {
772	>	public void testDrainToWithActivePut() throws InterruptedException {
773		final LinkedTransferQueue q = populatedQueue(SIZE);
774		Thread t = new Thread(new Runnable() {
849	–
775		public void run() {
776		try {
777	<	q.put(new Integer(SIZE + 1));
778	<	} catch (Exception ie) {
779	<	threadUnexpectedException();
777	>	q.put(SIZE + 1);
778	>	} catch (Throwable ex) {
779	>	threadUnexpectedException(ex);
780		}
781	<	}
782	<	});
783	<	try {
784	<	t.start();
785	<	ArrayList l = new ArrayList();
786	<	q.drainTo(l);
787	<	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();
781	>	}});
782	>	t.start();
783	>	ArrayList l = new ArrayList();
784	>	q.drainTo(l);
785	>	assertTrue(l.size() >= SIZE);
786	>	for (int i = 0; i < SIZE; ++i) {
787	>	assertEquals(l.get(i), i);
788		}
789	+	t.join();
790	+	assertTrue(q.size() + l.size() >= SIZE);
791		}
792
793		/**
794	<	* drainTo(null, n) throws NPE
794	>	* drainTo(null, n) throws NullPointerException
795		*/
796		public void testDrainToNullN() {
797		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 883 | Line 803 | public class LinkedTransferQueueTest ext
803		}
804
805		/**
806	<	* drainTo(this, n) throws IAE
806	>	* drainTo(this, n) throws IllegalArgumentException
807		*/
808		public void testDrainToSelfN() {
809		LinkedTransferQueue q = populatedQueue(SIZE);
#	Line 901 | Line 821 | public class LinkedTransferQueueTest ext
821		LinkedTransferQueue q = new LinkedTransferQueue();
822		for (int i = 0; i < SIZE + 2; ++i) {
823		for (int j = 0; j < SIZE; j++) {
824	<	assertTrue(q.offer(new Integer(j)));
824	>	assertTrue(q.offer(j));
825		}
826		ArrayList l = new ArrayList();
827		q.drainTo(l, i);
#	Line 909 | Line 829 | public class LinkedTransferQueueTest ext
829		assertEquals(l.size(), k);
830		assertEquals(q.size(), SIZE - k);
831		for (int j = 0; j < k; ++j) {
832	<	assertEquals(l.get(j), new Integer(j));
832	>	assertEquals(l.get(j), j);
833		}
834	<	while (q.poll() != null);
834	>	while (q.poll() != null)
835	>	;
836		}
837		}
838
839		/**
840		* poll and take should decrement the waiting consumer count
841		*/
842	<	public void testWaitingConsumer() {
843	<	try {
844	<	final LinkedTransferQueue q = new LinkedTransferQueue();
845	<	final ConsumerObserver waiting = new ConsumerObserver();
846	<	new Thread(new Runnable() {
847	<
848	<	public void run() {
849	<	try {
850	<	threadAssertTrue(q.hasWaitingConsumer());
851	<	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
852	<	threadAssertTrue(q.offer(new Object()));
932	<	} catch (Exception ex) {
933	<	threadUnexpectedException();
934	<	}
935	<
842	>	public void testWaitingConsumer() throws InterruptedException {
843	>	final LinkedTransferQueue q = new LinkedTransferQueue();
844	>	final ConsumerObserver waiting = new ConsumerObserver();
845	>	new Thread(new Runnable() {
846	>	public void run() {
847	>	try {
848	>	threadAssertTrue(q.hasWaitingConsumer());
849	>	waiting.setWaitingConsumer(q.getWaitingConsumerCount());
850	>	threadAssertTrue(q.offer(new Object()));
851	>	} catch (Throwable ex) {
852	>	threadUnexpectedException(ex);
853		}
854	<	}).start();
855	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
856	<	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
940	<	} catch (Exception ex) {
941	<	this.unexpectedException();
942	<	}
854	>	}}).start();
855	>	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
856	>	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
857		}
858
859		/**
860	<	* Inserts null into transfer throws NPE
860	>	* transfer(null) throws NullPointerException
861		*/
862	<	public void testTransfer1() {
862	>	public void testTransfer1() throws InterruptedException {
863		try {
864		LinkedTransferQueue q = new LinkedTransferQueue();
865		q.transfer(null);
866		shouldThrow();
867		} catch (NullPointerException ex) {
954	–	} catch (Exception ex) {
955	–	this.unexpectedException();
868		}
869		}
870
#	Line 960 | Line 872 | public class LinkedTransferQueueTest ext
872		* transfer attempts to insert into the queue then wait until that
873		* object is removed via take or poll.
874		*/
875	<	public void testTransfer2() {
875	>	public void testTransfer2() throws InterruptedException {
876		final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
965	–	new Thread(new Runnable() {
877
878	+	new Thread(new Runnable() {
879		public void run() {
880		try {
881	<	q.transfer(new Integer(SIZE));
881	>	q.transfer(SIZE);
882		threadAssertTrue(q.isEmpty());
883	<	} catch (Exception ex) {
884	<	threadUnexpectedException();
883	>	} catch (Throwable ex) {
884	>	threadUnexpectedException(ex);
885		}
886	<	}
975	<	}).start();
886	>	}}).start();
887
888	<	try {
889	<	Thread.sleep(SHORT_DELAY_MS);
890	<	assertEquals(1, q.size());
891	<	q.poll();
981	<	assertTrue(q.isEmpty());
982	<	} catch (Exception ex) {
983	<	this.unexpectedException();
984	<	}
888	>	Thread.sleep(SHORT_DELAY_MS);
889	>	assertEquals(1, q.size());
890	>	assertEquals(SIZE, (int) q.poll());
891	>	assertTrue(q.isEmpty());
892		}
893
894		/**
895		* transfer will attempt to transfer in fifo order and continue
896		* waiting if the element being transfered is not polled or taken
897		*/
898	<	public void testTransfer3() {
898	>	public void testTransfer3() throws InterruptedException {
899		final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
900	<	new Thread(new Runnable() {
900	>
901	>	Thread first =
902	>	new Thread(new Runnable() {
903		public void run() {
904		try {
905	<	Integer i;
906	<	q.transfer((i = new Integer(SIZE + 1)));
905	>	Integer i = SIZE + 1;
906	>	q.transfer(i);
907		threadAssertTrue(!q.contains(i));
908		threadAssertEquals(1, q.size());
909	<	} catch (Exception ex) {
910	<	threadUnexpectedException();
909	>	} catch (Throwable ex) {
910	>	threadUnexpectedException(ex);
911		}
912	<	}
913	<	}).start();
912	>	}});
913	>	first.start();
914	>
915		Thread interruptedThread =
916		new Thread(new Runnable() {
917	<	public void run() {
918	<	try {
919	<	q.transfer(new Integer(SIZE));
920	<	threadShouldThrow();
921	<	} catch (InterruptedException ex) {
922	<	}
917	>	public void run() {
918	>	try {
919	>	while (q.size() == 0)
920	>	Thread.yield();
921	>	q.transfer(SIZE);
922	>	threadShouldThrow();
923	>	} catch (InterruptedException success) {
924	>	} catch (Throwable ex) {
925	>	threadUnexpectedException(ex);
926		}
927	<	});
927	>	}});
928		interruptedThread.start();
929	<	try {
930	<	Thread.sleep(LONG_DELAY_MS);
931	<	assertEquals(2, q.size());
932	<	q.poll();
933	<	Thread.sleep(LONG_DELAY_MS);
934	<	interruptedThread.interrupt();
935	<	assertEquals(1, q.size());
936	<	} catch (Exception ex) {
937	<	this.unexpectedException();
938	<	}
929	>
930	>	while (q.size() < 2)
931	>	Thread.yield();
932	>	assertEquals(2, q.size());
933	>	assertEquals(SIZE + 1, (int) q.poll());
934	>	first.join();
935	>	assertEquals(1, q.size());
936	>	interruptedThread.interrupt();
937	>	interruptedThread.join();
938	>	assertEquals(0, q.size());
939	>	assertTrue(q.isEmpty());
940		}
941
942		/**
#	Line 1030 | Line 944 | public class LinkedTransferQueueTest ext
944		* the waiting is finished and the thread that tries to poll/take
945		* wins in retrieving the element
946		*/
947	<	public void testTransfer4() {
947	>	public void testTransfer4() throws InterruptedException {
948		final LinkedTransferQueue q = new LinkedTransferQueue();
949		new Thread(new Runnable() {
1036	–
950		public void run() {
951		try {
952	<	q.transfer(new Integer(four));
953	<	threadAssertFalse(q.contains(new Integer(four)));
954	<	threadAssertEquals(new Integer(three), q.poll());
955	<	} catch (Exception ex) {
956	<	threadUnexpectedException();
952	>	q.transfer(four);
953	>	threadAssertFalse(q.contains(four));
954	>	threadAssertEquals(three, q.poll());
955	>	} catch (Throwable ex) {
956	>	threadUnexpectedException(ex);
957		}
958	<	}
959	<	}).start();
960	<	try {
961	<	Thread.sleep(MEDIUM_DELAY_MS);
1049	<	assertTrue(q.offer(three));
1050	<	assertEquals(new Integer(four), q.poll());
1051	<	} catch (Exception ex) {
1052	<	this.unexpectedException();
1053	<	}
958	>	}}).start();
959	>	Thread.sleep(MEDIUM_DELAY_MS);
960	>	assertTrue(q.offer(three));
961	>	assertEquals(four, q.poll());
962		}
963
964		/**
965	<	* Insert null into tryTransfer throws NPE
965	>	* tryTransfer(null) throws NullPointerException
966		*/
967		public void testTryTransfer1() {
968		try {
#	Line 1062 | Line 970 | public class LinkedTransferQueueTest ext
970		q.tryTransfer(null);
971		this.shouldThrow();
972		} catch (NullPointerException ex) {
1065	–	} catch (Exception ex) {
1066	–	this.unexpectedException();
973		}
974		}
975
976		/**
977	<	* tryTransfer returns false and does not enqueue if there are no consumers
978	<	* waiting to poll or take.
977	>	* tryTransfer returns false and does not enqueue if there are no
978	>	* consumers waiting to poll or take.
979		*/
980		public void testTryTransfer2() {
981	<	try {
982	<	final LinkedTransferQueue q = new LinkedTransferQueue();
983	<	assertFalse(q.tryTransfer(new Object()));
984	<	assertEquals(0, q.size());
985	<	} catch (Exception ex) {
1080	<	this.unexpectedException();
1081	<	}
981	>	final LinkedTransferQueue q = new LinkedTransferQueue();
982	>	assertFalse(q.tryTransfer(new Object()));
983	>	assertFalse(q.hasWaitingConsumer());
984	>	assertTrue(q.isEmpty());
985	>	assertEquals(0, q.size());
986		}
987
988		/**
989	<	* if there is a consumer waiting poll or take tryTransfer returns
990	<	* true while enqueueing object
989	>	* If there is a consumer waiting in timed poll, tryTransfer
990	>	* returns true while successfully transfering object.
991		*/
992	<	public void testTryTransfer3() {
993	<	try {
994	<	final LinkedTransferQueue q = new LinkedTransferQueue();
995	<	new Thread(new Runnable() {
996	<
997	<	public void run() {
998	<	try {
999	<	threadAssertTrue(q.hasWaitingConsumer());
1000	<	threadAssertTrue(q.tryTransfer(new Object()));
1001	<	} catch (Exception ex) {
1002	<	threadUnexpectedException();
1003	<	}
992	>	public void testTryTransfer3() throws InterruptedException {
993	>	final Object hotPotato = new Object();
994	>	final LinkedTransferQueue q = new LinkedTransferQueue();
995	>	new Thread(new Runnable() {
996	>	public void run() {
997	>	try {
998	>	while (! q.hasWaitingConsumer())
999	>	Thread.yield();
1000	>	threadAssertTrue(q.hasWaitingConsumer());
1001	>	threadAssertTrue(q.isEmpty());
1002	>	threadAssertTrue(q.size() == 0);
1003	>	threadAssertTrue(q.tryTransfer(hotPotato));
1004	>	} catch (Throwable ex) {
1005	>	threadUnexpectedException(ex);
1006	>	}
1007	>	}}).start();
1008	>	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) == hotPotato);
1009	>	assertTrue(q.isEmpty());
1010	>	}
1011
1012	+	/**
1013	+	* If there is a consumer waiting in take, tryTransfer returns
1014	+	* true while successfully transfering object.
1015	+	*/
1016	+	public void testTryTransfer4() throws InterruptedException {
1017	+	final Object hotPotato = new Object();
1018	+	final LinkedTransferQueue q = new LinkedTransferQueue();
1019	+	new Thread(new Runnable() {
1020	+	public void run() {
1021	+	try {
1022	+	while (! q.hasWaitingConsumer())
1023	+	Thread.yield();
1024	+	threadAssertTrue(q.hasWaitingConsumer());
1025	+	threadAssertTrue(q.isEmpty());
1026	+	threadAssertTrue(q.size() == 0);
1027	+	threadAssertTrue(q.tryTransfer(hotPotato));
1028	+	} catch (Throwable ex) {
1029	+	threadUnexpectedException(ex);
1030		}
1031	<	}).start();
1032	<	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
1033	<	assertTrue(q.isEmpty());
1105	<	} catch (Exception ex) {
1106	<	this.unexpectedException();
1107	<	}
1031	>	}}).start();
1032	>	assertTrue(q.take() == hotPotato);
1033	>	assertTrue(q.isEmpty());
1034		}
1035
1036		/**
1037		* tryTransfer waits the amount given if interrupted, show an
1038		* interrupted exception
1039		*/
1040	<	public void testTryTransfer4() {
1040	>	public void testTryTransfer5() throws InterruptedException {
1041		final LinkedTransferQueue q = new LinkedTransferQueue();
1042		Thread toInterrupt = new Thread(new Runnable() {
1117	–
1043		public void run() {
1044		try {
1045		q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
1046		threadShouldThrow();
1047	<	} catch (InterruptedException ex) {
1047	>	} catch (InterruptedException success) {
1048	>	} catch (Throwable ex) {
1049	>	threadUnexpectedException(ex);
1050		}
1051	<	}
1052	<	});
1053	<	try {
1054	<	toInterrupt.start();
1128	<	Thread.sleep(SMALL_DELAY_MS);
1129	<	toInterrupt.interrupt();
1130	<	} catch (Exception ex) {
1131	<	this.unexpectedException();
1132	<	}
1051	>	}});
1052	>	toInterrupt.start();
1053	>	Thread.sleep(SMALL_DELAY_MS);
1054	>	toInterrupt.interrupt();
1055		}
1056
1057		/**
1058		* tryTransfer gives up after the timeout and return false
1059		*/
1060	<	public void testTryTransfer5() {
1060	>	public void testTryTransfer6() throws InterruptedException {
1061		final LinkedTransferQueue q = new LinkedTransferQueue();
1062	<	try {
1063	<	new Thread(new Runnable() {
1064	<
1065	<	public void run() {
1066	<	try {
1067	<	threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1146	<	} catch (InterruptedException ex) {
1147	<	threadUnexpectedException();
1148	<	}
1062	>	new Thread(new Runnable() {
1063	>	public void run() {
1064	>	try {
1065	>	threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1066	>	} catch (Throwable ex) {
1067	>	threadUnexpectedException(ex);
1068		}
1069	<	}).start();
1070	<	Thread.sleep(LONG_DELAY_MS);
1071	<	assertTrue(q.isEmpty());
1153	<	} catch (Exception ex) {
1154	<	this.unexpectedException();
1155	<	}
1069	>	}}).start();
1070	>	Thread.sleep(LONG_DELAY_MS);
1071	>	assertTrue(q.isEmpty());
1072		}
1073
1074		/**
1075		* tryTransfer waits for any elements previously in to be removed
1076		* before transfering to a poll or take
1077		*/
1078	<	public void testTryTransfer6() {
1078	>	public void testTryTransfer7() throws InterruptedException {
1079		final LinkedTransferQueue q = new LinkedTransferQueue();
1080	<	q.offer(new Integer(four));
1080	>	assertTrue(q.offer(four));
1081		new Thread(new Runnable() {
1166	–
1082		public void run() {
1083		try {
1084	<	threadAssertTrue(q.tryTransfer(new Integer(five), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
1084	>	threadAssertTrue(q.tryTransfer(five, LONG_DELAY_MS, TimeUnit.MILLISECONDS));
1085		threadAssertTrue(q.isEmpty());
1086	<	} catch (InterruptedException ex) {
1087	<	threadUnexpectedException();
1086	>	} catch (Throwable ex) {
1087	>	threadUnexpectedException(ex);
1088		}
1089	<	}
1090	<	}).start();
1091	<	try {
1092	<	Thread.sleep(SHORT_DELAY_MS);
1093	<	assertEquals(2, q.size());
1094	<	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	<	}
1089	>	}}).start();
1090	>	Thread.sleep(SHORT_DELAY_MS);
1091	>	assertEquals(2, q.size());
1092	>	assertEquals(four, q.poll());
1093	>	assertEquals(five, q.poll());
1094	>	assertTrue(q.isEmpty());
1095		}
1096
1097		/**
1098	<	* tryTransfer attempts to enqueue into the q and fails returning false not
1099	<	* enqueueing and the successive poll is null
1098	>	* tryTransfer attempts to enqueue into the q and fails returning
1099	>	* false not enqueueing and the successive poll is null
1100		*/
1101	<	public void testTryTransfer7() {
1101	>	public void testTryTransfer8() throws InterruptedException {
1102		final LinkedTransferQueue q = new LinkedTransferQueue();
1103	<	q.offer(new Integer(four));
1104	<	new Thread(new Runnable() {
1105	<
1106	<	public void run() {
1107	<	try {
1108	<	threadAssertFalse(q.tryTransfer(new Integer(five), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1109	<	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	<	}
1103	>	assertTrue(q.offer(four));
1104	>	assertEquals(1, q.size());
1105	>	assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1106	>	assertEquals(1, q.size());
1107	>	assertEquals(four, q.poll());
1108	>	threadAssertTrue(q.isEmpty());
1109	>	assertNull(q.poll());
1110		}
1111
1112	<	private LinkedTransferQueue populatedQueue(
1113	<	int n) {
1217	<	LinkedTransferQueue q = new LinkedTransferQueue();
1112	>	private LinkedTransferQueue<Integer> populatedQueue(int n) {
1113	>	LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1114		assertTrue(q.isEmpty());
1115	<	int remainingCapacity = q.remainingCapacity();
1116	<	for (int i = 0; i <
1221	<	n; i++) {
1115	>	for (int i = 0; i < n; i++) {
1116	>	assertEquals(i, q.size());
1117		assertTrue(q.offer(i));
1118	+	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
1119		}
1224	–
1120		assertFalse(q.isEmpty());
1226	–	assertEquals(remainingCapacity, q.remainingCapacity());
1227	–	assertEquals(n, q.size());
1121		return q;
1122		}
1123

Diff Legend

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