[cvs] / jsr166 / src / test / tck / ArrayBlockingQueueTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/ArrayBlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.21, Sat Nov 21 19:11:53 2009 UTC revision 1.37, Thu Oct 28 22:20:47 2010 UTC
# Line 14  Line 14 
14  import java.io.*;  import java.io.*;
15    
16  public class ArrayBlockingQueueTest extends JSR166TestCase {  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) {      public static void main(String[] args) {
31          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
32      }      }
33    
34      public static Test suite() {      public static Test suite() {
35          return new TestSuite(ArrayBlockingQueueTest.class);          return newTestSuite(ArrayBlockingQueueTest.class,
36                                new Fair().testSuite(),
37                                new NonFair().testSuite());
38      }      }
39    
40      /**      /**
# Line 224  Line 240 
240              shouldThrow();              shouldThrow();
241          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
242      }      }
243    
244      /**      /**
245       * addAll of a collection with any null elements throws NPE after       * addAll of a collection with any null elements throws NPE after
246       * possibly adding some elements       * possibly adding some elements
# Line 238  Line 255 
255              shouldThrow();              shouldThrow();
256          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
257      }      }
258    
259      /**      /**
260       * addAll throws ISE if not enough room       * addAll throws ISE if not enough room
261       */       */
# Line 251  Line 269 
269              shouldThrow();              shouldThrow();
270          } catch (IllegalStateException success) {}          } catch (IllegalStateException success) {}
271      }      }
272    
273      /**      /**
274       * Queue contains all elements, in traversal order, of successful addAll       * Queue contains all elements, in traversal order, of successful addAll
275       */       */
# Line 296  Line 315 
315      public void testBlockingPut() throws InterruptedException {      public void testBlockingPut() throws InterruptedException {
316          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
317          Thread t = new Thread(new CheckedRunnable() {          Thread t = new Thread(new CheckedRunnable() {
318              public void realRun() {              public void realRun() throws InterruptedException {
319                  int added = 0;                  for (int i = 0; i < SIZE; ++i)
320                        q.put(i);
321                    assertEquals(SIZE, q.size());
322                    assertEquals(0, q.remainingCapacity());
323                  try {                  try {
324                      for (int i = 0; i < SIZE; ++i) {                      q.put(99);
325                          q.put(new Integer(i));                      shouldThrow();
326                          ++added;                  } catch (InterruptedException success) {}
327                      }              }});
                     q.put(new Integer(SIZE));  
                     threadShouldThrow();  
                 } catch (InterruptedException success) {  
                     threadAssertEquals(added, SIZE);  
                 }}});  
328    
329          t.start();          t.start();
330          Thread.sleep(MEDIUM_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
331          t.interrupt();          t.interrupt();
332          t.join();          t.join();
333            assertEquals(SIZE, q.size());
334            assertEquals(0, q.remainingCapacity());
335      }      }
336    
337      /**      /**
338       * put blocks waiting for take when full       * put blocks waiting for take when full
339       */       */
340      public void testPutWithTake() throws InterruptedException {      public void testPutWithTake() throws InterruptedException {
341          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final int capacity = 2;
342            final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
343          Thread t = new Thread(new CheckedRunnable() {          Thread t = new Thread(new CheckedRunnable() {
344              public void realRun() {              public void realRun() throws InterruptedException {
345                  int added = 0;                  for (int i = 0; i < capacity + 1; i++)
346                        q.put(i);
347                  try {                  try {
348                      q.put(new Object());                      q.put(99);
349                      ++added;                      shouldThrow();
350                      q.put(new Object());                  } catch (InterruptedException success) {}
                     ++added;  
                     q.put(new Object());  
                     ++added;  
                     q.put(new Object());  
                     ++added;  
                     threadShouldThrow();  
                 } catch (InterruptedException success) {  
                     threadAssertTrue(added >= 2);  
                 }  
351              }});              }});
352    
353          t.start();          t.start();
354          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
355          q.take();          assertEquals(q.remainingCapacity(), 0);
356            assertEquals(0, q.take());
357            Thread.sleep(SHORT_DELAY_MS);
358          t.interrupt();          t.interrupt();
359          t.join();          t.join();
360            assertEquals(q.remainingCapacity(), 0);
361      }      }
362    
363      /**      /**
# Line 350  Line 365 
365       */       */
366      public void testTimedOffer() throws InterruptedException {      public void testTimedOffer() throws InterruptedException {
367          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);          final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
368          Thread t = new ThreadShouldThrow(InterruptedException.class) {          Thread t = new Thread(new CheckedRunnable() {
369              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
370                  q.put(new Object());                  q.put(new Object());
371                  q.put(new Object());                  q.put(new Object());
372                  threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));                  assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, MILLISECONDS));
373                    try {
374                  q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);                  q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
375              }};                      shouldThrow();
376                    } catch (InterruptedException success) {}
377                }});
378    
379          t.start();          t.start();
380          Thread.sleep(SHORT_DELAY_MS);          Thread.sleep(SHORT_DELAY_MS);
# Line 370  Line 388 
388      public void testTake() throws InterruptedException {      public void testTake() throws InterruptedException {
389          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
390          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
391              assertEquals(i, ((Integer)q.take()).intValue());              assertEquals(i, q.take());
392          }          }
393      }      }
394    
395      /**      /**
      * take blocks interruptibly when empty  
      */  
     public void testTakeFromEmpty() throws InterruptedException {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new ThreadShouldThrow(InterruptedException.class) {  
             public void realRun() throws InterruptedException {  
                 q.take();  
             }};  
   
         t.start();  
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
     }  
   
     /**  
396       * Take removes existing elements until empty, then blocks interruptibly       * Take removes existing elements until empty, then blocks interruptibly
397       */       */
398      public void testBlockingTake() throws InterruptedException {      public void testBlockingTake() throws InterruptedException {
399          Thread t = new ThreadShouldThrow(InterruptedException.class) {          final ArrayBlockingQueue q = populatedQueue(SIZE);
400            Thread t = new Thread(new CheckedRunnable() {
401              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
                 ArrayBlockingQueue q = populatedQueue(SIZE);  
402                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
403                      threadAssertEquals(i, ((Integer)q.take()).intValue());                      assertEquals(i, q.take());
404                  }                  }
405                    try {
406                  q.take();                  q.take();
407              }};                      shouldThrow();
408                    } catch (InterruptedException success) {}
409                }});
410    
411          t.start();          t.start();
412              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
# Line 416  Line 421 
421      public void testPoll() {      public void testPoll() {
422          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
423          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
424              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, q.poll());
425          }          }
426          assertNull(q.poll());          assertNull(q.poll());
427      }      }
428    
429      /**      /**
430       * timed pool with zero timeout succeeds when non-empty, else times out       * timed poll with zero timeout succeeds when non-empty, else times out
431       */       */
432      public void testTimedPoll0() throws InterruptedException {      public void testTimedPoll0() throws InterruptedException {
433          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
434          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
435              assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());              assertEquals(i, q.poll(0, MILLISECONDS));
436          }          }
437          assertNull(q.poll(0, MILLISECONDS));          assertNull(q.poll(0, MILLISECONDS));
438      }      }
439    
440      /**      /**
441       * timed pool with nonzero timeout succeeds when non-empty, else times out       * timed poll with nonzero timeout succeeds when non-empty, else times out
442       */       */
443      public void testTimedPoll() throws InterruptedException {      public void testTimedPoll() throws InterruptedException {
444          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
445          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
446              assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());              assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
447          }          }
448          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
449      }      }
# Line 452  Line 457 
457              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
458                  ArrayBlockingQueue q = populatedQueue(SIZE);                  ArrayBlockingQueue q = populatedQueue(SIZE);
459                  for (int i = 0; i < SIZE; ++i) {                  for (int i = 0; i < SIZE; ++i) {
460                      assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());                      assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));;
461                  }                  }
462                  try {                  try {
463                      q.poll(SMALL_DELAY_MS, MILLISECONDS);                      q.poll(SMALL_DELAY_MS, MILLISECONDS);
464                        shouldThrow();
465                  } catch (InterruptedException success) {}                  } catch (InterruptedException success) {}
466              }});              }});
467    
# Line 466  Line 472 
472      }      }
473    
474      /**      /**
      *  timed poll before a delayed offer fails; after offer succeeds;  
      *  on interruption throws  
      */  
     public void testTimedPollWithOffer() throws InterruptedException {  
         final ArrayBlockingQueue q = new ArrayBlockingQueue(2);  
         Thread t = new ThreadShouldThrow(InterruptedException.class) {  
             public void realRun() throws InterruptedException {  
                 threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));  
                 q.poll(LONG_DELAY_MS, MILLISECONDS);  
                 q.poll(LONG_DELAY_MS, MILLISECONDS);  
             }};  
   
         t.start();  
         Thread.sleep(SMALL_DELAY_MS);  
         assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));  
         t.interrupt();  
         t.join();  
     }  
   
   
     /**  
475       * peek returns next element, or null if empty       * peek returns next element, or null if empty
476       */       */
477      public void testPeek() {      public void testPeek() {
478          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
480              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, q.peek());
481              q.poll();              assertEquals(i, q.poll());
482              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
483                         i != ((Integer)q.peek()).intValue());                         !q.peek().equals(i));
484          }          }
485          assertNull(q.peek());          assertNull(q.peek());
486      }      }
# Line 506  Line 491 
491      public void testElement() {      public void testElement() {
492          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
493          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
494              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, q.element());
495              q.poll();              assertEquals(i, q.poll());
496          }          }
497          try {          try {
498              q.element();              q.element();
# Line 521  Line 506 
506      public void testRemove() {      public void testRemove() {
507          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
508          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
509              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, q.remove());
510          }          }
511          try {          try {
512              q.remove();              q.remove();
# Line 551  Line 536 
536          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
537          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
538              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
539              q.poll();              assertEquals(i, q.poll());
540              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
541          }          }
542      }      }
# Line 646  Line 631 
631       * toArray(null) throws NPE       * toArray(null) throws NPE
632       */       */
633      public void testToArray_BadArg() {      public void testToArray_BadArg() {
         try {  
634              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
635            try {
636              Object o[] = q.toArray(null);              Object o[] = q.toArray(null);
637              shouldThrow();              shouldThrow();
638          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
# Line 657  Line 642 
642       * toArray with incompatible array type throws CCE       * toArray with incompatible array type throws CCE
643       */       */
644      public void testToArray1_BadArg() {      public void testToArray1_BadArg() {
         try {  
645              ArrayBlockingQueue q = populatedQueue(SIZE);              ArrayBlockingQueue q = populatedQueue(SIZE);
646            try {
647              Object o[] = q.toArray(new String[10] );              Object o[] = q.toArray(new String[10] );
648              shouldThrow();              shouldThrow();
649          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
# Line 690  Line 675 
675          it.remove();          it.remove();
676    
677          it = q.iterator();          it = q.iterator();
678          assertEquals(it.next(), one);          assertSame(it.next(), one);
679          assertEquals(it.next(), three);          assertSame(it.next(), three);
680          assertFalse(it.hasNext());          assertFalse(it.hasNext());
681      }      }
682    
# Line 708  Line 693 
693    
694          int k = 0;          int k = 0;
695          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
696              int i = ((Integer)(it.next())).intValue();              assertEquals(++k, it.next());
             assertEquals(++k, i);  
697          }          }
698          assertEquals(3, k);          assertEquals(3, k);
699      }      }
# Line 752  Line 736 
736          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
737          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
738              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
739                  threadAssertFalse(q.offer(three));                  assertFalse(q.offer(three));
740                  threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));                  assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
741                  threadAssertEquals(0, q.remainingCapacity());                  assertEquals(0, q.remainingCapacity());
742              }});              }});
743    
744          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
745              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
746                  Thread.sleep(SMALL_DELAY_MS);                  Thread.sleep(SMALL_DELAY_MS);
747                  threadAssertEquals(one, q.take());                  assertSame(one, q.take());
748              }});              }});
749    
750          joinPool(executor);          joinPool(executor);
   
751      }      }
752    
753      /**      /**
# Line 775  Line 758 
758          ExecutorService executor = Executors.newFixedThreadPool(2);          ExecutorService executor = Executors.newFixedThreadPool(2);
759          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
760              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
761                  threadAssertNull(q.poll());                  assertNull(q.poll());
762                  threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));                  assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
763                  threadAssertTrue(q.isEmpty());                  assertTrue(q.isEmpty());
764              }});              }});
765    
766          executor.execute(new CheckedRunnable() {          executor.execute(new CheckedRunnable() {
# Line 897  Line 880 
880      }      }
881    
882      /**      /**
883       * drainTo(c, n) empties first max {n, size} elements of queue into c       * drainTo(c, n) empties first min(n, size) elements of queue into c
884       */       */
885      public void testDrainToN() {      public void testDrainToN() {
886          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE*2);

Legend:
Removed from v.1.21  
changed lines
  Added in v.1.37

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8