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.45 by dl, Fri May 6 16:43:45 2011 UTC vs.
Revision 1.48 by jsr166, Tue May 31 16:16:24 2011 UTC

# Line 5 | Line 5
5   * Other contributors include John Vint
6   */
7  
8 < import java.io.BufferedInputStream;
9 < import java.io.BufferedOutputStream;
10 < import java.io.ByteArrayInputStream;
11 < import java.io.ByteArrayOutputStream;
12 < import java.io.ObjectInputStream;
13 < import java.io.ObjectOutputStream;
14 < import java.util.ArrayList;
8 > import junit.framework.*;
9   import java.util.Arrays;
10 + import java.util.ArrayList;
11 + import java.util.Collection;
12   import java.util.Iterator;
13   import java.util.List;
14   import java.util.NoSuchElementException;
15 < import java.util.concurrent.*;
15 > import java.util.Queue;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.CountDownLatch;
18 > import java.util.concurrent.Executors;
19 > import java.util.concurrent.ExecutorService;
20 > import java.util.concurrent.LinkedTransferQueue;
21   import static java.util.concurrent.TimeUnit.MILLISECONDS;
22   import static java.util.concurrent.TimeUnit.NANOSECONDS;
22 – import junit.framework.Test;
23 – import junit.framework.TestSuite;
23  
24   @SuppressWarnings({"unchecked", "rawtypes"})
25   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 65 | Line 64 | public class LinkedTransferQueueTest ext
64       * NullPointerException
65       */
66      public void testConstructor3() {
67 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
68          try {
69 <            Integer[] ints = new Integer[SIZE];
70 <            new LinkedTransferQueue(Arrays.asList(ints));
69 >            new LinkedTransferQueue(elements);
70              shouldThrow();
71          } catch (NullPointerException success) {}
72      }
# Line 77 | Line 76 | public class LinkedTransferQueueTest ext
76       * throws NullPointerException
77       */
78      public void testConstructor4() {
79 +        Integer[] ints = new Integer[SIZE];
80 +        for (int i = 0; i < SIZE-1; ++i)
81 +            ints[i] = i;
82 +        Collection<Integer> elements = Arrays.asList(ints);
83          try {
84 <            Integer[] ints = new Integer[SIZE];
82 <            for (int i = 0; i < SIZE - 1; ++i) {
83 <                ints[i] = i;
84 <            }
85 <            new LinkedTransferQueue(Arrays.asList(ints));
84 >            new LinkedTransferQueue(elements);
85              shouldThrow();
86          } catch (NullPointerException success) {}
87      }
# Line 129 | Line 128 | public class LinkedTransferQueueTest ext
128      }
129  
130      /**
132 –     * offer(null) throws NullPointerException
133 –     */
134 –    public void testOfferNull() {
135 –        try {
136 –            LinkedTransferQueue q = new LinkedTransferQueue();
137 –            q.offer(null);
138 –            shouldThrow();
139 –        } catch (NullPointerException success) {}
140 –    }
141 –
142 –    /**
143 –     * add(null) throws NullPointerException
144 –     */
145 –    public void testAddNull() {
146 –        try {
147 –            LinkedTransferQueue q = new LinkedTransferQueue();
148 –            q.add(null);
149 –            shouldThrow();
150 –        } catch (NullPointerException success) {}
151 –    }
152 –
153 –    /**
154 –     * addAll(null) throws NullPointerException
155 –     */
156 –    public void testAddAll1() {
157 –        try {
158 –            LinkedTransferQueue q = new LinkedTransferQueue();
159 –            q.addAll(null);
160 –            shouldThrow();
161 –        } catch (NullPointerException success) {}
162 –    }
163 –
164 –    /**
131       * addAll(this) throws IllegalArgumentException
132       */
133      public void testAddAllSelf() {
# Line 173 | Line 139 | public class LinkedTransferQueueTest ext
139      }
140  
141      /**
176 –     * addAll of a collection with null elements throws NullPointerException
177 –     */
178 –    public void testAddAll2() {
179 –        try {
180 –            LinkedTransferQueue q = new LinkedTransferQueue();
181 –            Integer[] ints = new Integer[SIZE];
182 –            q.addAll(Arrays.asList(ints));
183 –            shouldThrow();
184 –        } catch (NullPointerException success) {}
185 –    }
186 –
187 –    /**
142       * addAll of a collection with any null elements throws
143       * NullPointerException after possibly adding some elements
144       */
# Line 218 | Line 172 | public class LinkedTransferQueueTest ext
172      }
173  
174      /**
221 –     * put(null) throws NullPointerException
222 –     */
223 –    public void testPutNull() throws InterruptedException {
224 –        try {
225 –            LinkedTransferQueue q = new LinkedTransferQueue();
226 –            q.put(null);
227 –            shouldThrow();
228 –        } catch (NullPointerException success) {}
229 –    }
230 –
231 –    /**
175       * all elements successfully put are contained
176       */
177      public void testPut() {
# Line 254 | Line 197 | public class LinkedTransferQueueTest ext
197       * take removes existing elements until empty, then blocks interruptibly
198       */
199      public void testBlockingTake() throws InterruptedException {
200 <        final BlockingQueue<Integer> q = populatedQueue(SIZE);
201 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
200 >        final BlockingQueue q = populatedQueue(SIZE);
201 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
202          Thread t = newStartedThread(new CheckedRunnable() {
203              public void realRun() throws InterruptedException {
204                  for (int i = 0; i < SIZE; ++i) {
205 <                    assertEquals(i, (int) q.take());
205 >                    assertEquals(i, q.take());
206                  }
207 <                aboutToWait.countDown();
207 >
208 >                Thread.currentThread().interrupt();
209                  try {
210                      q.take();
211                      shouldThrow();
212                  } catch (InterruptedException success) {}
213 +                assertFalse(Thread.interrupted());
214 +
215 +                pleaseInterrupt.countDown();
216 +                try {
217 +                    q.take();
218 +                    shouldThrow();
219 +                } catch (InterruptedException success) {}
220 +                assertFalse(Thread.interrupted());
221              }});
222  
223 <        aboutToWait.await();
224 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
223 >        await(pleaseInterrupt);
224 >        assertThreadStaysAlive(t);
225          t.interrupt();
226 <        awaitTermination(t, MEDIUM_DELAY_MS);
275 <        checkEmpty(q);
226 >        awaitTermination(t);
227      }
228  
229      /**
# Line 305 | Line 256 | public class LinkedTransferQueueTest ext
256      public void testTimedPoll() throws InterruptedException {
257          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
258          for (int i = 0; i < SIZE; ++i) {
259 <            long t0 = System.nanoTime();
260 <            assertEquals(i, (int) q.poll(SMALL_DELAY_MS, MILLISECONDS));
261 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
262 <        }
263 <        long t0 = System.nanoTime();
264 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
265 <        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
259 >            long startTime = System.nanoTime();
260 >            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
261 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
262 >        }
263 >        long startTime = System.nanoTime();
264 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
265 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
266          checkEmpty(q);
267      }
268  
# Line 553 | Line 504 | public class LinkedTransferQueueTest ext
504      }
505  
506      /**
556 –     * toArray(null) throws NullPointerException
557 –     */
558 –    public void testToArray_NullArg() {
559 –        LinkedTransferQueue q = populatedQueue(SIZE);
560 –        try {
561 –            q.toArray(null);
562 –            shouldThrow();
563 –        } catch (NullPointerException success) {}
564 –    }
565 –
566 –    /**
507       * toArray(incompatible array type) throws ArrayStoreException
508       */
509      public void testToArray1_BadArg() {
# Line 646 | Line 586 | public class LinkedTransferQueueTest ext
586          LinkedTransferQueue q = populatedQueue(SIZE);
587          String s = q.toString();
588          for (int i = 0; i < SIZE; ++i) {
589 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
589 >            assertTrue(s.contains(String.valueOf(i)));
590          }
591      }
592  
# Line 655 | Line 595 | public class LinkedTransferQueueTest ext
595       */
596      public void testOfferInExecutor() {
597          final LinkedTransferQueue q = new LinkedTransferQueue();
598 <        final CountDownLatch threadsStarted = new CountDownLatch(2);
598 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
599          ExecutorService executor = Executors.newFixedThreadPool(2);
600  
601          executor.execute(new CheckedRunnable() {
602              public void realRun() throws InterruptedException {
663 –                threadsStarted.countDown();
603                  threadsStarted.await();
604 <                assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
604 >                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
605              }});
606  
607          executor.execute(new CheckedRunnable() {
608              public void realRun() throws InterruptedException {
670 –                threadsStarted.countDown();
609                  threadsStarted.await();
610                  assertSame(one, q.take());
611                  checkEmpty(q);
# Line 681 | Line 619 | public class LinkedTransferQueueTest ext
619       */
620      public void testPollInExecutor() {
621          final LinkedTransferQueue q = new LinkedTransferQueue();
622 <        final CountDownLatch threadsStarted = new CountDownLatch(2);
622 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
623          ExecutorService executor = Executors.newFixedThreadPool(2);
624  
625          executor.execute(new CheckedRunnable() {
626              public void realRun() throws InterruptedException {
627                  assertNull(q.poll());
690 –                threadsStarted.countDown();
628                  threadsStarted.await();
629 <                assertSame(one, q.poll(SMALL_DELAY_MS, MILLISECONDS));
629 >                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
630                  checkEmpty(q);
631              }});
632  
633          executor.execute(new CheckedRunnable() {
634              public void realRun() throws InterruptedException {
698 –                threadsStarted.countDown();
635                  threadsStarted.await();
636                  q.put(one);
637              }});
# Line 707 | Line 643 | public class LinkedTransferQueueTest ext
643       * A deserialized serialized queue has same elements in same order
644       */
645      public void testSerialization() throws Exception {
646 <        LinkedTransferQueue q = populatedQueue(SIZE);
647 <
712 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
713 <        ObjectOutputStream out
714 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
715 <        out.writeObject(q);
716 <        out.close();
717 <
718 <        ByteArrayInputStream bin
719 <            = new ByteArrayInputStream(bout.toByteArray());
720 <        ObjectInputStream in
721 <            = new ObjectInputStream(new BufferedInputStream(bin));
722 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
646 >        Queue x = populatedQueue(SIZE);
647 >        Queue y = serialClone(x);
648  
649 <        assertEquals(q.size(), r.size());
650 <        assertEquals(q.toString(), r.toString());
651 <        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
652 <        while (!q.isEmpty()) {
653 <            assertEquals(q.remove(), r.remove());
649 >        assertTrue(x != y);
650 >        assertEquals(x.size(), y.size());
651 >        assertEquals(x.toString(), y.toString());
652 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
653 >        while (!x.isEmpty()) {
654 >            assertFalse(y.isEmpty());
655 >            assertEquals(x.remove(), y.remove());
656          }
657 <    }
731 <
732 <    /**
733 <     * drainTo(null) throws NullPointerException
734 <     */
735 <    public void testDrainToNull() {
736 <        LinkedTransferQueue q = populatedQueue(SIZE);
737 <        try {
738 <            q.drainTo(null);
739 <            shouldThrow();
740 <        } catch (NullPointerException success) {}
741 <    }
742 <
743 <    /**
744 <     * drainTo(this) throws IllegalArgumentException
745 <     */
746 <    public void testDrainToSelf() {
747 <        LinkedTransferQueue q = populatedQueue(SIZE);
748 <        try {
749 <            q.drainTo(q);
750 <            shouldThrow();
751 <        } catch (IllegalArgumentException success) {}
657 >        assertTrue(y.isEmpty());
658      }
659  
660      /**
# Line 797 | Line 703 | public class LinkedTransferQueueTest ext
703      }
704  
705      /**
800 –     * drainTo(null, n) throws NullPointerException
801 –     */
802 –    public void testDrainToNullN() {
803 –        LinkedTransferQueue q = populatedQueue(SIZE);
804 –        try {
805 –            q.drainTo(null, SIZE);
806 –            shouldThrow();
807 –        } catch (NullPointerException success) {}
808 –    }
809 –
810 –    /**
811 –     * drainTo(this, n) throws IllegalArgumentException
812 –     */
813 –    public void testDrainToSelfN() {
814 –        LinkedTransferQueue q = populatedQueue(SIZE);
815 –        try {
816 –            q.drainTo(q, SIZE);
817 –            shouldThrow();
818 –        } catch (IllegalArgumentException success) {}
819 –    }
820 –
821 –    /**
706       * drainTo(c, n) empties first min(n, size) elements of queue into c
707       */
708      public void testDrainToN() {
# Line 1051 | Line 935 | public class LinkedTransferQueueTest ext
935      }
936  
937      /**
938 <     * tryTransfer waits the amount given, and throws
1055 <     * InterruptedException when interrupted.
938 >     * tryTransfer blocks interruptibly if no takers
939       */
940      public void testTryTransfer5() throws InterruptedException {
941          final LinkedTransferQueue q = new LinkedTransferQueue();
942 <        final CountDownLatch threadStarted = new CountDownLatch(1);
942 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
943          assertTrue(q.isEmpty());
944  
945          Thread t = newStartedThread(new CheckedRunnable() {
946              public void realRun() throws InterruptedException {
947 <                long t0 = System.nanoTime();
1065 <                threadStarted.countDown();
947 >                Thread.currentThread().interrupt();
948                  try {
949                      q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
950                      shouldThrow();
951                  } catch (InterruptedException success) {}
952 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
953 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
952 >                assertFalse(Thread.interrupted());
953 >
954 >                pleaseInterrupt.countDown();
955 >                try {
956 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
957 >                    shouldThrow();
958 >                } catch (InterruptedException success) {}
959 >                assertFalse(Thread.interrupted());
960              }});
961  
962 <        threadStarted.await();
963 <        while (q.isEmpty())
1076 <            Thread.yield();
1077 <        delay(SHORT_DELAY_MS);
962 >        await(pleaseInterrupt);
963 >        assertThreadStaysAlive(t);
964          t.interrupt();
965 <        awaitTermination(t, MEDIUM_DELAY_MS);
965 >        awaitTermination(t);
966          checkEmpty(q);
967      }
968  
# Line 1090 | Line 976 | public class LinkedTransferQueueTest ext
976              public void realRun() throws InterruptedException {
977                  long t0 = System.nanoTime();
978                  assertFalse(q.tryTransfer(new Object(),
979 <                                          SHORT_DELAY_MS, MILLISECONDS));
980 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
979 >                                          timeoutMillis(), MILLISECONDS));
980 >                assertTrue(millisElapsedSince(t0) >= timeoutMillis());
981                  checkEmpty(q);
982              }});
983  
984 <        awaitTermination(t, MEDIUM_DELAY_MS);
984 >        awaitTermination(t);
985          checkEmpty(q);
986      }
987  
# Line 1131 | Line 1017 | public class LinkedTransferQueueTest ext
1017          assertTrue(q.offer(four));
1018          assertEquals(1, q.size());
1019          long t0 = System.nanoTime();
1020 <        assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1021 <        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1020 >        assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1021 >        assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1022          assertEquals(1, q.size());
1023          assertSame(four, q.poll());
1024          assertNull(q.poll());

Diff Legend

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