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
#	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.8	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	jsr166	1.1	import static java.util.concurrent.TimeUnit.MILLISECONDS;
17
18			/**
19	jsr166	1.8	* Contains "contract" tests applicable to all BlockingQueue implementations.
20	jsr166	1.1	*/
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	jsr166	1.8	//----------------------------------------------------------------
40			// Configuration methods
41			//----------------------------------------------------------------
42	jsr166	1.9
43	jsr166	1.1	/** Returns an empty instance of the implementation class. */
44			protected abstract BlockingQueue emptyCollection();
45
46			/**
47	jsr166	1.8	* 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	jsr166	1.9
58	jsr166	1.8	/**
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	jsr166	1.7	* timed poll before a delayed offer times out; after offer succeeds;
184	jsr166	1.1	* on interruption throws
185			*/
186			public void testTimedPollWithOffer() throws InterruptedException {
187			final BlockingQueue q = emptyCollection();
188			final CheckedBarrier barrier = new CheckedBarrier(2);
189	jsr166	1.8	final Object zero = makeElement(0);
190	jsr166	1.1	Thread t = newStartedThread(new CheckedRunnable() {
191			public void realRun() throws InterruptedException {
192	jsr166	1.7	long startTime = System.nanoTime();
193			assertNull(q.poll(timeoutMillis(), MILLISECONDS));
194			assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
195	jsr166	1.1
196			barrier.await();
197	jsr166	1.7
198			assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
199	jsr166	1.1
200			Thread.currentThread().interrupt();
201			try {
202	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
203	jsr166	1.1	shouldThrow();
204			} catch (InterruptedException success) {}
205	jsr166	1.7	assertFalse(Thread.interrupted());
206	jsr166	1.1
207			barrier.await();
208			try {
209	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
210	jsr166	1.1	shouldThrow();
211			} catch (InterruptedException success) {}
212	jsr166	1.7	assertFalse(Thread.interrupted());
213	jsr166	1.1	}});
214
215			barrier.await();
216	jsr166	1.7	long startTime = System.nanoTime();
217			assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
218			assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
219
220	jsr166	1.1	barrier.await();
221	jsr166	1.7	assertThreadStaysAlive(t);
222	jsr166	1.1	t.interrupt();
223	jsr166	1.7	awaitTermination(t);
224	jsr166	1.1	}
225
226	jsr166	1.2	/**
227	jsr166	1.3	* take() blocks interruptibly when empty
228	jsr166	1.2	*/
229	jsr166	1.7	public void testTakeFromEmptyBlocksInterruptibly() {
230	jsr166	1.2	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	jsr166	1.7	assertFalse(Thread.interrupted());
240	jsr166	1.2	}});
241	jsr166	1.3
242	jsr166	1.7	await(threadStarted);
243			assertThreadStaysAlive(t);
244	jsr166	1.2	t.interrupt();
245	jsr166	1.7	awaitTermination(t);
246	jsr166	1.3	}
247
248			/**
249			* take() throws InterruptedException immediately if interrupted
250			* before waiting
251			*/
252	jsr166	1.7	public void testTakeFromEmptyAfterInterrupt() {
253	jsr166	1.3	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	jsr166	1.7	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	jsr166	1.3	}});
304
305	jsr166	1.7	awaitTermination(t);
306	jsr166	1.2	}
307
308	jsr166	1.1	/** For debugging. */
309			public void XXXXtestFails() {
310			fail(emptyCollection().getClass().toString());
311			}
312
313			}