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
#	User	Rev	Content
1	jsr166	1.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	jsr166	1.5	* explained at http://creativecommons.org/publicdomain/zero/1.0/
5	jsr166	1.1	*
6			* Other contributors include Andrew Wright, Jeffrey Hayes,
7			* Pat Fisher, Mike Judd.
8			*/
9
10			import junit.framework.*;
11	jsr166	1.10	import java.util.ArrayList;
12	jsr166	1.8	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	jsr166	1.1	import static java.util.concurrent.TimeUnit.MILLISECONDS;
18
19			/**
20	jsr166	1.8	* Contains "contract" tests applicable to all BlockingQueue implementations.
21	jsr166	1.1	*/
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	jsr166	1.8	//----------------------------------------------------------------
41			// Configuration methods
42			//----------------------------------------------------------------
43	jsr166	1.9
44	jsr166	1.1	/** Returns an empty instance of the implementation class. */
45			protected abstract BlockingQueue emptyCollection();
46
47			/**
48	jsr166	1.8	* 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	jsr166	1.9
59	jsr166	1.8	/**
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	jsr166	1.10	* 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	jsr166	1.7	* timed poll before a delayed offer times out; after offer succeeds;
212	jsr166	1.1	* on interruption throws
213			*/
214			public void testTimedPollWithOffer() throws InterruptedException {
215			final BlockingQueue q = emptyCollection();
216			final CheckedBarrier barrier = new CheckedBarrier(2);
217	jsr166	1.8	final Object zero = makeElement(0);
218	jsr166	1.1	Thread t = newStartedThread(new CheckedRunnable() {
219			public void realRun() throws InterruptedException {
220	jsr166	1.7	long startTime = System.nanoTime();
221			assertNull(q.poll(timeoutMillis(), MILLISECONDS));
222			assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
223	jsr166	1.1
224			barrier.await();
225	jsr166	1.7
226			assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
227	jsr166	1.1
228			Thread.currentThread().interrupt();
229			try {
230	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
231	jsr166	1.1	shouldThrow();
232			} catch (InterruptedException success) {}
233	jsr166	1.7	assertFalse(Thread.interrupted());
234	jsr166	1.1
235			barrier.await();
236			try {
237	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
238	jsr166	1.1	shouldThrow();
239			} catch (InterruptedException success) {}
240	jsr166	1.7	assertFalse(Thread.interrupted());
241	jsr166	1.1	}});
242
243			barrier.await();
244	jsr166	1.7	long startTime = System.nanoTime();
245			assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
246			assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
247
248	jsr166	1.1	barrier.await();
249	jsr166	1.7	assertThreadStaysAlive(t);
250	jsr166	1.1	t.interrupt();
251	jsr166	1.7	awaitTermination(t);
252	jsr166	1.1	}
253
254	jsr166	1.2	/**
255	jsr166	1.3	* take() blocks interruptibly when empty
256	jsr166	1.2	*/
257	jsr166	1.7	public void testTakeFromEmptyBlocksInterruptibly() {
258	jsr166	1.2	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	jsr166	1.7	assertFalse(Thread.interrupted());
268	jsr166	1.2	}});
269	jsr166	1.3
270	jsr166	1.7	await(threadStarted);
271			assertThreadStaysAlive(t);
272	jsr166	1.2	t.interrupt();
273	jsr166	1.7	awaitTermination(t);
274	jsr166	1.3	}
275
276			/**
277			* take() throws InterruptedException immediately if interrupted
278			* before waiting
279			*/
280	jsr166	1.7	public void testTakeFromEmptyAfterInterrupt() {
281	jsr166	1.3	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	jsr166	1.7	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	jsr166	1.3	}});
332
333	jsr166	1.7	awaitTermination(t);
334	jsr166	1.2	}
335
336	jsr166	1.1	/** For debugging. */
337			public void XXXXtestFails() {
338			fail(emptyCollection().getClass().toString());
339			}
340
341			}