ViewVC Help

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

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

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.40 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.50 by jsr166, Sun Nov 23 22:27:06 2014 UTC

#	Line 8 | Line 8 | import junit.framework.*;
8		import java.util.Arrays;
9		import java.util.ArrayList;
10		import java.util.Collection;
11	+	import java.util.Deque;
12		import java.util.Iterator;
13		import java.util.NoSuchElementException;
14	+	import java.util.Queue;
15		import java.util.concurrent.BlockingDeque;
16		import java.util.concurrent.BlockingQueue;
17		import java.util.concurrent.CountDownLatch;
#	Line 17 | Line 19 | import java.util.concurrent.Executors;
19		import java.util.concurrent.ExecutorService;
20		import java.util.concurrent.LinkedBlockingDeque;
21		import static java.util.concurrent.TimeUnit.MILLISECONDS;
20	–	import java.io.*;
22
23		public class LinkedBlockingDequeTest extends JSR166TestCase {
24
#	Line 29 | Line 30 | public class LinkedBlockingDequeTest ext
30
31		public static class Bounded extends BlockingQueueTest {
32		protected BlockingQueue emptyCollection() {
33	<	return new LinkedBlockingDeque(20);
33	>	return new LinkedBlockingDeque(SIZE);
34		}
35		}
36
#	Line 44 | Line 45 | public class LinkedBlockingDequeTest ext
45		}
46
47		/**
48	<	* Create a deque of given size containing consecutive
48	>	* Returns a new deque of given size containing consecutive
49		* Integers 0 ... n.
50		*/
51		private LinkedBlockingDeque<Integer> populatedDeque(int n) {
#	Line 622 | Line 623 | public class LinkedBlockingDequeTest ext
623		}});
624
625		await(pleaseTake);
626	<	assertEquals(q.remainingCapacity(), 0);
626	>	assertEquals(0, q.remainingCapacity());
627		assertEquals(0, q.take());
628
629		await(pleaseInterrupt);
630		assertThreadStaysAlive(t);
631		t.interrupt();
632		awaitTermination(t);
633	<	assertEquals(q.remainingCapacity(), 0);
633	>	assertEquals(0, q.remainingCapacity());
634		}
635
636		/**
#	Line 854 | Line 855 | public class LinkedBlockingDequeTest ext
855		}});
856
857		await(pleaseTake);
858	<	assertEquals(q.remainingCapacity(), 0);
858	>	assertEquals(0, q.remainingCapacity());
859		assertEquals(capacity - 1, q.take());
860
861		await(pleaseInterrupt);
862		assertThreadStaysAlive(t);
863		t.interrupt();
864		awaitTermination(t);
865	<	assertEquals(q.remainingCapacity(), 0);
865	>	assertEquals(0, q.remainingCapacity());
866		}
867
868		/**
#	Line 1064 | Line 1065 | public class LinkedBlockingDequeTest ext
1065
1066		pleaseInterrupt.countDown();
1067		try {
1068	<	q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1068	>	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1069		shouldThrow();
1070		} catch (InterruptedException success) {}
1071		assertFalse(Thread.interrupted());
#	Line 1201 | Line 1202 | public class LinkedBlockingDequeTest ext
1202		}});
1203
1204		await(pleaseTake);
1205	<	assertEquals(q.remainingCapacity(), 0);
1205	>	assertEquals(0, q.remainingCapacity());
1206		assertEquals(0, q.take());
1207
1208		await(pleaseInterrupt);
1209		assertThreadStaysAlive(t);
1210		t.interrupt();
1211		awaitTermination(t);
1212	<	assertEquals(q.remainingCapacity(), 0);
1212	>	assertEquals(0, q.remainingCapacity());
1213		}
1214
1215		/**
#	Line 1400 | Line 1401 | public class LinkedBlockingDequeTest ext
1401		}
1402
1403		/**
1403	–	* remove(x) removes x and returns true if present
1404	–	*/
1405	–	public void testRemoveElement() {
1406	–	LinkedBlockingDeque q = populatedDeque(SIZE);
1407	–	for (int i = 1; i < SIZE; i+=2) {
1408	–	assertTrue(q.contains(i));
1409	–	assertTrue(q.remove(i));
1410	–	assertFalse(q.contains(i));
1411	–	assertTrue(q.contains(i-1));
1412	–	}
1413	–	for (int i = 0; i < SIZE; i+=2) {
1414	–	assertTrue(q.contains(i));
1415	–	assertTrue(q.remove(i));
1416	–	assertFalse(q.contains(i));
1417	–	assertFalse(q.remove(i+1));
1418	–	assertFalse(q.contains(i+1));
1419	–	}
1420	–	assertTrue(q.isEmpty());
1421	–	}
1422	–
1423	–	/**
1404		* contains(x) reports true when elements added but not yet removed
1405		*/
1406		public void testContains() {
#	Line 1500 | Line 1480 | public class LinkedBlockingDequeTest ext
1480		/**
1481		* toArray contains all elements in FIFO order
1482		*/
1483	<	public void testToArray() throws InterruptedException{
1483	>	public void testToArray() throws InterruptedException {
1484		LinkedBlockingDeque q = populatedDeque(SIZE);
1485		Object[] o = q.toArray();
1486		for (int i = 0; i < o.length; i++)
#	Line 1718 | Line 1698 | public class LinkedBlockingDequeTest ext
1698		* A deserialized serialized deque has same elements in same order
1699		*/
1700		public void testSerialization() throws Exception {
1701	<	LinkedBlockingDeque q = populatedDeque(SIZE);
1701	>	Queue x = populatedDeque(SIZE);
1702	>	Queue y = serialClone(x);
1703
1704	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1705	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1706	<	out.writeObject(q);
1707	<	out.close();
1708	<
1709	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1710	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1711	<	LinkedBlockingDeque r = (LinkedBlockingDeque)in.readObject();
1712	<	assertEquals(q.size(), r.size());
1732	<	while (!q.isEmpty())
1733	<	assertEquals(q.remove(), r.remove());
1704	>	assertNotSame(y, x);
1705	>	assertEquals(x.size(), y.size());
1706	>	assertEquals(x.toString(), y.toString());
1707	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
1708	>	while (!x.isEmpty()) {
1709	>	assertFalse(y.isEmpty());
1710	>	assertEquals(x.remove(), y.remove());
1711	>	}
1712	>	assertTrue(y.isEmpty());
1713		}
1714
1715		/**
#	Line 1740 | Line 1719 | public class LinkedBlockingDequeTest ext
1719		LinkedBlockingDeque q = populatedDeque(SIZE);
1720		ArrayList l = new ArrayList();
1721		q.drainTo(l);
1722	<	assertEquals(q.size(), 0);
1723	<	assertEquals(l.size(), SIZE);
1722	>	assertEquals(0, q.size());
1723	>	assertEquals(SIZE, l.size());
1724		for (int i = 0; i < SIZE; ++i)
1725		assertEquals(l.get(i), new Integer(i));
1726		q.add(zero);
#	Line 1751 | Line 1730 | public class LinkedBlockingDequeTest ext
1730		assertTrue(q.contains(one));
1731		l.clear();
1732		q.drainTo(l);
1733	<	assertEquals(q.size(), 0);
1734	<	assertEquals(l.size(), 2);
1733	>	assertEquals(0, q.size());
1734	>	assertEquals(2, l.size());
1735		for (int i = 0; i < 2; ++i)
1736		assertEquals(l.get(i), new Integer(i));
1737		}
#	Line 1788 | Line 1767 | public class LinkedBlockingDequeTest ext
1767		ArrayList l = new ArrayList();
1768		q.drainTo(l, i);
1769		int k = (i < SIZE) ? i : SIZE;
1770	<	assertEquals(l.size(), k);
1771	<	assertEquals(q.size(), SIZE-k);
1770	>	assertEquals(k, l.size());
1771	>	assertEquals(SIZE-k, q.size());
1772		for (int j = 0; j < k; ++j)
1773		assertEquals(l.get(j), new Integer(j));
1774		while (q.poll() != null) ;
1775		}
1776		}
1777
1778	+	/**
1779	+	* remove(null), contains(null) always return false
1780	+	*/
1781	+	public void testNeverContainsNull() {
1782	+	Deque<?>[] qs = {
1783	+	new LinkedBlockingDeque<Object>(),
1784	+	populatedDeque(2),
1785	+	};
1786	+
1787	+	for (Deque<?> q : qs) {
1788	+	assertFalse(q.contains(null));
1789	+	assertFalse(q.remove(null));
1790	+	assertFalse(q.removeFirstOccurrence(null));
1791	+	assertFalse(q.removeLastOccurrence(null));
1792	+	}
1793	+	}
1794	+
1795		}

Diff Legend

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