test/tck/BlockingQueueTest.java

/*
 * Written by Doug Lea and Martin Buchholz with assistance from members
 * of JCP JSR-166 Expert Group and released to the public domain, as
 * explained at http://creativecommons.org/publicdomain/zero/1.0/
 *
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

/**
 * Contains "contract" tests applicable to all BlockingQueue implementations.
 */
public abstract class BlockingQueueTest extends JSR166TestCase {
    /*
     * This is the start of an attempt to refactor the tests for the
     * various related implementations of related interfaces without
     * too much duplicated code.  junit does not really support such
     * testing.  Here subclasses of TestCase not only contain tests,
     * but also configuration information that describes the
     * implementation class, most importantly how to instantiate
     * instances.
     */

    /** Like suite(), but non-static */
    public Test testSuite() {
        // TODO: filter the returned tests using the configuration
        // information provided by the subclass via protected methods.
        return new TestSuite(this.getClass());
    }

    //----------------------------------------------------------------
    // Configuration methods
    //----------------------------------------------------------------

    /** Returns an empty instance of the implementation class. */
    protected abstract BlockingQueue emptyCollection();

    /**
     * Returns an element suitable for insertion in the collection.
     * Override for collections with unusual element types.
     */
    protected Object makeElement(int i) {
        return Integer.valueOf(i);
    }

    //----------------------------------------------------------------
    // Tests
    //----------------------------------------------------------------

    /**
     * offer(null) throws NullPointerException
     */
    public void testOfferNull() {
        final Queue q = emptyCollection();
        try {
            q.offer(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * add(null) throws NullPointerException
     */
    public void testAddNull() {
        final Collection q = emptyCollection();
        try {
            q.add(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * timed offer(null) throws NullPointerException
     */
    public void testTimedOfferNull() throws InterruptedException {
        final BlockingQueue q = emptyCollection();
        long startTime = System.nanoTime();
        try {
            q.offer(null, LONG_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (NullPointerException success) {}
        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
    }

    /**
     * put(null) throws NullPointerException
     */
    public void testPutNull() throws InterruptedException {
        final BlockingQueue q = emptyCollection();
        try {
            q.put(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * put(null) throws NullPointerException
     */
    public void testAddAllNull() throws InterruptedException {
        final Collection q = emptyCollection();
        try {
            q.addAll(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * addAll of a collection with null elements throws NullPointerException
     */
    public void testAddAllNullElements() {
        final Collection q = emptyCollection();
        final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
        try {
            q.addAll(elements);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * toArray(null) throws NullPointerException
     */
    public void testToArray_NullArray() {
        final Collection q = emptyCollection();
        try {
            q.toArray(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * drainTo(null) throws NullPointerException
     */
    public void testDrainToNull() {
        final BlockingQueue q = emptyCollection();
        try {
            q.drainTo(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * drainTo(this) throws IllegalArgumentException
     */
    public void testDrainToSelf() {
        final BlockingQueue q = emptyCollection();
        try {
            q.drainTo(q);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * drainTo(null, n) throws NullPointerException
     */
    public void testDrainToNullN() {
        final BlockingQueue q = emptyCollection();
        try {
            q.drainTo(null, 0);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * drainTo(this, n) throws IllegalArgumentException
     */
    public void testDrainToSelfN() {
        final BlockingQueue q = emptyCollection();
        try {
            q.drainTo(q, 0);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * drainTo(c, -n) returns 0
     */
    public void testDrainToNegativeMaxElements() {
        final BlockingQueue q = emptyCollection();
        assertEquals(0, q.drainTo(new ArrayList(), -42));
    }

    /**
     * drainTo(c, 0) returns 0 and does nothing
     */
    public void testDrainToZeroMaxElements() {
        final BlockingQueue q = emptyCollection();
        if (q.remainingCapacity() == 0) {
            // SynchronousQueue, for example
            assertEquals(0, q.drainTo(new ArrayList(), 0));
        } else {
            Object one = makeElement(1);
            q.add(one);
            ArrayList c = new ArrayList();
            assertEquals(0, q.drainTo(c, 0));
            assertEquals(1, q.size());
            assertSame(one, q.poll());
            assertTrue(c.isEmpty());
        }
    }

    /**
     * timed poll before a delayed offer times out; after offer succeeds;
     * on interruption throws
     */
    public void testTimedPollWithOffer() throws InterruptedException {
        final BlockingQueue q = emptyCollection();
        final CheckedBarrier barrier = new CheckedBarrier(2);
        final Object zero = makeElement(0);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                long startTime = System.nanoTime();
                assertNull(q.poll(timeoutMillis(), MILLISECONDS));
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

                barrier.await();

                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));

                Thread.currentThread().interrupt();
                try {
                    q.poll(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                barrier.await();
                try {
                    q.poll(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        barrier.await();
        long startTime = System.nanoTime();
        assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);

        barrier.await();
        assertThreadStaysAlive(t);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * take() blocks interruptibly when empty
     */
    public void testTakeFromEmptyBlocksInterruptibly() {
        final BlockingQueue q = emptyCollection();
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                threadStarted.countDown();
                try {
                    q.take();
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        await(threadStarted);
        assertThreadStaysAlive(t);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * take() throws InterruptedException immediately if interrupted
     * before waiting
     */
    public void testTakeFromEmptyAfterInterrupt() {
        final BlockingQueue q = emptyCollection();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                Thread.currentThread().interrupt();
                try {
                    q.take();
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        awaitTermination(t);
    }

    /**
     * timed poll() blocks interruptibly when empty
     */
    public void testTimedPollFromEmptyBlocksInterruptibly() {
        final BlockingQueue q = emptyCollection();
        final CountDownLatch threadStarted = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                threadStarted.countDown();
                try {
                    q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        await(threadStarted);
        assertThreadStaysAlive(t);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timed poll() throws InterruptedException immediately if
     * interrupted before waiting
     */
    public void testTimedPollFromEmptyAfterInterrupt() {
        final BlockingQueue q = emptyCollection();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                Thread.currentThread().interrupt();
                try {
                    q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        awaitTermination(t);
    }

    /** For debugging. */
    public void XXXXtestFails() {
        fail(emptyCollection().getClass().toString());
    }

}
Revision:	1.10
Committed:	Tue Jun 14 03:22:38 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.9:	+28 -0 lines
Log Message:	drainTo(c, -n) should return 0
#	Content
1	/*
2	* Written by Doug Lea and Martin Buchholz with assistance from members
3	* of JCP JSR-166 Expert Group and released to the public domain, as
4	* explained at http://creativecommons.org/publicdomain/zero/1.0/
5	*
6	* Other contributors include Andrew Wright, Jeffrey Hayes,
7	* Pat Fisher, Mike Judd.
8	*/
9
10	import junit.framework.*;
11	import java.util.ArrayList;
12	import java.util.Arrays;
13	import java.util.Collection;
14	import java.util.Queue;
15	import java.util.concurrent.BlockingQueue;
16	import java.util.concurrent.CountDownLatch;
17	import static java.util.concurrent.TimeUnit.MILLISECONDS;
18
19	/**
20	* Contains "contract" tests applicable to all BlockingQueue implementations.
21	*/
22	public abstract class BlockingQueueTest extends JSR166TestCase {
23	/*
24	* This is the start of an attempt to refactor the tests for the
25	* various related implementations of related interfaces without
26	* too much duplicated code. junit does not really support such
27	* testing. Here subclasses of TestCase not only contain tests,
28	* but also configuration information that describes the
29	* implementation class, most importantly how to instantiate
30	* instances.
31	*/
32
33	/** Like suite(), but non-static */
34	public Test testSuite() {
35	// TODO: filter the returned tests using the configuration
36	// information provided by the subclass via protected methods.
37	return new TestSuite(this.getClass());
38	}
39
40	//----------------------------------------------------------------
41	// Configuration methods
42	//----------------------------------------------------------------
43
44	/** Returns an empty instance of the implementation class. */
45	protected abstract BlockingQueue emptyCollection();
46
47	/**
48	* Returns an element suitable for insertion in the collection.
49	* Override for collections with unusual element types.
50	*/
51	protected Object makeElement(int i) {
52	return Integer.valueOf(i);
53	}
54
55	//----------------------------------------------------------------
56	// Tests
57	//----------------------------------------------------------------
58
59	/**
60	* offer(null) throws NullPointerException
61	*/
62	public void testOfferNull() {
63	final Queue q = emptyCollection();
64	try {
65	q.offer(null);
66	shouldThrow();
67	} catch (NullPointerException success) {}
68	}
69
70	/**
71	* add(null) throws NullPointerException
72	*/
73	public void testAddNull() {
74	final Collection q = emptyCollection();
75	try {
76	q.add(null);
77	shouldThrow();
78	} catch (NullPointerException success) {}
79	}
80
81	/**
82	* timed offer(null) throws NullPointerException
83	*/
84	public void testTimedOfferNull() throws InterruptedException {
85	final BlockingQueue q = emptyCollection();
86	long startTime = System.nanoTime();
87	try {
88	q.offer(null, LONG_DELAY_MS, MILLISECONDS);
89	shouldThrow();
90	} catch (NullPointerException success) {}
91	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
92	}
93
94	/**
95	* put(null) throws NullPointerException
96	*/
97	public void testPutNull() throws InterruptedException {
98	final BlockingQueue q = emptyCollection();
99	try {
100	q.put(null);
101	shouldThrow();
102	} catch (NullPointerException success) {}
103	}
104
105	/**
106	* put(null) throws NullPointerException
107	*/
108	public void testAddAllNull() throws InterruptedException {
109	final Collection q = emptyCollection();
110	try {
111	q.addAll(null);
112	shouldThrow();
113	} catch (NullPointerException success) {}
114	}
115
116	/**
117	* addAll of a collection with null elements throws NullPointerException
118	*/
119	public void testAddAllNullElements() {
120	final Collection q = emptyCollection();
121	final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
122	try {
123	q.addAll(elements);
124	shouldThrow();
125	} catch (NullPointerException success) {}
126	}
127
128	/**
129	* toArray(null) throws NullPointerException
130	*/
131	public void testToArray_NullArray() {
132	final Collection q = emptyCollection();
133	try {
134	q.toArray(null);
135	shouldThrow();
136	} catch (NullPointerException success) {}
137	}
138
139	/**
140	* drainTo(null) throws NullPointerException
141	*/
142	public void testDrainToNull() {
143	final BlockingQueue q = emptyCollection();
144	try {
145	q.drainTo(null);
146	shouldThrow();
147	} catch (NullPointerException success) {}
148	}
149
150	/**
151	* drainTo(this) throws IllegalArgumentException
152	*/
153	public void testDrainToSelf() {
154	final BlockingQueue q = emptyCollection();
155	try {
156	q.drainTo(q);
157	shouldThrow();
158	} catch (IllegalArgumentException success) {}
159	}
160
161	/**
162	* drainTo(null, n) throws NullPointerException
163	*/
164	public void testDrainToNullN() {
165	final BlockingQueue q = emptyCollection();
166	try {
167	q.drainTo(null, 0);
168	shouldThrow();
169	} catch (NullPointerException success) {}
170	}
171
172	/**
173	* drainTo(this, n) throws IllegalArgumentException
174	*/
175	public void testDrainToSelfN() {
176	final BlockingQueue q = emptyCollection();
177	try {
178	q.drainTo(q, 0);
179	shouldThrow();
180	} catch (IllegalArgumentException success) {}
181	}
182
183	/**
184	* drainTo(c, -n) returns 0
185	*/
186	public void testDrainToNegativeMaxElements() {
187	final BlockingQueue q = emptyCollection();
188	assertEquals(0, q.drainTo(new ArrayList(), -42));
189	}
190
191	/**
192	* drainTo(c, 0) returns 0 and does nothing
193	*/
194	public void testDrainToZeroMaxElements() {
195	final BlockingQueue q = emptyCollection();
196	if (q.remainingCapacity() == 0) {
197	// SynchronousQueue, for example
198	assertEquals(0, q.drainTo(new ArrayList(), 0));
199	} else {
200	Object one = makeElement(1);
201	q.add(one);
202	ArrayList c = new ArrayList();
203	assertEquals(0, q.drainTo(c, 0));
204	assertEquals(1, q.size());
205	assertSame(one, q.poll());
206	assertTrue(c.isEmpty());
207	}
208	}
209
210	/**
211	* timed poll before a delayed offer times out; after offer succeeds;
212	* on interruption throws
213	*/
214	public void testTimedPollWithOffer() throws InterruptedException {
215	final BlockingQueue q = emptyCollection();
216	final CheckedBarrier barrier = new CheckedBarrier(2);
217	final Object zero = makeElement(0);
218	Thread t = newStartedThread(new CheckedRunnable() {
219	public void realRun() throws InterruptedException {
220	long startTime = System.nanoTime();
221	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
222	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
223
224	barrier.await();
225
226	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
227
228	Thread.currentThread().interrupt();
229	try {
230	q.poll(LONG_DELAY_MS, MILLISECONDS);
231	shouldThrow();
232	} catch (InterruptedException success) {}
233	assertFalse(Thread.interrupted());
234
235	barrier.await();
236	try {
237	q.poll(LONG_DELAY_MS, MILLISECONDS);
238	shouldThrow();
239	} catch (InterruptedException success) {}
240	assertFalse(Thread.interrupted());
241	}});
242
243	barrier.await();
244	long startTime = System.nanoTime();
245	assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
246	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
247
248	barrier.await();
249	assertThreadStaysAlive(t);
250	t.interrupt();
251	awaitTermination(t);
252	}
253
254	/**
255	* take() blocks interruptibly when empty
256	*/
257	public void testTakeFromEmptyBlocksInterruptibly() {
258	final BlockingQueue q = emptyCollection();
259	final CountDownLatch threadStarted = new CountDownLatch(1);
260	Thread t = newStartedThread(new CheckedRunnable() {
261	public void realRun() {
262	threadStarted.countDown();
263	try {
264	q.take();
265	shouldThrow();
266	} catch (InterruptedException success) {}
267	assertFalse(Thread.interrupted());
268	}});
269
270	await(threadStarted);
271	assertThreadStaysAlive(t);
272	t.interrupt();
273	awaitTermination(t);
274	}
275
276	/**
277	* take() throws InterruptedException immediately if interrupted
278	* before waiting
279	*/
280	public void testTakeFromEmptyAfterInterrupt() {
281	final BlockingQueue q = emptyCollection();
282	Thread t = newStartedThread(new CheckedRunnable() {
283	public void realRun() {
284	Thread.currentThread().interrupt();
285	try {
286	q.take();
287	shouldThrow();
288	} catch (InterruptedException success) {}
289	assertFalse(Thread.interrupted());
290	}});
291
292	awaitTermination(t);
293	}
294
295	/**
296	* timed poll() blocks interruptibly when empty
297	*/
298	public void testTimedPollFromEmptyBlocksInterruptibly() {
299	final BlockingQueue q = emptyCollection();
300	final CountDownLatch threadStarted = new CountDownLatch(1);
301	Thread t = newStartedThread(new CheckedRunnable() {
302	public void realRun() {
303	threadStarted.countDown();
304	try {
305	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
306	shouldThrow();
307	} catch (InterruptedException success) {}
308	assertFalse(Thread.interrupted());
309	}});
310
311	await(threadStarted);
312	assertThreadStaysAlive(t);
313	t.interrupt();
314	awaitTermination(t);
315	}
316
317	/**
318	* timed poll() throws InterruptedException immediately if
319	* interrupted before waiting
320	*/
321	public void testTimedPollFromEmptyAfterInterrupt() {
322	final BlockingQueue q = emptyCollection();
323	Thread t = newStartedThread(new CheckedRunnable() {
324	public void realRun() {
325	Thread.currentThread().interrupt();
326	try {
327	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
328	shouldThrow();
329	} catch (InterruptedException success) {}
330	assertFalse(Thread.interrupted());
331	}});
332
333	awaitTermination(t);
334	}
335
336	/** For debugging. */
337	public void XXXXtestFails() {
338	fail(emptyCollection().getClass().toString());
339	}
340
341	}