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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.31 by jsr166, Thu Oct 28 22:42:05 2010 UTC vs.
Revision 1.42 by jsr166, Thu Nov 18 20:21:53 2010 UTC

# Line 354 | Line 354 | public class LinkedTransferQueueTest ext
354                  for (int i = 0; i < SIZE; ++i) {
355                      long t0 = System.nanoTime();
356                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
357 <                    assertTrue(millisElapsedSince(t0) < SHORT_DELAY_MS);
357 >                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
358                  }
359 +                long t0 = System.nanoTime();
360                  aboutToWait.countDown();
361                  try {
362                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
363                      shouldThrow();
364 <                } catch (InterruptedException success) {}
364 >                } catch (InterruptedException success) {
365 >                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
366 >                }
367              }});
368  
369          aboutToWait.await();
# Line 382 | Line 385 | public class LinkedTransferQueueTest ext
385                  for (int i = 0; i < SIZE; ++i) {
386                      long t0 = System.nanoTime();
387                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
388 <                    assertTrue(millisElapsedSince(t0) < SHORT_DELAY_MS);
388 >                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
389                  }
390                  try {
391                      q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
# Line 445 | Line 448 | public class LinkedTransferQueueTest ext
448       */
449      public void testRemoveElement() throws InterruptedException {
450          LinkedTransferQueue q = populatedQueue(SIZE);
451 <        for (int i = 1; i < SIZE; i += 2) {
451 >        for (int i = 1; i < SIZE; i+=2) {
452 >            assertTrue(q.contains(i));
453              assertTrue(q.remove(i));
454 +            assertFalse(q.contains(i));
455 +            assertTrue(q.contains(i-1));
456          }
457 <        for (int i = 0; i < SIZE; i += 2) {
457 >        for (int i = 0; i < SIZE; i+=2) {
458 >            assertTrue(q.contains(i));
459              assertTrue(q.remove(i));
460 <            assertFalse(q.remove(i + 1));
460 >            assertFalse(q.contains(i));
461 >            assertFalse(q.remove(i+1));
462 >            assertFalse(q.contains(i+1));
463          }
464          checkEmpty(q);
465      }
# Line 547 | Line 556 | public class LinkedTransferQueueTest ext
556      }
557  
558      /**
559 <     * toArray() contains all elements
559 >     * toArray() contains all elements in FIFO order
560       */
561 <    public void testToArray() throws InterruptedException {
561 >    public void testToArray() {
562          LinkedTransferQueue q = populatedQueue(SIZE);
563          Object[] o = q.toArray();
564          for (int i = 0; i < o.length; i++) {
565 <            assertEquals(o[i], q.take());
565 >            assertSame(o[i], q.poll());
566          }
567      }
568  
569      /**
570 <     * toArray(a) contains all elements
570 >     * toArray(a) contains all elements in FIFO order
571       */
572 <    public void testToArray2() throws InterruptedException {
572 >    public void testToArray2() {
573          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
574          Integer[] ints = new Integer[SIZE];
575 <        ints = q.toArray(ints);
575 >        Integer[] array = q.toArray(ints);
576 >        assertSame(ints, array);
577          for (int i = 0; i < ints.length; i++) {
578 <            assertEquals(ints[i], q.take());
578 >            assertSame(ints[i], q.poll());
579          }
580      }
581  
582      /**
583       * toArray(null) throws NullPointerException
584       */
585 <    public void testToArray_BadArg() {
585 >    public void testToArray_NullArg() {
586          LinkedTransferQueue q = populatedQueue(SIZE);
587          try {
588 <            Object o[] = q.toArray(null);
588 >            q.toArray(null);
589              shouldThrow();
590          } catch (NullPointerException success) {}
591      }
592  
593      /**
594 <     * toArray(incompatible array type) throws CCE
594 >     * toArray(incompatible array type) throws ArrayStoreException
595       */
596      public void testToArray1_BadArg() {
597          LinkedTransferQueue q = populatedQueue(SIZE);
598          try {
599 <            Object o[] = q.toArray(new String[10]);
599 >            q.toArray(new String[10]);
600              shouldThrow();
601          } catch (ArrayStoreException success) {}
602      }
# Line 739 | Line 749 | public class LinkedTransferQueueTest ext
749          LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
750  
751          assertEquals(q.size(), r.size());
752 +        assertEquals(q.toString(), r.toString());
753 +        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
754          while (!q.isEmpty()) {
755              assertEquals(q.remove(), r.remove());
756          }
# Line 908 | Line 920 | public class LinkedTransferQueueTest ext
920          Thread t = newStartedThread(new CheckedRunnable() {
921              public void realRun() throws InterruptedException {
922                  threadStarted.countDown();
923 <                q.transfer(SIZE);
923 >                q.transfer(five);
924                  checkEmpty(q);
925              }});
926  
927          threadStarted.await();
928          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
917 –        assertTrue(t.isAlive());
929          assertEquals(1, q.size());
930 <        assertEquals(SIZE, (int) q.poll());
930 >        assertSame(five, q.poll());
931          checkEmpty(q);
932          awaitTermination(t, MEDIUM_DELAY_MS);
933      }
# Line 930 | Line 941 | public class LinkedTransferQueueTest ext
941  
942          Thread first = newStartedThread(new CheckedRunnable() {
943              public void realRun() throws InterruptedException {
944 <                Integer i = SIZE + 1;
945 <                q.transfer(i);
935 <                assertTrue(!q.contains(i));
944 >                q.transfer(four);
945 >                assertTrue(!q.contains(four));
946                  assertEquals(1, q.size());
947              }});
948  
949          Thread interruptedThread = newStartedThread(
950              new CheckedInterruptedRunnable() {
951                  public void realRun() throws InterruptedException {
952 <                    while (q.size() == 0)
952 >                    while (q.isEmpty())
953                          Thread.yield();
954 <                    q.transfer(SIZE);
954 >                    q.transfer(five);
955                  }});
956  
957          while (q.size() < 2)
958              Thread.yield();
959          assertEquals(2, q.size());
960 <        assertEquals(SIZE + 1, (int) q.poll());
960 >        assertSame(four, q.poll());
961          first.join();
962          assertEquals(1, q.size());
963          interruptedThread.interrupt();
# Line 1068 | Line 1078 | public class LinkedTransferQueueTest ext
1078      }
1079  
1080      /**
1081 <     * tryTransfer waits the amount given if interrupted, and
1082 <     * throws interrupted exception
1081 >     * tryTransfer waits the amount given, and throws
1082 >     * InterruptedException when interrupted.
1083       */
1084      public void testTryTransfer5() throws InterruptedException {
1085          final LinkedTransferQueue q = new LinkedTransferQueue();
1086          final CountDownLatch threadStarted = new CountDownLatch(1);
1087 +        assertTrue(q.isEmpty());
1088  
1089          Thread t = newStartedThread(new CheckedRunnable() {
1090              public void realRun() throws InterruptedException {
# Line 1084 | Line 1095 | public class LinkedTransferQueueTest ext
1095                      shouldThrow();
1096                  } catch (InterruptedException success) {}
1097                  assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1098 +                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
1099              }});
1100  
1101          threadStarted.await();
1102 +        while (q.isEmpty())
1103 +            Thread.yield();
1104          Thread.sleep(SHORT_DELAY_MS);
1105          t.interrupt();
1106          awaitTermination(t, MEDIUM_DELAY_MS);
# Line 1094 | Line 1108 | public class LinkedTransferQueueTest ext
1108      }
1109  
1110      /**
1111 <     * tryTransfer gives up after the timeout and return false
1111 >     * tryTransfer gives up after the timeout and returns false
1112       */
1113      public void testTryTransfer6() throws InterruptedException {
1114          final LinkedTransferQueue q = new LinkedTransferQueue();
# Line 1105 | Line 1119 | public class LinkedTransferQueueTest ext
1119                  assertFalse(q.tryTransfer(new Object(),
1120                                            SHORT_DELAY_MS, MILLISECONDS));
1121                  assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1122 +                checkEmpty(q);
1123              }});
1124  
1110 –        checkEmpty(q);
1125          awaitTermination(t, MEDIUM_DELAY_MS);
1126          checkEmpty(q);
1127      }
# Line 1126 | Line 1140 | public class LinkedTransferQueueTest ext
1140                  checkEmpty(q);
1141              }});
1142  
1143 <        Thread.sleep(SHORT_DELAY_MS);
1143 >        while (q.size() != 2)
1144 >            Thread.yield();
1145          assertEquals(2, q.size());
1146          assertSame(four, q.poll());
1147          assertSame(five, q.poll());
# Line 1135 | Line 1150 | public class LinkedTransferQueueTest ext
1150      }
1151  
1152      /**
1153 <     * tryTransfer attempts to enqueue into the q and fails returning
1154 <     * false not enqueueing and the successive poll is null
1153 >     * tryTransfer attempts to enqueue into the queue and fails
1154 >     * returning false not enqueueing and the successive poll is null
1155       */
1156      public void testTryTransfer8() throws InterruptedException {
1157          final LinkedTransferQueue q = new LinkedTransferQueue();
1158          assertTrue(q.offer(four));
1159          assertEquals(1, q.size());
1160 +        long t0 = System.nanoTime();
1161          assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1162 +        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1163          assertEquals(1, q.size());
1164          assertSame(four, q.poll());
1165          assertNull(q.poll());

Diff Legend

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