ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/BlockingQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/BlockingQueueTest.java (file contents):
Revision 1.11 by jsr166, Tue Jun 14 04:30:06 2011 UTC vs.
Revision 1.25 by dl, Tue Jan 26 13:33:05 2021 UTC

# Line 7 | Line 7
7   * Pat Fisher, Mike Judd.
8   */
9  
10 < import junit.framework.*;
10 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 >
12   import java.util.ArrayList;
13   import java.util.Arrays;
14   import java.util.Collection;
15   import java.util.Queue;
16   import java.util.concurrent.BlockingQueue;
17   import java.util.concurrent.CountDownLatch;
18 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
18 >
19 > import junit.framework.Test;
20 > import junit.framework.TestSuite;
21  
22   /**
23   * Contains "contract" tests applicable to all BlockingQueue implementations.
# Line 49 | Line 52 | public abstract class BlockingQueueTest
52       * Override for collections with unusual element types.
53       */
54      protected Object makeElement(int i) {
55 <        return Integer.valueOf(i);
55 >        return JSR166TestCase.itemFor(i);
56      }
57  
58      //----------------------------------------------------------------
# Line 103 | Line 106 | public abstract class BlockingQueueTest
106      }
107  
108      /**
109 <     * put(null) throws NullPointerException
109 >     * addAll(null) throws NullPointerException
110       */
111      public void testAddAllNull() throws InterruptedException {
112          final Collection q = emptyCollection();
# Line 118 | Line 121 | public abstract class BlockingQueueTest
121       */
122      public void testAddAllNullElements() {
123          final Collection q = emptyCollection();
124 <        final Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
124 >        final Collection elements = Arrays.asList(new Item[SIZE]);
125          try {
126              q.addAll(elements);
127              shouldThrow();
# Line 131 | Line 134 | public abstract class BlockingQueueTest
134      public void testToArray_NullArray() {
135          final Collection q = emptyCollection();
136          try {
137 <            q.toArray(null);
137 >            q.toArray((Object[])null);
138              shouldThrow();
139          } catch (NullPointerException success) {}
140      }
# Line 186 | Line 189 | public abstract class BlockingQueueTest
189      public void testDrainToNonPositiveMaxElements() {
190          final BlockingQueue q = emptyCollection();
191          final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
192 <        for (int n : ns)
193 <            assertEquals(0, q.drainTo(new ArrayList(), n));
192 >        final ArrayList sink = new ArrayList();
193 >        for (int n : ns) {
194 >            assertEquals(0, q.drainTo(sink, n));
195 >            assertTrue(sink.isEmpty());
196 >        }
197          if (q.remainingCapacity() > 0) {
198              // Not SynchronousQueue, that is
199 <            Object one = makeElement(1);
200 <            q.add(one);
201 <            ArrayList c = new ArrayList();
202 <            for (int n : ns)
203 <                assertEquals(0, q.drainTo(new ArrayList(), n));
204 <            assertEquals(1, q.size());
205 <            assertSame(one, q.poll());
206 <            assertTrue(c.isEmpty());
199 >            Object e = makeElement(1);
200 >            if (q.add(e)) {
201 >                for (int n : ns)
202 >                    assertEquals(0, q.drainTo(sink, n));
203 >                assertEquals(1, q.size());
204 >                assertEquals(e, q.poll());
205 >                assertTrue(sink.isEmpty());
206 >            }
207          }
208      }
209  
# Line 221 | Line 227 | public abstract class BlockingQueueTest
227  
228                  Thread.currentThread().interrupt();
229                  try {
230 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
230 >                    q.poll(randomTimeout(), randomTimeUnit());
231                      shouldThrow();
232                  } catch (InterruptedException success) {}
233                  assertFalse(Thread.interrupted());
# Line 232 | Line 238 | public abstract class BlockingQueueTest
238                      shouldThrow();
239                  } catch (InterruptedException success) {}
240                  assertFalse(Thread.interrupted());
241 +
242 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
243              }});
244  
245          barrier.await();
# Line 240 | Line 248 | public abstract class BlockingQueueTest
248          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
249  
250          barrier.await();
251 <        assertThreadStaysAlive(t);
251 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
252          t.interrupt();
253          awaitTermination(t);
254      }
# Line 262 | Line 270 | public abstract class BlockingQueueTest
270              }});
271  
272          await(threadStarted);
273 <        assertThreadStaysAlive(t);
273 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
274          t.interrupt();
275          awaitTermination(t);
276      }
# Line 291 | Line 299 | public abstract class BlockingQueueTest
299       */
300      public void testTimedPollFromEmptyBlocksInterruptibly() {
301          final BlockingQueue q = emptyCollection();
302 <        final CountDownLatch threadStarted = new CountDownLatch(1);
302 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
303          Thread t = newStartedThread(new CheckedRunnable() {
304              public void realRun() {
305 <                threadStarted.countDown();
305 >                pleaseInterrupt.countDown();
306                  try {
307 <                    q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
307 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
308                      shouldThrow();
309                  } catch (InterruptedException success) {}
310                  assertFalse(Thread.interrupted());
311              }});
312  
313 <        await(threadStarted);
314 <        assertThreadStaysAlive(t);
313 >        await(pleaseInterrupt);
314 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
315          t.interrupt();
316          awaitTermination(t);
317      }
# Line 318 | Line 326 | public abstract class BlockingQueueTest
326              public void realRun() {
327                  Thread.currentThread().interrupt();
328                  try {
329 <                    q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
329 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
330                      shouldThrow();
331                  } catch (InterruptedException success) {}
332                  assertFalse(Thread.interrupted());
# Line 327 | Line 335 | public abstract class BlockingQueueTest
335          awaitTermination(t);
336      }
337  
338 +    /**
339 +     * remove(x) removes x and returns true if present
340 +     * TODO: move to superclass CollectionTest.java
341 +     */
342 +    public void testRemoveElement() {
343 +        final BlockingQueue q = emptyCollection();
344 +        final int size = Math.min(q.remainingCapacity(), SIZE);
345 +        final Object[] elts = new Object[size];
346 +        assertFalse(q.contains(makeElement(99)));
347 +        assertFalse(q.remove(makeElement(99)));
348 +        checkEmpty(q);
349 +        for (int i = 0; i < size; i++)
350 +            q.add(elts[i] = makeElement(i));
351 +        for (int i = 1; i < size; i += 2) {
352 +            for (int pass = 0; pass < 2; pass++) {
353 +                mustEqual((pass == 0), q.contains(elts[i]));
354 +                mustEqual((pass == 0), q.remove(elts[i]));
355 +                assertFalse(q.contains(elts[i]));
356 +                assertTrue(q.contains(elts[i - 1]));
357 +                if (i < size - 1)
358 +                    assertTrue(q.contains(elts[i + 1]));
359 +            }
360 +        }
361 +        if (size > 0)
362 +            assertTrue(q.contains(elts[0]));
363 +        for (int i = size - 2; i >= 0; i -= 2) {
364 +            assertTrue(q.contains(elts[i]));
365 +            assertFalse(q.contains(elts[i + 1]));
366 +            assertTrue(q.remove(elts[i]));
367 +            assertFalse(q.contains(elts[i]));
368 +            assertFalse(q.remove(elts[i + 1]));
369 +            assertFalse(q.contains(elts[i + 1]));
370 +        }
371 +        checkEmpty(q);
372 +    }
373 +
374      /** For debugging. */
375      public void XXXXtestFails() {
376          fail(emptyCollection().getClass().toString());

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines