ViewVC Help

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

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

Comparing jsr166/src/test/tck/BlockingQueueTest.java (file contents):
Revision 1.7 by jsr166, Fri May 27 19:32:04 2011 UTC vs.
Revision 1.14 by jsr166, Wed Dec 31 20:09:08 2014 UTC

#	Line 7 | Line 7
7		* Pat Fisher, Mike Judd.
8		*/
9
10	–	import junit.framework.*;
11	–	import java.util.*;
12	–	import java.util.concurrent.*;
10		import static java.util.concurrent.TimeUnit.MILLISECONDS;
11
12	+	import java.util.ArrayList;
13	+	import java.util.Arrays;
14	+	import java.util.Collection;
15	+	import java.util.Queue;
16	+	import java.util.concurrent.BlockingQueue;
17	+	import java.util.concurrent.CountDownLatch;
18	+
19	+	import junit.framework.Test;
20	+	import junit.framework.TestSuite;
21	+
22		/**
23	<	* Contains tests generally applicable to BlockingQueue implementations.
23	>	* Contains "contract" tests applicable to all BlockingQueue implementations.
24		*/
25		public abstract class BlockingQueueTest extends JSR166TestCase {
26		/*
#	Line 33 | Line 40 | public abstract class BlockingQueueTest
40		return new TestSuite(this.getClass());
41		}
42
43	+	//----------------------------------------------------------------
44	+	// Configuration methods
45	+	//----------------------------------------------------------------
46	+
47		/** Returns an empty instance of the implementation class. */
48		protected abstract BlockingQueue emptyCollection();
49
50		/**
51	+	* Returns an element suitable for insertion in the collection.
52	+	* Override for collections with unusual element types.
53	+	*/
54	+	protected Object makeElement(int i) {
55	+	return Integer.valueOf(i);
56	+	}
57	+
58	+	//----------------------------------------------------------------
59	+	// Tests
60	+	//----------------------------------------------------------------
61	+
62	+	/**
63	+	* offer(null) throws NullPointerException
64	+	*/
65	+	public void testOfferNull() {
66	+	final Queue q = emptyCollection();
67	+	try {
68	+	q.offer(null);
69	+	shouldThrow();
70	+	} catch (NullPointerException success) {}
71	+	}
72	+
73	+	/**
74	+	* add(null) throws NullPointerException
75	+	*/
76	+	public void testAddNull() {
77	+	final Collection q = emptyCollection();
78	+	try {
79	+	q.add(null);
80	+	shouldThrow();
81	+	} catch (NullPointerException success) {}
82	+	}
83	+
84	+	/**
85	+	* timed offer(null) throws NullPointerException
86	+	*/
87	+	public void testTimedOfferNull() throws InterruptedException {
88	+	final BlockingQueue q = emptyCollection();
89	+	long startTime = System.nanoTime();
90	+	try {
91	+	q.offer(null, LONG_DELAY_MS, MILLISECONDS);
92	+	shouldThrow();
93	+	} catch (NullPointerException success) {}
94	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
95	+	}
96	+
97	+	/**
98	+	* put(null) throws NullPointerException
99	+	*/
100	+	public void testPutNull() throws InterruptedException {
101	+	final BlockingQueue q = emptyCollection();
102	+	try {
103	+	q.put(null);
104	+	shouldThrow();
105	+	} catch (NullPointerException success) {}
106	+	}
107	+
108	+	/**
109	+	* put(null) throws NullPointerException
110	+	*/
111	+	public void testAddAllNull() throws InterruptedException {
112	+	final Collection q = emptyCollection();
113	+	try {
114	+	q.addAll(null);
115	+	shouldThrow();
116	+	} catch (NullPointerException success) {}
117	+	}
118	+
119	+	/**
120	+	* addAll of a collection with null elements throws NullPointerException
121	+	*/
122	+	public void testAddAllNullElements() {
123	+	final Collection q = emptyCollection();
124	+	final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
125	+	try {
126	+	q.addAll(elements);
127	+	shouldThrow();
128	+	} catch (NullPointerException success) {}
129	+	}
130	+
131	+	/**
132	+	* toArray(null) throws NullPointerException
133	+	*/
134	+	public void testToArray_NullArray() {
135	+	final Collection q = emptyCollection();
136	+	try {
137	+	q.toArray(null);
138	+	shouldThrow();
139	+	} catch (NullPointerException success) {}
140	+	}
141	+
142	+	/**
143	+	* drainTo(null) throws NullPointerException
144	+	*/
145	+	public void testDrainToNull() {
146	+	final BlockingQueue q = emptyCollection();
147	+	try {
148	+	q.drainTo(null);
149	+	shouldThrow();
150	+	} catch (NullPointerException success) {}
151	+	}
152	+
153	+	/**
154	+	* drainTo(this) throws IllegalArgumentException
155	+	*/
156	+	public void testDrainToSelf() {
157	+	final BlockingQueue q = emptyCollection();
158	+	try {
159	+	q.drainTo(q);
160	+	shouldThrow();
161	+	} catch (IllegalArgumentException success) {}
162	+	}
163	+
164	+	/**
165	+	* drainTo(null, n) throws NullPointerException
166	+	*/
167	+	public void testDrainToNullN() {
168	+	final BlockingQueue q = emptyCollection();
169	+	try {
170	+	q.drainTo(null, 0);
171	+	shouldThrow();
172	+	} catch (NullPointerException success) {}
173	+	}
174	+
175	+	/**
176	+	* drainTo(this, n) throws IllegalArgumentException
177	+	*/
178	+	public void testDrainToSelfN() {
179	+	final BlockingQueue q = emptyCollection();
180	+	try {
181	+	q.drainTo(q, 0);
182	+	shouldThrow();
183	+	} catch (IllegalArgumentException success) {}
184	+	}
185	+
186	+	/**
187	+	* drainTo(c, n) returns 0 and does nothing when n <= 0
188	+	*/
189	+	public void testDrainToNonPositiveMaxElements() {
190	+	final BlockingQueue q = emptyCollection();
191	+	final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
192	+	for (int n : ns)
193	+	assertEquals(0, q.drainTo(new ArrayList(), n));
194	+	if (q.remainingCapacity() > 0) {
195	+	// Not SynchronousQueue, that is
196	+	Object one = makeElement(1);
197	+	q.add(one);
198	+	ArrayList c = new ArrayList();
199	+	for (int n : ns)
200	+	assertEquals(0, q.drainTo(new ArrayList(), n));
201	+	assertEquals(1, q.size());
202	+	assertSame(one, q.poll());
203	+	assertTrue(c.isEmpty());
204	+	}
205	+	}
206	+
207	+	/**
208		* timed poll before a delayed offer times out; after offer succeeds;
209		* on interruption throws
210		*/
211		public void testTimedPollWithOffer() throws InterruptedException {
212		final BlockingQueue q = emptyCollection();
213		final CheckedBarrier barrier = new CheckedBarrier(2);
214	+	final Object zero = makeElement(0);
215		Thread t = newStartedThread(new CheckedRunnable() {
216		public void realRun() throws InterruptedException {
217		long startTime = System.nanoTime();
#	Line 161 | Line 330 | public abstract class BlockingQueueTest
330		awaitTermination(t);
331		}
332
333	+	/**
334	+	* remove(x) removes x and returns true if present
335	+	* TODO: move to superclass CollectionTest.java
336	+	*/
337	+	public void testRemoveElement() {
338	+	final BlockingQueue q = emptyCollection();
339	+	final int size = Math.min(q.remainingCapacity(), SIZE);
340	+	final Object[] elts = new Object[size];
341	+	assertFalse(q.contains(makeElement(99)));
342	+	assertFalse(q.remove(makeElement(99)));
343	+	checkEmpty(q);
344	+	for (int i = 0; i < size; i++)
345	+	q.add(elts[i] = makeElement(i));
346	+	for (int i = 1; i < size; i += 2) {
347	+	for (int pass = 0; pass < 2; pass++) {
348	+	assertEquals((pass == 0), q.contains(elts[i]));
349	+	assertEquals((pass == 0), q.remove(elts[i]));
350	+	assertFalse(q.contains(elts[i]));
351	+	assertTrue(q.contains(elts[i-1]));
352	+	if (i < size - 1)
353	+	assertTrue(q.contains(elts[i+1]));
354	+	}
355	+	}
356	+	if (size > 0)
357	+	assertTrue(q.contains(elts[0]));
358	+	for (int i = size-2; i >= 0; i -= 2) {
359	+	assertTrue(q.contains(elts[i]));
360	+	assertFalse(q.contains(elts[i+1]));
361	+	assertTrue(q.remove(elts[i]));
362	+	assertFalse(q.contains(elts[i]));
363	+	assertFalse(q.remove(elts[i+1]));
364	+	assertFalse(q.contains(elts[i+1]));
365	+	}
366	+	checkEmpty(q);
367	+	}
368	+
369		/** For debugging. */
370		public void XXXXtestFails() {
371		fail(emptyCollection().getClass().toString());

Diff Legend

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