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

Comparing jsr166/src/test/tck/ArrayBlockingQueueTest.java (file contents):
Revision 1.30 by jsr166, Wed Aug 25 01:44:48 2010 UTC vs.
Revision 1.36 by jsr166, Thu Oct 28 17:57:26 2010 UTC

# Line 14 | Line 14 | import static java.util.concurrent.TimeU
14   import java.io.*;
15  
16   public class ArrayBlockingQueueTest extends JSR166TestCase {
17 +
18 +    public static class Fair extends BlockingQueueTest {
19 +        protected BlockingQueue emptyCollection() {
20 +            return new ArrayBlockingQueue(20, true);
21 +        }
22 +    }
23 +
24 +    public static class NonFair extends BlockingQueueTest {
25 +        protected BlockingQueue emptyCollection() {
26 +            return new ArrayBlockingQueue(20, false);
27 +        }
28 +    }
29 +
30      public static void main(String[] args) {
31          junit.textui.TestRunner.run(suite());
32      }
33 +
34      public static Test suite() {
35 <        return new TestSuite(ArrayBlockingQueueTest.class);
35 >        return newTestSuite(ArrayBlockingQueueTest.class,
36 >                            new Fair().testSuite(),
37 >                            new NonFair().testSuite());
38      }
39  
40      /**
# Line 145 | Line 161 | public class ArrayBlockingQueueTest exte
161      }
162  
163      /**
164 <     *  offer(null) throws NPE
164 >     * offer(null) throws NPE
165       */
166      public void testOfferNull() {
167          try {
# Line 156 | Line 172 | public class ArrayBlockingQueueTest exte
172      }
173  
174      /**
175 <     *  add(null) throws NPE
175 >     * add(null) throws NPE
176       */
177      public void testAddNull() {
178          try {
# Line 191 | Line 207 | public class ArrayBlockingQueueTest exte
207      }
208  
209      /**
210 <     *  addAll(null) throws NPE
210 >     * addAll(null) throws NPE
211       */
212      public void testAddAll1() {
213          try {
# Line 214 | Line 230 | public class ArrayBlockingQueueTest exte
230  
231  
232      /**
233 <     *  addAll of a collection with null elements throws NPE
233 >     * addAll of a collection with null elements throws NPE
234       */
235      public void testAddAll2() {
236          try {
# Line 270 | Line 286 | public class ArrayBlockingQueueTest exte
286      }
287  
288      /**
289 <     *  put(null) throws NPE
289 >     * put(null) throws NPE
290       */
291      public void testPutNull() throws InterruptedException {
292          try {
# Line 377 | Line 393 | public class ArrayBlockingQueueTest exte
393      }
394  
395      /**
380 –     * take blocks interruptibly when empty
381 –     */
382 –    public void testTakeFromEmpty() throws InterruptedException {
383 –        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
384 –        Thread t = new ThreadShouldThrow(InterruptedException.class) {
385 –            public void realRun() throws InterruptedException {
386 –                q.take();
387 –            }};
388 –
389 –        t.start();
390 –        Thread.sleep(SHORT_DELAY_MS);
391 –        t.interrupt();
392 –        t.join();
393 –    }
394 –
395 –    /**
396       * Take removes existing elements until empty, then blocks interruptibly
397       */
398      public void testBlockingTake() throws InterruptedException {
# Line 472 | Line 472 | public class ArrayBlockingQueueTest exte
472      }
473  
474      /**
475 –     *  timed poll before a delayed offer fails; after offer succeeds;
476 –     *  on interruption throws
477 –     */
478 –    public void testTimedPollWithOffer() throws InterruptedException {
479 –        final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
480 –        Thread t = new Thread(new CheckedRunnable() {
481 –            public void realRun() throws InterruptedException {
482 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
483 –                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
484 –                try {
485 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
486 –                    shouldThrow();
487 –                } catch (InterruptedException success) {}
488 –            }});
489 –
490 –        t.start();
491 –        Thread.sleep(SMALL_DELAY_MS);
492 –        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
493 –        t.interrupt();
494 –        t.join();
495 –    }
496 –
497 –
498 –    /**
475       * peek returns next element, or null if empty
476       */
477      public void testPeek() {
# Line 631 | Line 607 | public class ArrayBlockingQueueTest exte
607      }
608  
609      /**
610 <     *  toArray contains all elements
610 >     * toArray contains all elements
611       */
612      public void testToArray() throws InterruptedException {
613          ArrayBlockingQueue q = populatedQueue(SIZE);
# Line 904 | Line 880 | public class ArrayBlockingQueueTest exte
880      }
881  
882      /**
883 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
883 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
884       */
885      public void testDrainToN() {
886          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);
# Line 913 | Line 889 | public class ArrayBlockingQueueTest exte
889                  assertTrue(q.offer(new Integer(j)));
890              ArrayList l = new ArrayList();
891              q.drainTo(l, i);
892 <            int k = (i < SIZE)? i : SIZE;
892 >            int k = (i < SIZE) ? i : SIZE;
893              assertEquals(l.size(), k);
894              assertEquals(q.size(), SIZE-k);
895              for (int j = 0; j < k; ++j)

Diff Legend

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