ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedBlockingQueueTest.java (file contents):
Revision 1.46 by jsr166, Tue May 31 16:16:24 2011 UTC vs.
Revision 1.56 by jsr166, Wed Dec 31 20:17:39 2014 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.Arrays;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11		import java.util.ArrayList;
12	+	import java.util.Arrays;
13		import java.util.Collection;
14		import java.util.Iterator;
15		import java.util.NoSuchElementException;
16		import java.util.Queue;
17		import java.util.concurrent.BlockingQueue;
18		import java.util.concurrent.CountDownLatch;
18	–	import java.util.concurrent.LinkedBlockingQueue;
19		import java.util.concurrent.Executors;
20		import java.util.concurrent.ExecutorService;
21	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	>	import java.util.concurrent.LinkedBlockingQueue;
22	>
23	>	import junit.framework.Test;
24
25		public class LinkedBlockingQueueTest extends JSR166TestCase {
26
#	Line 30 | Line 32 | public class LinkedBlockingQueueTest ext
32
33		public static class Bounded extends BlockingQueueTest {
34		protected BlockingQueue emptyCollection() {
35	<	return new LinkedBlockingQueue(20);
35	>	return new LinkedBlockingQueue(SIZE);
36		}
37		}
38
#	Line 45 | Line 47 | public class LinkedBlockingQueueTest ext
47		}
48
49		/**
50	<	* Create a queue of given size containing consecutive
50	>	* Returns a new queue of given size containing consecutive
51		* Integers 0 ... n.
52		*/
53		private LinkedBlockingQueue<Integer> populatedQueue(int n) {
#	Line 245 | Line 247 | public class LinkedBlockingQueueTest ext
247		public void testPut() throws InterruptedException {
248		LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
249		for (int i = 0; i < SIZE; ++i) {
250	<	Integer I = new Integer(i);
251	<	q.put(I);
252	<	assertTrue(q.contains(I));
250	>	Integer x = new Integer(i);
251	>	q.put(x);
252	>	assertTrue(q.contains(x));
253		}
254		assertEquals(0, q.remainingCapacity());
255		}
#	Line 312 | Line 314 | public class LinkedBlockingQueueTest ext
314		}});
315
316		await(pleaseTake);
317	<	assertEquals(q.remainingCapacity(), 0);
317	>	assertEquals(0, q.remainingCapacity());
318		assertEquals(0, q.take());
319
320		await(pleaseInterrupt);
321		assertThreadStaysAlive(t);
322		t.interrupt();
323		awaitTermination(t);
324	<	assertEquals(q.remainingCapacity(), 0);
324	>	assertEquals(0, q.remainingCapacity());
325		}
326
327		/**
#	Line 504 | Line 506 | public class LinkedBlockingQueueTest ext
506		}
507
508		/**
507	–	* remove(x) removes x and returns true if present
508	–	*/
509	–	public void testRemoveElement() {
510	–	LinkedBlockingQueue q = populatedQueue(SIZE);
511	–	for (int i = 1; i < SIZE; i+=2) {
512	–	assertTrue(q.contains(i));
513	–	assertTrue(q.remove(i));
514	–	assertFalse(q.contains(i));
515	–	assertTrue(q.contains(i-1));
516	–	}
517	–	for (int i = 0; i < SIZE; i+=2) {
518	–	assertTrue(q.contains(i));
519	–	assertTrue(q.remove(i));
520	–	assertFalse(q.contains(i));
521	–	assertFalse(q.remove(i+1));
522	–	assertFalse(q.contains(i+1));
523	–	}
524	–	assertTrue(q.isEmpty());
525	–	}
526	–
527	–	/**
509		* An add following remove(x) succeeds
510		*/
511		public void testRemoveElementAndAdd() throws InterruptedException {
#	Line 534 | Line 515 | public class LinkedBlockingQueueTest ext
515		assertTrue(q.remove(new Integer(1)));
516		assertTrue(q.remove(new Integer(2)));
517		assertTrue(q.add(new Integer(3)));
518	<	assertTrue(q.take() != null);
518	>	assertNotNull(q.take());
519		}
520
521		/**
#	Line 608 | Line 589 | public class LinkedBlockingQueueTest ext
589		assertTrue(q.removeAll(p));
590		assertEquals(SIZE-i, q.size());
591		for (int j = 0; j < i; ++j) {
592	<	Integer I = (Integer)(p.remove());
593	<	assertFalse(q.contains(I));
592	>	Integer x = (Integer)(p.remove());
593	>	assertFalse(q.contains(x));
594		}
595		}
596		}
#	Line 776 | Line 757 | public class LinkedBlockingQueueTest ext
757		Queue x = populatedQueue(SIZE);
758		Queue y = serialClone(x);
759
760	<	assertTrue(x != y);
760	>	assertNotSame(x, y);
761		assertEquals(x.size(), y.size());
762		assertEquals(x.toString(), y.toString());
763		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 794 | Line 775 | public class LinkedBlockingQueueTest ext
775		LinkedBlockingQueue q = populatedQueue(SIZE);
776		ArrayList l = new ArrayList();
777		q.drainTo(l);
778	<	assertEquals(q.size(), 0);
779	<	assertEquals(l.size(), SIZE);
778	>	assertEquals(0, q.size());
779	>	assertEquals(SIZE, l.size());
780		for (int i = 0; i < SIZE; ++i)
781		assertEquals(l.get(i), new Integer(i));
782		q.add(zero);
#	Line 805 | Line 786 | public class LinkedBlockingQueueTest ext
786		assertTrue(q.contains(one));
787		l.clear();
788		q.drainTo(l);
789	<	assertEquals(q.size(), 0);
790	<	assertEquals(l.size(), 2);
789	>	assertEquals(0, q.size());
790	>	assertEquals(2, l.size());
791		for (int i = 0; i < 2; ++i)
792		assertEquals(l.get(i), new Integer(i));
793		}
#	Line 842 | Line 823 | public class LinkedBlockingQueueTest ext
823		ArrayList l = new ArrayList();
824		q.drainTo(l, i);
825		int k = (i < SIZE) ? i : SIZE;
826	<	assertEquals(l.size(), k);
827	<	assertEquals(q.size(), SIZE-k);
826	>	assertEquals(k, l.size());
827	>	assertEquals(SIZE-k, q.size());
828		for (int j = 0; j < k; ++j)
829		assertEquals(l.get(j), new Integer(j));
830	<	while (q.poll() != null) ;
830	>	do {} while (q.poll() != null);
831	>	}
832	>	}
833	>
834	>	/**
835	>	* remove(null), contains(null) always return false
836	>	*/
837	>	public void testNeverContainsNull() {
838	>	Collection<?>[] qs = {
839	>	new LinkedBlockingQueue<Object>(),
840	>	populatedQueue(2),
841	>	};
842	>
843	>	for (Collection<?> q : qs) {
844	>	assertFalse(q.contains(null));
845	>	assertFalse(q.remove(null));
846		}
847		}
848

Diff Legend

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