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.1 by dl, Fri Jul 31 23:02:49 2009 UTC vs.
Revision 1.5 by jsr166, Sun Aug 2 08:17:31 2009 UTC

#	Line 1 | Line 1
1	–
1		/*
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
#	Line 31 | Line 30 | public class LinkedTransferQueueTest ext
30		return new TestSuite(LinkedTransferQueueTest.class);
31		}
32
33	<	/*
34	<	*Constructor builds new queue with size being zero and empty being true
33	>	/**
34	>	* Constructor builds new queue with size being zero and empty being true
35		*/
36		public void testConstructor1() {
37		assertEquals(0, new LinkedTransferQueue().size());
38		assertTrue(new LinkedTransferQueue().isEmpty());
39		}
40
41	<	/*
42	<	* Initizialing constructor with null collection throws NPE
41	>	/**
42	>	* Initializing constructor with null collection throws NullPointerException
43		*/
44		public void testConstructor2() {
45		try {
#	Line 51 | 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 61 | Line 60 | public class LinkedTransferQueueTest ext
60		} catch (NullPointerException success) {
61		}
62		}
63	<	/*
63	>
64	>	/**
65		* Initializing constructor with a collection containing some null elements
66	<	* throws NPE
66	>	* throws NullPointerException
67		*/
68	–
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 78 | Line 77 | public class LinkedTransferQueueTest ext
77		}
78		}
79
80	<	/*
80	>	/**
81		* Queue contains all elements of the collection it is initialized by
82		*/
83		public void testConstructor5() {
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 99 | 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);
103	<	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 126 | 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 138 | 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 150 | 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 162 | 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 175 | 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 183 | 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 195 | 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) {
208	<	assertEquals(ints[i], q.poll());
209	<	}
210	<	} 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) {
223	<	} catch (Exception ie) {
224	<	unexpectedException();
225	<	}
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);
236	<	q.put(I);
237	<	assertTrue(q.contains(I));
238	<	}
239	<	} catch (Exception ie) {
240	<	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) {
251	<	assertEquals(i, ((Integer) q.take()).intValue());
252	<	}
253	<	} catch (InterruptedException e) {
254	<	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() {
264	–
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);
276	<	t.interrupt();
277	<	t.join();
278	<	} catch (Exception e) {
279	<	unexpectedException();
280	<	}
256	>	}});
257	>	t.start();
258	>	Thread.sleep(SHORT_DELAY_MS);
259	>	t.interrupt();
260	>	t.join();
261		}
262	<	/*
262	>
263	>	/**
264		* Take removes existing elements until empty, then blocks interruptibly
265		*/
266	<
286	<	public void testBlockingTake() {
266	>	public void testBlockingTake() throws InterruptedException {
267		Thread t = new Thread(new Runnable() {
288	–
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	<	}
300	<	});
280	>	}});
281		t.start();
282	<	try {
283	<	Thread.sleep(SHORT_DELAY_MS);
284	<	t.interrupt();
305	<	t.join();
306	<	} catch (InterruptedException ie) {
307	<	unexpectedException();
308	<	}
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 322 | 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) {
329	<	assertEquals(i, ((Integer) q.poll(0, TimeUnit.MILLISECONDS)).intValue());
330	<	}
331	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
332	<	} catch (InterruptedException e) {
333	<	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) {
344	<	assertEquals(i, ((Integer) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)).intValue());
345	<	}
346	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
347	<	} catch (InterruptedException e) {
348	<	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() {
358	–
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	<	}
369	<	});
337	>	}});
338		t.start();
339	<	try {
340	<	Thread.sleep(SHORT_DELAY_MS);
341	<	t.interrupt();
374	<	t.join();
375	<	} catch (InterruptedException ie) {
376	<	unexpectedException();
377	<	}
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
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() {
387	–
351		public void run() {
352		try {
353		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 392 | 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));
402	<	t.interrupt();
403	<	t.join();
404	<	} catch (Exception e) {
405	<	unexpectedException();
406	<	}
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 437 | 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 457 | 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 469 | 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)));
480	<	assertTrue(q.take() != null);
481	<	} catch (Exception e) {
482	<	unexpectedException();
483	<	}
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 500 | Line 456 | public class LinkedTransferQueueTest ext
456		*/
457		public void testClear() {
458		LinkedTransferQueue q = populatedQueue(SIZE);
503	–	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 516 | 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 555 | 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());
559	<	assertFalse(q.contains(I));
513	>	assertFalse(q.contains(p.remove()));
514		}
515		}
516		}
#	Line 564 | 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++) {
572	<	assertEquals(o[i], q.take());
573	<	}
574	<	} catch (InterruptedException e) {
575	<	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++) {
588	<	assertEquals(ints[i], q.take());
589	<	}
590	<	} catch (InterruptedException e) {
591	<	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 619 | 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()) {
627	<	assertEquals(it.next(), q.take());
628	<	}
629	<	} catch (InterruptedException e) {
630	<	unexpectedException();
571	>	while (it.hasNext()) {
572	>	assertEquals(it.next(), q.take());
573		}
574		}
575
#	Line 654 | 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();
666	<	assertEquals(++k, i);
606	>	for (Integer n : q) {
607	>	assertEquals(++k, (int) n);
608		}
609		assertEquals(3, k);
610		}
#	Line 676 | 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();
682	<	it.next();
683	<	}
684	<	} catch (ConcurrentModificationException e) {
685	<	unexpectedException();
620	>	for (Iterator it = q.iterator(); it.hasNext();) {
621	>	q.remove();
622	>	it.next();
623		}
624		assertEquals(0, q.size());
625		}
#	Line 707 | Line 644 | public class LinkedTransferQueueTest ext
644		q.add(two);
645		ExecutorService executor = Executors.newFixedThreadPool(2);
646		executor.execute(new Runnable() {
710	–
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	<	}
718	<	});
653	>	}});
654
655		executor.execute(new Runnable() {
721	–
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	<	}
730	<	});
663	>	}});
664
665		joinPool(executor);
666		}
#	Line 739 | Line 672 | public class LinkedTransferQueueTest ext
672		final LinkedTransferQueue q = new LinkedTransferQueue();
673		ExecutorService executor = Executors.newFixedThreadPool(2);
674		executor.execute(new Runnable() {
742	–
675		public void run() {
744	–	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	<	}
752	<	});
683	>	}});
684
685		executor.execute(new Runnable() {
755	–
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	<	}
764	<	});
693	>	}});
694
695		joinPool(executor);
696		}
#	Line 769 | 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()) {
787	<	assertEquals(q.remove(), r.remove());
788	<	}
789	<	} catch (Exception e) {
790	<	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 804 | 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 825 | 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 837 | 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() {
850	–
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);
864	<	for (int i = 0; i < SIZE; ++i) {
865	<	assertEquals(l.get(i), new Integer(i));
866	<	}
867	<	t.join();
868	<	assertTrue(q.size() + l.size() >= SIZE);
869	<	} catch (Exception e) {
870	<	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 884 | 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 902 | 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 910 | 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	<	/*
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()));
933	<	} catch (Exception ex) {
934	<	threadUnexpectedException();
935	<	}
936	<
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());
941	<	} catch (Exception ex) {
942	<	this.unexpectedException();
943	<	}
854	>	}}).start();
855	>	assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
856	>	assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
857		}
945	–	/*
946	–	* Inserts null into transfer throws NPE
947	–	*/
858
859	<	public void testTransfer1() {
859	>	/**
860	>	* transfer(null) throws NullPointerException
861	>	*/
862	>	public void testTransfer1() throws InterruptedException {
863		try {
864		LinkedTransferQueue q = new LinkedTransferQueue();
865		q.transfer(null);
866		shouldThrow();
867		} catch (NullPointerException ex) {
955	–	} catch (Exception ex) {
956	–	this.unexpectedException();
868		}
869		}
870
871	<	/*
872	<	* transfer attempts to insert into the queue then wait until that
873	<	* object is removed via take or poll.
871	>	/**
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>();
966	–	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	<	}
976	<	}).start();
886	>	}}).start();
887
888	<	try {
889	<	Thread.sleep(SHORT_DELAY_MS);
890	<	assertEquals(1, q.size());
891	<	q.poll();
982	<	assertTrue(q.isEmpty());
983	<	} catch (Exception ex) {
984	<	this.unexpectedException();
985	<	}
888	>	Thread.sleep(SHORT_DELAY_MS);
889	>	assertEquals(1, q.size());
890	>	assertEquals(SIZE, (int) q.poll());
891	>	assertTrue(q.isEmpty());
892		}
987	–	/*
988	–	* transfer will attempt to transfer in fifo order and continue waiting if
989	–	* the element being transfered is not polled or taken
990	–	*/
893
894	<	public void testTransfer3() {
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() 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();
914	<	Thread interruptedThread =
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		/**
943		* transfer will wait as long as a poll or take occurs if one does occur
944	<	* the waiting is finished and the thread that tries to poll/take
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() {
1037	–
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);
1050	<	assertTrue(q.offer(three));
1051	<	assertEquals(new Integer(four), q.poll());
1052	<	} catch (Exception ex) {
1053	<	this.unexpectedException();
1054	<	}
958	>	}}).start();
959	>	Thread.sleep(MEDIUM_DELAY_MS);
960	>	assertTrue(q.offer(three));
961	>	assertEquals(four, q.poll());
962		}
1056	–	/*
1057	–	* Insert null into trTransfer throws NPE
1058	–	*/
963
964	+	/**
965	+	* tryTransfer(null) throws NullPointerException
966	+	*/
967		public void testTryTransfer1() {
968		try {
969		final LinkedTransferQueue q = new LinkedTransferQueue();
970		q.tryTransfer(null);
971		this.shouldThrow();
972		} catch (NullPointerException ex) {
1066	–	} catch (Exception ex) {
1067	–	this.unexpectedException();
973		}
974		}
1070	–	/*
1071	–	* tryTransfer returns false and does not enqueue if there are no consumers
1072	–	* waiting to poll or take.
1073	–	*/
975
976	+	/**
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) {
1081	<	this.unexpectedException();
1082	<	}
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		}
1084	–	/*
1085	–	* if there is a consumer waiting poll or take tryTransfer returns
1086	–	* true while enqueueing object
1087	–	*/
987
988	<	public void testTryTransfer3() {
989	<	try {
990	<	final LinkedTransferQueue q = new LinkedTransferQueue();
991	<	new Thread(new Runnable() {
992	<
993	<	public void run() {
994	<	try {
995	<	threadAssertTrue(q.hasWaitingConsumer());
996	<	threadAssertTrue(q.tryTransfer(new Object()));
997	<	} catch (Exception ex) {
998	<	threadUnexpectedException();
999	<	}
988	>	/**
989	>	* If there is a consumer waiting in timed poll, tryTransfer
990	>	* returns true while successfully transfering object.
991	>	*/
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());
1106	<	} catch (Exception ex) {
1107	<	this.unexpectedException();
1108	<	}
1031	>	}}).start();
1032	>	assertTrue(q.take() == hotPotato);
1033	>	assertTrue(q.isEmpty());
1034		}
1035
1036	<	/*
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() {
1118	–
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();
1129	<	Thread.sleep(SMALL_DELAY_MS);
1130	<	toInterrupt.interrupt();
1131	<	} catch (Exception ex) {
1132	<	this.unexpectedException();
1133	<	}
1051	>	}});
1052	>	toInterrupt.start();
1053	>	Thread.sleep(SMALL_DELAY_MS);
1054	>	toInterrupt.interrupt();
1055		}
1056
1057	<	/*
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));
1147	<	} catch (InterruptedException ex) {
1148	<	threadUnexpectedException();
1149	<	}
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());
1154	<	} catch (Exception ex) {
1155	<	this.unexpectedException();
1156	<	}
1069	>	}}).start();
1070	>	Thread.sleep(LONG_DELAY_MS);
1071	>	assertTrue(q.isEmpty());
1072		}
1073
1074	<	/*
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() {
1167	–
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());
1181	<	assertEquals(new Integer(five), q.poll());
1182	<	assertTrue(q.isEmpty());
1183	<	} catch (Exception ex) {
1184	<	this.unexpectedException();
1185	<	}
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 successing poll is null
1097	>	/**
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());
1201	<	} catch (InterruptedException ex) {
1202	<	threadUnexpectedException();
1203	<	}
1204	<	}
1205	<	}).start();
1206	<	try {
1207	<	assertEquals(1, q.size());
1208	<	assertEquals(new Integer(four), q.poll());
1209	<	Thread.sleep(MEDIUM_DELAY_MS);
1210	<	assertNull(q.poll());
1211	<	} catch (Exception ex) {
1212	<	this.unexpectedException();
1213	<	}
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) {
1218	<	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 <
1222	<	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		}
1225	–
1120		assertFalse(q.isEmpty());
1227	–	assertEquals(remainingCapacity, q.remainingCapacity());
1228	–	assertEquals(n, q.size());
1121		return q;
1122		}
1123

Diff Legend

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