ViewVC Help

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

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

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.45 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.59 by jsr166, Sat Feb 28 19:59:23 2015 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.Comparator;
15		import java.util.Iterator;
16		import java.util.NoSuchElementException;
17	<	import java.util.concurrent.PriorityBlockingQueue;
17	>	import java.util.Queue;
18		import java.util.concurrent.BlockingQueue;
19		import java.util.concurrent.CountDownLatch;
20		import java.util.concurrent.Executors;
21		import java.util.concurrent.ExecutorService;
22	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
23	<	import java.io.*;
22	>	import java.util.concurrent.PriorityBlockingQueue;
23	>
24	>	import junit.framework.Test;
25
26		public class PriorityBlockingQueueTest extends JSR166TestCase {
27
#	Line 31 | Line 33 | public class PriorityBlockingQueueTest e
33
34		public static class InitialCapacity extends BlockingQueueTest {
35		protected BlockingQueue emptyCollection() {
36	<	return new PriorityBlockingQueue(20);
36	>	return new PriorityBlockingQueue(SIZE);
37		}
38		}
39
#	Line 45 | Line 47 | public class PriorityBlockingQueueTest e
47		new InitialCapacity().testSuite());
48		}
49
48	–	private static final int NOCAP = Integer.MAX_VALUE;
49	–
50		/** Sample Comparator */
51		static class MyReverseComparator implements Comparator {
52		public int compare(Object x, Object y) {
#	Line 55 | Line 55 | public class PriorityBlockingQueueTest e
55		}
56
57		/**
58	<	* Create a queue of given size containing consecutive
58	>	* Returns a new queue of given size containing consecutive
59		* Integers 0 ... n.
60		*/
61		private PriorityBlockingQueue<Integer> populatedQueue(int n) {
62		PriorityBlockingQueue<Integer> q =
63		new PriorityBlockingQueue<Integer>(n);
64		assertTrue(q.isEmpty());
65	<	for (int i = n-1; i >= 0; i-=2)
65	>	for (int i = n-1; i >= 0; i -= 2)
66		assertTrue(q.offer(new Integer(i)));
67	<	for (int i = (n & 1); i < n; i+=2)
67	>	for (int i = (n & 1); i < n; i += 2)
68		assertTrue(q.offer(new Integer(i)));
69		assertFalse(q.isEmpty());
70	<	assertEquals(NOCAP, q.remainingCapacity());
70	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
71		assertEquals(n, q.size());
72		return q;
73		}
#	Line 76 | Line 76 | public class PriorityBlockingQueueTest e
76		* A new queue has unbounded capacity
77		*/
78		public void testConstructor1() {
79	<	assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
79	>	assertEquals(Integer.MAX_VALUE,
80	>	new PriorityBlockingQueue(SIZE).remainingCapacity());
81		}
82
83		/**
#	Line 157 | Line 158 | public class PriorityBlockingQueueTest e
158		public void testEmpty() {
159		PriorityBlockingQueue q = new PriorityBlockingQueue(2);
160		assertTrue(q.isEmpty());
161	<	assertEquals(NOCAP, q.remainingCapacity());
161	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
162		q.add(one);
163		assertFalse(q.isEmpty());
164		q.add(two);
#	Line 167 | Line 168 | public class PriorityBlockingQueueTest e
168		}
169
170		/**
171	<	* remainingCapacity does not change when elements added or removed,
171	<	* but size does
171	>	* remainingCapacity() always returns Integer.MAX_VALUE
172		*/
173		public void testRemainingCapacity() {
174	<	PriorityBlockingQueue q = populatedQueue(SIZE);
174	>	BlockingQueue q = populatedQueue(SIZE);
175		for (int i = 0; i < SIZE; ++i) {
176	<	assertEquals(NOCAP, q.remainingCapacity());
177	<	assertEquals(SIZE-i, q.size());
178	<	q.remove();
176	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
177	>	assertEquals(SIZE - i, q.size());
178	>	assertEquals(i, q.remove());
179		}
180		for (int i = 0; i < SIZE; ++i) {
181	<	assertEquals(NOCAP, q.remainingCapacity());
181	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
182		assertEquals(i, q.size());
183	<	q.add(new Integer(i));
183	>	assertTrue(q.add(i));
184		}
185		}
186
#	Line 264 | Line 264 | public class PriorityBlockingQueueTest e
264		public void testPut() {
265		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
266		for (int i = 0; i < SIZE; ++i) {
267	<	Integer I = new Integer(i);
268	<	q.put(I);
269	<	assertTrue(q.contains(I));
267	>	Integer x = new Integer(i);
268	>	q.put(x);
269	>	assertTrue(q.contains(x));
270		}
271		assertEquals(SIZE, q.size());
272		}
#	Line 459 | Line 459 | public class PriorityBlockingQueueTest e
459		}
460
461		/**
462	–	* remove(x) removes x and returns true if present
463	–	*/
464	–	public void testRemoveElement() {
465	–	PriorityBlockingQueue q = populatedQueue(SIZE);
466	–	for (int i = 1; i < SIZE; i+=2) {
467	–	assertTrue(q.contains(i));
468	–	assertTrue(q.remove(i));
469	–	assertFalse(q.contains(i));
470	–	assertTrue(q.contains(i-1));
471	–	}
472	–	for (int i = 0; i < SIZE; i+=2) {
473	–	assertTrue(q.contains(i));
474	–	assertTrue(q.remove(i));
475	–	assertFalse(q.contains(i));
476	–	assertFalse(q.remove(i+1));
477	–	assertFalse(q.contains(i+1));
478	–	}
479	–	assertTrue(q.isEmpty());
480	–	}
481	–
482	–	/**
462		* contains(x) reports true when elements added but not yet removed
463		*/
464		public void testContains() {
#	Line 549 | Line 528 | public class PriorityBlockingQueueTest e
528		assertTrue(q.removeAll(p));
529		assertEquals(SIZE-i, q.size());
530		for (int j = 0; j < i; ++j) {
531	<	Integer I = (Integer)(p.remove());
532	<	assertFalse(q.contains(I));
531	>	Integer x = (Integer)(p.remove());
532	>	assertFalse(q.contains(x));
533		}
534		}
535		}
#	Line 595 | Line 574 | public class PriorityBlockingQueueTest e
574		*/
575		public void testIterator() {
576		PriorityBlockingQueue q = populatedQueue(SIZE);
598	–	int i = 0;
577		Iterator it = q.iterator();
578	<	while (it.hasNext()) {
578	>	int i;
579	>	for (i = 0; it.hasNext(); i++)
580		assertTrue(q.contains(it.next()));
602	–	++i;
603	–	}
581		assertEquals(i, SIZE);
582	+	assertIteratorExhausted(it);
583	+	}
584	+
585	+	/**
586	+	* iterator of empty collection has no elements
587	+	*/
588	+	public void testEmptyIterator() {
589	+	assertIteratorExhausted(new PriorityBlockingQueue().iterator());
590		}
591
592		/**
#	Line 662 | Line 647 | public class PriorityBlockingQueueTest e
647		* A deserialized serialized queue has same elements
648		*/
649		public void testSerialization() throws Exception {
650	<	PriorityBlockingQueue q = populatedQueue(SIZE);
651	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
652	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
653	<	out.writeObject(q);
654	<	out.close();
655	<
656	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
657	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
658	<	PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject();
659	<	assertEquals(q.size(), r.size());
675	<	while (!q.isEmpty())
676	<	assertEquals(q.remove(), r.remove());
650	>	Queue x = populatedQueue(SIZE);
651	>	Queue y = serialClone(x);
652	>
653	>	assertNotSame(x, y);
654	>	assertEquals(x.size(), y.size());
655	>	while (!x.isEmpty()) {
656	>	assertFalse(y.isEmpty());
657	>	assertEquals(x.remove(), y.remove());
658	>	}
659	>	assertTrue(y.isEmpty());
660		}
661
662		/**
#	Line 683 | Line 666 | public class PriorityBlockingQueueTest e
666		PriorityBlockingQueue q = populatedQueue(SIZE);
667		ArrayList l = new ArrayList();
668		q.drainTo(l);
669	<	assertEquals(q.size(), 0);
670	<	assertEquals(l.size(), SIZE);
669	>	assertEquals(0, q.size());
670	>	assertEquals(SIZE, l.size());
671		for (int i = 0; i < SIZE; ++i)
672		assertEquals(l.get(i), new Integer(i));
673		q.add(zero);
#	Line 694 | Line 677 | public class PriorityBlockingQueueTest e
677		assertTrue(q.contains(one));
678		l.clear();
679		q.drainTo(l);
680	<	assertEquals(q.size(), 0);
681	<	assertEquals(l.size(), 2);
680	>	assertEquals(0, q.size());
681	>	assertEquals(2, l.size());
682		for (int i = 0; i < 2; ++i)
683		assertEquals(l.get(i), new Integer(i));
684		}
#	Line 731 | Line 714 | public class PriorityBlockingQueueTest e
714		ArrayList l = new ArrayList();
715		q.drainTo(l, i);
716		int k = (i < SIZE) ? i : SIZE;
717	<	assertEquals(l.size(), k);
718	<	assertEquals(q.size(), SIZE-k);
717	>	assertEquals(k, l.size());
718	>	assertEquals(SIZE-k, q.size());
719		for (int j = 0; j < k; ++j)
720		assertEquals(l.get(j), new Integer(j));
721	<	while (q.poll() != null) ;
721	>	do {} while (q.poll() != null);
722	>	}
723	>	}
724	>
725	>	/**
726	>	* remove(null), contains(null) always return false
727	>	*/
728	>	public void testNeverContainsNull() {
729	>	Collection<?>[] qs = {
730	>	new PriorityBlockingQueue<Object>(),
731	>	populatedQueue(2),
732	>	};
733	>
734	>	for (Collection<?> q : qs) {
735	>	assertFalse(q.contains(null));
736	>	assertFalse(q.remove(null));
737		}
738		}
739

Diff Legend

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