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.48 by jsr166, Tue May 31 16:16:24 2011 UTC vs.
Revision 1.54 by jsr166, Wed Dec 31 16:44:02 2014 UTC

# Line 19 | Line 19 | 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  
23   @SuppressWarnings({"unchecked", "rawtypes"})
24   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 177 | Line 176 | public class LinkedTransferQueueTest ext
176      public void testPut() {
177          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
178          for (int i = 0; i < SIZE; ++i) {
179 <            assertEquals(q.size(), i);
179 >            assertEquals(i, q.size());
180              q.put(i);
181              assertTrue(q.contains(i));
182          }
# Line 368 | Line 367 | public class LinkedTransferQueueTest ext
367      }
368  
369      /**
371 –     * remove(x) removes x and returns true if present
372 –     */
373 –    public void testRemoveElement() throws InterruptedException {
374 –        LinkedTransferQueue q = populatedQueue(SIZE);
375 –        for (int i = 1; i < SIZE; i+=2) {
376 –            assertTrue(q.contains(i));
377 –            assertTrue(q.remove(i));
378 –            assertFalse(q.contains(i));
379 –            assertTrue(q.contains(i-1));
380 –        }
381 –        for (int i = 0; i < SIZE; i+=2) {
382 –            assertTrue(q.contains(i));
383 –            assertTrue(q.remove(i));
384 –            assertFalse(q.contains(i));
385 –            assertFalse(q.remove(i+1));
386 –            assertFalse(q.contains(i+1));
387 –        }
388 –        checkEmpty(q);
389 –    }
390 –
391 –    /**
370       * An add following remove(x) succeeds
371       */
372      public void testRemoveElementAndAdd() throws InterruptedException {
# Line 646 | Line 624 | public class LinkedTransferQueueTest ext
624          Queue x = populatedQueue(SIZE);
625          Queue y = serialClone(x);
626  
627 <        assertTrue(x != y);
627 >        assertNotSame(y, x);
628          assertEquals(x.size(), y.size());
629          assertEquals(x.toString(), y.toString());
630          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 664 | Line 642 | public class LinkedTransferQueueTest ext
642          LinkedTransferQueue q = populatedQueue(SIZE);
643          ArrayList l = new ArrayList();
644          q.drainTo(l);
645 <        assertEquals(q.size(), 0);
646 <        assertEquals(l.size(), SIZE);
645 >        assertEquals(0, q.size());
646 >        assertEquals(SIZE, l.size());
647          for (int i = 0; i < SIZE; ++i) {
648 <            assertEquals(l.get(i), i);
648 >            assertEquals(i, l.get(i));
649          }
650          q.add(zero);
651          q.add(one);
# Line 676 | Line 654 | public class LinkedTransferQueueTest ext
654          assertTrue(q.contains(one));
655          l.clear();
656          q.drainTo(l);
657 <        assertEquals(q.size(), 0);
658 <        assertEquals(l.size(), 2);
657 >        assertEquals(0, q.size());
658 >        assertEquals(2, l.size());
659          for (int i = 0; i < 2; ++i) {
660 <            assertEquals(l.get(i), i);
660 >            assertEquals(i, l.get(i));
661          }
662      }
663  
# Line 695 | Line 673 | public class LinkedTransferQueueTest ext
673          ArrayList l = new ArrayList();
674          q.drainTo(l);
675          assertTrue(l.size() >= SIZE);
676 <        for (int i = 0; i < SIZE; ++i) {
677 <            assertEquals(l.get(i), i);
700 <        }
676 >        for (int i = 0; i < SIZE; ++i)
677 >            assertEquals(i, l.get(i));
678          awaitTermination(t, MEDIUM_DELAY_MS);
679          assertTrue(q.size() + l.size() >= SIZE);
680      }
# Line 714 | Line 691 | public class LinkedTransferQueueTest ext
691              ArrayList l = new ArrayList();
692              q.drainTo(l, i);
693              int k = (i < SIZE) ? i : SIZE;
694 <            assertEquals(l.size(), k);
695 <            assertEquals(q.size(), SIZE - k);
696 <            for (int j = 0; j < k; ++j) {
697 <                assertEquals(l.get(j), j);
721 <            }
694 >            assertEquals(k, l.size());
695 >            assertEquals(SIZE - k, q.size());
696 >            for (int j = 0; j < k; ++j)
697 >                assertEquals(j, l.get(j));
698              while (q.poll() != null)
699                  ;
700          }
# Line 730 | Line 706 | public class LinkedTransferQueueTest ext
706       */
707      public void testWaitingConsumer() throws InterruptedException {
708          final LinkedTransferQueue q = new LinkedTransferQueue();
709 <        assertEquals(q.getWaitingConsumerCount(), 0);
709 >        assertEquals(0, q.getWaitingConsumerCount());
710          assertFalse(q.hasWaitingConsumer());
711          final CountDownLatch threadStarted = new CountDownLatch(1);
712  
# Line 738 | Line 714 | public class LinkedTransferQueueTest ext
714              public void realRun() throws InterruptedException {
715                  threadStarted.countDown();
716                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
717 <                assertEquals(q.getWaitingConsumerCount(), 0);
717 >                assertEquals(0, q.getWaitingConsumerCount());
718                  assertFalse(q.hasWaitingConsumer());
719              }});
720  
721          threadStarted.await();
722          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
723 <        assertEquals(q.getWaitingConsumerCount(), 1);
723 >        assertEquals(1, q.getWaitingConsumerCount());
724          assertTrue(q.hasWaitingConsumer());
725  
726          assertTrue(q.offer(one));
727 <        assertEquals(q.getWaitingConsumerCount(), 0);
727 >        assertEquals(0, q.getWaitingConsumerCount());
728          assertFalse(q.hasWaitingConsumer());
729  
730          awaitTermination(t, MEDIUM_DELAY_MS);
# Line 1036 | Line 1012 | public class LinkedTransferQueueTest ext
1012          assertFalse(q.isEmpty());
1013          return q;
1014      }
1015 +
1016 +    /**
1017 +     * remove(null), contains(null) always return false
1018 +     */
1019 +    public void testNeverContainsNull() {
1020 +        Collection<?>[] qs = {
1021 +            new LinkedTransferQueue<Object>(),
1022 +            populatedQueue(2),
1023 +        };
1024 +
1025 +        for (Collection<?> q : qs) {
1026 +            assertFalse(q.contains(null));
1027 +            assertFalse(q.remove(null));
1028 +        }
1029 +    }
1030   }

Diff Legend

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