[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.73, Mon Oct 17 01:52:04 2016 UTC revision 1.74, Sun Oct 30 21:07:27 2016 UTC
# Line 19  Line 19 
19  import java.util.concurrent.CountDownLatch;  import java.util.concurrent.CountDownLatch;
20  import java.util.concurrent.Executors;  import java.util.concurrent.Executors;
21  import java.util.concurrent.ExecutorService;  import java.util.concurrent.ExecutorService;
22    import java.util.concurrent.ThreadLocalRandom;
23    
24  import junit.framework.Test;  import junit.framework.Test;
25    
# Line 600  Line 601 
601          }          }
602      }      }
603    
604      void checkToArray(ArrayBlockingQueue q) {      void checkToArray(ArrayBlockingQueue<Integer> q) {
605          int size = q.size();          int size = q.size();
606          Object[] o = q.toArray();          Object[] a1 = q.toArray();
607          assertEquals(size, o.length);          assertEquals(size, a1.length);
608            Integer[] a2 = q.toArray(new Integer[0]);
609            assertEquals(size, a2.length);
610            Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
611            assertEquals(size, a3.length);
612            Integer[] a4 = new Integer[size];
613            assertSame(a4, q.toArray(a4));
614            Integer[] a5 = new Integer[size + 1];
615            Arrays.fill(a5, 42);
616            assertSame(a5, q.toArray(a5));
617            Integer[] a6 = new Integer[size + 2];
618            Arrays.fill(a6, 42);
619            assertSame(a6, q.toArray(a6));
620            Object[][] as = { a1, a2, a3, a4, a5, a6 };
621            for (Object[] a : as) {
622                if (a.length > size) assertNull(a[size]);
623                if (a.length > size + 1) assertEquals(42, a[size + 1]);
624            }
625          Iterator it = q.iterator();          Iterator it = q.iterator();
626            Integer s = q.peek();
627          for (int i = 0; i < size; i++) {          for (int i = 0; i < size; i++) {
628              Integer x = (Integer) it.next();              Integer x = (Integer) it.next();
629              assertEquals((Integer)o[0] + i, (int) x);              assertEquals(s + i, (int) x);
630              assertSame(o[i], x);              for (Object[] a : as)
631                    assertSame(a1[i], x);
632          }          }
633      }      }
634    
635      /**      /**
636       * toArray() contains all elements in FIFO order       * toArray() and toArray(a) contain all elements in FIFO order
637       */       */
638      public void testToArray() {      public void testToArray() {
639          ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);          final ThreadLocalRandom rnd = ThreadLocalRandom.current();
640          for (int i = 0; i < SIZE; i++) {          final int size = rnd.nextInt(6);
641            final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
642            ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
643            for (int i = 0; i < size; i++) {
644              checkToArray(q);              checkToArray(q);
645              q.add(i);              q.add(i);
646          }          }
647          // Provoke wraparound          // Provoke wraparound
648          for (int i = 0; i < SIZE; i++) {          int added = size * 2;
649              checkToArray(q);          for (int i = 0; i < added; i++) {
             assertEquals(i, q.poll());  
             checkToArray(q);  
             q.add(SIZE + i);  
         }  
         for (int i = 0; i < SIZE; i++) {  
650              checkToArray(q);              checkToArray(q);
651              assertEquals(SIZE + i, q.poll());              assertEquals((Integer) i, q.poll());
652          }              q.add(size + i);
653      }      }
   
     void checkToArray2(ArrayBlockingQueue q) {  
         int size = q.size();  
         Integer[] a1 = (size == 0) ? null : new Integer[size - 1];  
         Integer[] a2 = new Integer[size];  
         Integer[] a3 = new Integer[size + 2];  
         if (size > 0) Arrays.fill(a1, 42);  
         Arrays.fill(a2, 42);  
         Arrays.fill(a3, 42);  
         Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);  
         Integer[] b2 = (Integer[]) q.toArray(a2);  
         Integer[] b3 = (Integer[]) q.toArray(a3);  
         assertSame(a2, b2);  
         assertSame(a3, b3);  
         Iterator it = q.iterator();  
654          for (int i = 0; i < size; i++) {          for (int i = 0; i < size; i++) {
655              Integer x = (Integer) it.next();              checkToArray(q);
656              assertSame(b1[i], x);              assertEquals((Integer) (added + i), q.poll());
             assertEquals(b1[0] + i, (int) x);  
             assertSame(b2[i], x);  
             assertSame(b3[i], x);  
         }  
         assertNull(a3[size]);  
         assertEquals(42, (int) a3[size + 1]);  
         if (size > 0) {  
             assertNotSame(a1, b1);  
             assertEquals(size, b1.length);  
             for (int i = 0; i < a1.length; i++) {  
                 assertEquals(42, (int) a1[i]);  
             }  
         }  
     }  
   
     /**  
      * toArray(a) contains all elements in FIFO order  
      */  
     public void testToArray2() {  
         ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);  
         for (int i = 0; i < SIZE; i++) {  
             checkToArray2(q);  
             q.add(i);  
         }  
         // Provoke wraparound  
         for (int i = 0; i < SIZE; i++) {  
             checkToArray2(q);  
             assertEquals(i, q.poll());  
             checkToArray2(q);  
             q.add(SIZE + i);  
         }  
         for (int i = 0; i < SIZE; i++) {  
             checkToArray2(q);  
             assertEquals(SIZE + i, q.poll());  
657          }          }
658      }      }
659    
660      /**      /**
661       * toArray(incompatible array type) throws ArrayStoreException       * toArray(incompatible array type) throws ArrayStoreException
662       */       */
663      public void testToArray1_BadArg() {      public void testToArray_incompatibleArrayType() {
664          ArrayBlockingQueue q = populatedQueue(SIZE);          ArrayBlockingQueue q = populatedQueue(SIZE);
665          try {          try {
666              q.toArray(new String[10]);              q.toArray(new String[10]);
667              shouldThrow();              shouldThrow();
668          } catch (ArrayStoreException success) {}          } catch (ArrayStoreException success) {}
669            try {
670                q.toArray(new String[0]);
671                shouldThrow();
672            } catch (ArrayStoreException success) {}
673      }      }
674    
675      /**      /**

Legend:
Removed from v.1.73  
changed lines
  Added in v.1.74

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8