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.43 by jsr166, Tue Oct 25 20:29:12 2011 UTC vs.
Revision 1.51 by jsr166, Wed Dec 31 19:05:42 2014 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	<	import junit.framework.*;
8	<	import java.util.Arrays;
7	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
8	>
9		import java.util.ArrayList;
10	+	import java.util.Arrays;
11		import java.util.Collection;
12	+	import java.util.Deque;
13		import java.util.Iterator;
14		import java.util.NoSuchElementException;
15		import java.util.Queue;
#	Line 17 | Line 19 | import java.util.concurrent.CountDownLat
19		import java.util.concurrent.Executors;
20		import java.util.concurrent.ExecutorService;
21		import java.util.concurrent.LinkedBlockingDeque;
22	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
22	>
23	>	import junit.framework.Test;
24
25		public class LinkedBlockingDequeTest extends JSR166TestCase {
26
#	Line 44 | Line 47 | public class LinkedBlockingDequeTest ext
47		}
48
49		/**
50	<	* Create a deque of given size containing consecutive
50	>	* Returns a new deque of given size containing consecutive
51		* Integers 0 ... n.
52		*/
53		private LinkedBlockingDeque<Integer> populatedDeque(int n) {
#	Line 622 | Line 625 | public class LinkedBlockingDequeTest ext
625		}});
626
627		await(pleaseTake);
628	<	assertEquals(q.remainingCapacity(), 0);
628	>	assertEquals(0, q.remainingCapacity());
629		assertEquals(0, q.take());
630
631		await(pleaseInterrupt);
632		assertThreadStaysAlive(t);
633		t.interrupt();
634		awaitTermination(t);
635	<	assertEquals(q.remainingCapacity(), 0);
635	>	assertEquals(0, q.remainingCapacity());
636		}
637
638		/**
#	Line 854 | Line 857 | public class LinkedBlockingDequeTest ext
857		}});
858
859		await(pleaseTake);
860	<	assertEquals(q.remainingCapacity(), 0);
860	>	assertEquals(0, q.remainingCapacity());
861		assertEquals(capacity - 1, q.take());
862
863		await(pleaseInterrupt);
864		assertThreadStaysAlive(t);
865		t.interrupt();
866		awaitTermination(t);
867	<	assertEquals(q.remainingCapacity(), 0);
867	>	assertEquals(0, q.remainingCapacity());
868		}
869
870		/**
#	Line 1064 | Line 1067 | public class LinkedBlockingDequeTest ext
1067
1068		pleaseInterrupt.countDown();
1069		try {
1070	<	q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1070	>	q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1071		shouldThrow();
1072		} catch (InterruptedException success) {}
1073		assertFalse(Thread.interrupted());
#	Line 1201 | Line 1204 | public class LinkedBlockingDequeTest ext
1204		}});
1205
1206		await(pleaseTake);
1207	<	assertEquals(q.remainingCapacity(), 0);
1207	>	assertEquals(0, q.remainingCapacity());
1208		assertEquals(0, q.take());
1209
1210		await(pleaseInterrupt);
1211		assertThreadStaysAlive(t);
1212		t.interrupt();
1213		awaitTermination(t);
1214	<	assertEquals(q.remainingCapacity(), 0);
1214	>	assertEquals(0, q.remainingCapacity());
1215		}
1216
1217		/**
#	Line 1700 | Line 1703 | public class LinkedBlockingDequeTest ext
1703		Queue x = populatedDeque(SIZE);
1704		Queue y = serialClone(x);
1705
1706	<	assertTrue(x != y);
1706	>	assertNotSame(y, x);
1707		assertEquals(x.size(), y.size());
1708		assertEquals(x.toString(), y.toString());
1709		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 1718 | Line 1721 | public class LinkedBlockingDequeTest ext
1721		LinkedBlockingDeque q = populatedDeque(SIZE);
1722		ArrayList l = new ArrayList();
1723		q.drainTo(l);
1724	<	assertEquals(q.size(), 0);
1725	<	assertEquals(l.size(), SIZE);
1724	>	assertEquals(0, q.size());
1725	>	assertEquals(SIZE, l.size());
1726		for (int i = 0; i < SIZE; ++i)
1727		assertEquals(l.get(i), new Integer(i));
1728		q.add(zero);
#	Line 1729 | Line 1732 | public class LinkedBlockingDequeTest ext
1732		assertTrue(q.contains(one));
1733		l.clear();
1734		q.drainTo(l);
1735	<	assertEquals(q.size(), 0);
1736	<	assertEquals(l.size(), 2);
1735	>	assertEquals(0, q.size());
1736	>	assertEquals(2, l.size());
1737		for (int i = 0; i < 2; ++i)
1738		assertEquals(l.get(i), new Integer(i));
1739		}
#	Line 1766 | Line 1769 | public class LinkedBlockingDequeTest ext
1769		ArrayList l = new ArrayList();
1770		q.drainTo(l, i);
1771		int k = (i < SIZE) ? i : SIZE;
1772	<	assertEquals(l.size(), k);
1773	<	assertEquals(q.size(), SIZE-k);
1772	>	assertEquals(k, l.size());
1773	>	assertEquals(SIZE-k, q.size());
1774		for (int j = 0; j < k; ++j)
1775		assertEquals(l.get(j), new Integer(j));
1776		while (q.poll() != null) ;
1777		}
1778		}
1779
1780	+	/**
1781	+	* remove(null), contains(null) always return false
1782	+	*/
1783	+	public void testNeverContainsNull() {
1784	+	Deque<?>[] qs = {
1785	+	new LinkedBlockingDeque<Object>(),
1786	+	populatedDeque(2),
1787	+	};
1788	+
1789	+	for (Deque<?> q : qs) {
1790	+	assertFalse(q.contains(null));
1791	+	assertFalse(q.remove(null));
1792	+	assertFalse(q.removeFirstOccurrence(null));
1793	+	assertFalse(q.removeLastOccurrence(null));
1794	+	}
1795	+	}
1796	+
1797		}

Diff Legend

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