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);
    }

    /**
     * remove(x) removes x and returns true if present
     * TODO: move to superclass CollectionTest.java
     */
    public void testRemoveElement() {
        final BlockingQueue q = emptyCollection();
        final int size = Math.min(q.remainingCapacity(), SIZE);
        final Object[] elts = new Object[size];
        assertFalse(q.contains(makeElement(99)));
        assertFalse(q.remove(makeElement(99)));
        checkEmpty(q);
        for (int i = 0; i < size; i++)
            q.add(elts[i] = makeElement(i));
        for (int i = 1; i < size; i+=2) {
            for (int pass = 0; pass < 2; pass++) {
                assertEquals((pass == 0), q.contains(elts[i]));
                assertEquals((pass == 0), q.remove(elts[i]));
                assertFalse(q.contains(elts[i]));
                assertTrue(q.contains(elts[i-1]));
                if (i < size - 1)
                    assertTrue(q.contains(elts[i+1]));
            }
        }
        if (size > 0)
            assertTrue(q.contains(elts[0]));
        for (int i = size-2; i >= 0; i-=2) {
            assertTrue(q.contains(elts[i]));
            assertFalse(q.contains(elts[i+1]));
            assertTrue(q.remove(elts[i]));
            assertFalse(q.contains(elts[i]));
            assertFalse(q.remove(elts[i+1]));
            assertFalse(q.contains(elts[i+1]));
        }
        checkEmpty(q);
    }

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

}
Revision:	1.12
Committed:	Fri Jul 15 18:49:31 2011 UTC (12 years, 10 months ago) by jsr166
Branch:	MAIN
Changes since 1.11:	+36 -0 lines
Log Message:	Robust weak consistency for ArrayBlockingQueue iterators
#	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.11	* drainTo(c, n) returns 0 and does nothing when n <= 0
185	jsr166	1.10	*/
186	jsr166	1.11	public void testDrainToNonPositiveMaxElements() {
187	jsr166	1.10	final BlockingQueue q = emptyCollection();
188	jsr166	1.11	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	jsr166	1.10	Object one = makeElement(1);
194			q.add(one);
195			ArrayList c = new ArrayList();
196	jsr166	1.11	for (int n : ns)
197			assertEquals(0, q.drainTo(new ArrayList(), n));
198	jsr166	1.10	assertEquals(1, q.size());
199			assertSame(one, q.poll());
200			assertTrue(c.isEmpty());
201			}
202			}
203
204			/**
205	jsr166	1.7	* timed poll before a delayed offer times out; after offer succeeds;
206	jsr166	1.1	* on interruption throws
207			*/
208			public void testTimedPollWithOffer() throws InterruptedException {
209			final BlockingQueue q = emptyCollection();
210			final CheckedBarrier barrier = new CheckedBarrier(2);
211	jsr166	1.8	final Object zero = makeElement(0);
212	jsr166	1.1	Thread t = newStartedThread(new CheckedRunnable() {
213			public void realRun() throws InterruptedException {
214	jsr166	1.7	long startTime = System.nanoTime();
215			assertNull(q.poll(timeoutMillis(), MILLISECONDS));
216			assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
217	jsr166	1.1
218			barrier.await();
219	jsr166	1.7
220			assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
221	jsr166	1.1
222			Thread.currentThread().interrupt();
223			try {
224	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
225	jsr166	1.1	shouldThrow();
226			} catch (InterruptedException success) {}
227	jsr166	1.7	assertFalse(Thread.interrupted());
228	jsr166	1.1
229			barrier.await();
230			try {
231	jsr166	1.7	q.poll(LONG_DELAY_MS, MILLISECONDS);
232	jsr166	1.1	shouldThrow();
233			} catch (InterruptedException success) {}
234	jsr166	1.7	assertFalse(Thread.interrupted());
235	jsr166	1.1	}});
236
237			barrier.await();
238	jsr166	1.7	long startTime = System.nanoTime();
239			assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
240			assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
241
242	jsr166	1.1	barrier.await();
243	jsr166	1.7	assertThreadStaysAlive(t);
244	jsr166	1.1	t.interrupt();
245	jsr166	1.7	awaitTermination(t);
246	jsr166	1.1	}
247
248	jsr166	1.2	/**
249	jsr166	1.3	* take() blocks interruptibly when empty
250	jsr166	1.2	*/
251	jsr166	1.7	public void testTakeFromEmptyBlocksInterruptibly() {
252	jsr166	1.2	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	jsr166	1.7	assertFalse(Thread.interrupted());
262	jsr166	1.2	}});
263	jsr166	1.3
264	jsr166	1.7	await(threadStarted);
265			assertThreadStaysAlive(t);
266	jsr166	1.2	t.interrupt();
267	jsr166	1.7	awaitTermination(t);
268	jsr166	1.3	}
269
270			/**
271			* take() throws InterruptedException immediately if interrupted
272			* before waiting
273			*/
274	jsr166	1.7	public void testTakeFromEmptyAfterInterrupt() {
275	jsr166	1.3	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	jsr166	1.7	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	jsr166	1.3	}});
326
327	jsr166	1.7	awaitTermination(t);
328	jsr166	1.2	}
329
330	jsr166	1.12	/**
331			* remove(x) removes x and returns true if present
332			* TODO: move to superclass CollectionTest.java
333			*/
334			public void testRemoveElement() {
335			final BlockingQueue q = emptyCollection();
336			final int size = Math.min(q.remainingCapacity(), SIZE);
337			final Object[] elts = new Object[size];
338			assertFalse(q.contains(makeElement(99)));
339			assertFalse(q.remove(makeElement(99)));
340			checkEmpty(q);
341			for (int i = 0; i < size; i++)
342			q.add(elts[i] = makeElement(i));
343			for (int i = 1; i < size; i+=2) {
344			for (int pass = 0; pass < 2; pass++) {
345			assertEquals((pass == 0), q.contains(elts[i]));
346			assertEquals((pass == 0), q.remove(elts[i]));
347			assertFalse(q.contains(elts[i]));
348			assertTrue(q.contains(elts[i-1]));
349			if (i < size - 1)
350			assertTrue(q.contains(elts[i+1]));
351			}
352			}
353			if (size > 0)
354			assertTrue(q.contains(elts[0]));
355			for (int i = size-2; i >= 0; i-=2) {
356			assertTrue(q.contains(elts[i]));
357			assertFalse(q.contains(elts[i+1]));
358			assertTrue(q.remove(elts[i]));
359			assertFalse(q.contains(elts[i]));
360			assertFalse(q.remove(elts[i+1]));
361			assertFalse(q.contains(elts[i+1]));
362			}
363			checkEmpty(q);
364			}
365
366	jsr166	1.1	/** For debugging. */
367			public void XXXXtestFails() {
368			fail(emptyCollection().getClass().toString());
369			}
370
371			}