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.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) {}
    }

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