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 and does nothing when n <= 0
     */
    public void testDrainToNonPositiveMaxElements() {
        final BlockingQueue q = emptyCollection();
        final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
        for (int n : ns)
            assertEquals(0, q.drainTo(new ArrayList(), n));
        if (q.remainingCapacity() > 0) {
            // Not SynchronousQueue, that is
            Object one = makeElement(1);
            q.add(one);
            ArrayList c = new ArrayList();
            for (int n : ns)
                assertEquals(0, q.drainTo(new ArrayList(), n));
            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.11
Committed:	Tue Jun 14 04:30:06 2011 UTC (12 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.10:	+9 -15 lines
Log Message:	improve testDrainToNonPositiveMaxElements
#	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 and does nothing when n <= 0
185	*/
186	public void testDrainToNonPositiveMaxElements() {
187	final BlockingQueue q = emptyCollection();
188	final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
189	for (int n : ns)
190	assertEquals(0, q.drainTo(new ArrayList(), n));
191	if (q.remainingCapacity() > 0) {
192	// Not SynchronousQueue, that is
193	Object one = makeElement(1);
194	q.add(one);
195	ArrayList c = new ArrayList();
196	for (int n : ns)
197	assertEquals(0, q.drainTo(new ArrayList(), n));
198	assertEquals(1, q.size());
199	assertSame(one, q.poll());
200	assertTrue(c.isEmpty());
201	}
202	}
203
204	/**
205	* timed poll before a delayed offer times out; after offer succeeds;
206	* on interruption throws
207	*/
208	public void testTimedPollWithOffer() throws InterruptedException {
209	final BlockingQueue q = emptyCollection();
210	final CheckedBarrier barrier = new CheckedBarrier(2);
211	final Object zero = makeElement(0);
212	Thread t = newStartedThread(new CheckedRunnable() {
213	public void realRun() throws InterruptedException {
214	long startTime = System.nanoTime();
215	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
216	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
217
218	barrier.await();
219
220	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
221
222	Thread.currentThread().interrupt();
223	try {
224	q.poll(LONG_DELAY_MS, MILLISECONDS);
225	shouldThrow();
226	} catch (InterruptedException success) {}
227	assertFalse(Thread.interrupted());
228
229	barrier.await();
230	try {
231	q.poll(LONG_DELAY_MS, MILLISECONDS);
232	shouldThrow();
233	} catch (InterruptedException success) {}
234	assertFalse(Thread.interrupted());
235	}});
236
237	barrier.await();
238	long startTime = System.nanoTime();
239	assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
240	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
241
242	barrier.await();
243	assertThreadStaysAlive(t);
244	t.interrupt();
245	awaitTermination(t);
246	}
247
248	/**
249	* take() blocks interruptibly when empty
250	*/
251	public void testTakeFromEmptyBlocksInterruptibly() {
252	final BlockingQueue q = emptyCollection();
253	final CountDownLatch threadStarted = new CountDownLatch(1);
254	Thread t = newStartedThread(new CheckedRunnable() {
255	public void realRun() {
256	threadStarted.countDown();
257	try {
258	q.take();
259	shouldThrow();
260	} catch (InterruptedException success) {}
261	assertFalse(Thread.interrupted());
262	}});
263
264	await(threadStarted);
265	assertThreadStaysAlive(t);
266	t.interrupt();
267	awaitTermination(t);
268	}
269
270	/**
271	* take() throws InterruptedException immediately if interrupted
272	* before waiting
273	*/
274	public void testTakeFromEmptyAfterInterrupt() {
275	final BlockingQueue q = emptyCollection();
276	Thread t = newStartedThread(new CheckedRunnable() {
277	public void realRun() {
278	Thread.currentThread().interrupt();
279	try {
280	q.take();
281	shouldThrow();
282	} catch (InterruptedException success) {}
283	assertFalse(Thread.interrupted());
284	}});
285
286	awaitTermination(t);
287	}
288
289	/**
290	* timed poll() blocks interruptibly when empty
291	*/
292	public void testTimedPollFromEmptyBlocksInterruptibly() {
293	final BlockingQueue q = emptyCollection();
294	final CountDownLatch threadStarted = new CountDownLatch(1);
295	Thread t = newStartedThread(new CheckedRunnable() {
296	public void realRun() {
297	threadStarted.countDown();
298	try {
299	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
300	shouldThrow();
301	} catch (InterruptedException success) {}
302	assertFalse(Thread.interrupted());
303	}});
304
305	await(threadStarted);
306	assertThreadStaysAlive(t);
307	t.interrupt();
308	awaitTermination(t);
309	}
310
311	/**
312	* timed poll() throws InterruptedException immediately if
313	* interrupted before waiting
314	*/
315	public void testTimedPollFromEmptyAfterInterrupt() {
316	final BlockingQueue q = emptyCollection();
317	Thread t = newStartedThread(new CheckedRunnable() {
318	public void realRun() {
319	Thread.currentThread().interrupt();
320	try {
321	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
322	shouldThrow();
323	} catch (InterruptedException success) {}
324	assertFalse(Thread.interrupted());
325	}});
326
327	awaitTermination(t);
328	}
329
330	/** For debugging. */
331	public void XXXXtestFails() {
332	fail(emptyCollection().getClass().toString());
333	}
334
335	}