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.9 by jsr166, Mon May 30 23:51:08 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 48 | 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 102 | 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 117 | 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 130 | 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 180 | Line 184 | public abstract class BlockingQueueTest
184      }
185  
186      /**
187 +     * drainTo(c, n) returns 0 and does nothing when n <= 0
188 +     */
189 +    public void testDrainToNonPositiveMaxElements() {
190 +        final BlockingQueue q = emptyCollection();
191 +        final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
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 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 +
210 +    /**
211       * timed poll before a delayed offer times out; after offer succeeds;
212       * on interruption throws
213       */
# Line 199 | 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 210 | 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 218 | 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 240 | 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 269 | 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 296 | 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 305 | 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