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.49 by jsr166, Fri Jul 15 18:49:31 2011 UTC vs.
Revision 1.53 by jsr166, Sun Nov 23 22:27:06 2014 UTC

# Line 177 | Line 177 | public class LinkedTransferQueueTest ext
177      public void testPut() {
178          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
179          for (int i = 0; i < SIZE; ++i) {
180 <            assertEquals(q.size(), i);
180 >            assertEquals(i, q.size());
181              q.put(i);
182              assertTrue(q.contains(i));
183          }
# Line 625 | Line 625 | public class LinkedTransferQueueTest ext
625          Queue x = populatedQueue(SIZE);
626          Queue y = serialClone(x);
627  
628 <        assertTrue(x != y);
628 >        assertNotSame(y, x);
629          assertEquals(x.size(), y.size());
630          assertEquals(x.toString(), y.toString());
631          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 643 | Line 643 | public class LinkedTransferQueueTest ext
643          LinkedTransferQueue q = populatedQueue(SIZE);
644          ArrayList l = new ArrayList();
645          q.drainTo(l);
646 <        assertEquals(q.size(), 0);
647 <        assertEquals(l.size(), SIZE);
646 >        assertEquals(0, q.size());
647 >        assertEquals(SIZE, l.size());
648          for (int i = 0; i < SIZE; ++i) {
649 <            assertEquals(l.get(i), i);
649 >            assertEquals(i, l.get(i));
650          }
651          q.add(zero);
652          q.add(one);
# Line 655 | Line 655 | public class LinkedTransferQueueTest ext
655          assertTrue(q.contains(one));
656          l.clear();
657          q.drainTo(l);
658 <        assertEquals(q.size(), 0);
659 <        assertEquals(l.size(), 2);
658 >        assertEquals(0, q.size());
659 >        assertEquals(2, l.size());
660          for (int i = 0; i < 2; ++i) {
661 <            assertEquals(l.get(i), i);
661 >            assertEquals(i, l.get(i));
662          }
663      }
664  
# Line 674 | Line 674 | public class LinkedTransferQueueTest ext
674          ArrayList l = new ArrayList();
675          q.drainTo(l);
676          assertTrue(l.size() >= SIZE);
677 <        for (int i = 0; i < SIZE; ++i) {
678 <            assertEquals(l.get(i), i);
679 <        }
677 >        for (int i = 0; i < SIZE; ++i)
678 >            assertEquals(i, l.get(i));
679          awaitTermination(t, MEDIUM_DELAY_MS);
680          assertTrue(q.size() + l.size() >= SIZE);
681      }
# Line 693 | Line 692 | public class LinkedTransferQueueTest ext
692              ArrayList l = new ArrayList();
693              q.drainTo(l, i);
694              int k = (i < SIZE) ? i : SIZE;
695 <            assertEquals(l.size(), k);
696 <            assertEquals(q.size(), SIZE - k);
697 <            for (int j = 0; j < k; ++j) {
698 <                assertEquals(l.get(j), j);
700 <            }
695 >            assertEquals(k, l.size());
696 >            assertEquals(SIZE - k, q.size());
697 >            for (int j = 0; j < k; ++j)
698 >                assertEquals(j, l.get(j));
699              while (q.poll() != null)
700                  ;
701          }
# Line 709 | Line 707 | public class LinkedTransferQueueTest ext
707       */
708      public void testWaitingConsumer() throws InterruptedException {
709          final LinkedTransferQueue q = new LinkedTransferQueue();
710 <        assertEquals(q.getWaitingConsumerCount(), 0);
710 >        assertEquals(0, q.getWaitingConsumerCount());
711          assertFalse(q.hasWaitingConsumer());
712          final CountDownLatch threadStarted = new CountDownLatch(1);
713  
# Line 717 | Line 715 | public class LinkedTransferQueueTest ext
715              public void realRun() throws InterruptedException {
716                  threadStarted.countDown();
717                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
718 <                assertEquals(q.getWaitingConsumerCount(), 0);
718 >                assertEquals(0, q.getWaitingConsumerCount());
719                  assertFalse(q.hasWaitingConsumer());
720              }});
721  
722          threadStarted.await();
723          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
724 <        assertEquals(q.getWaitingConsumerCount(), 1);
724 >        assertEquals(1, q.getWaitingConsumerCount());
725          assertTrue(q.hasWaitingConsumer());
726  
727          assertTrue(q.offer(one));
728 <        assertEquals(q.getWaitingConsumerCount(), 0);
728 >        assertEquals(0, q.getWaitingConsumerCount());
729          assertFalse(q.hasWaitingConsumer());
730  
731          awaitTermination(t, MEDIUM_DELAY_MS);
# Line 1015 | Line 1013 | public class LinkedTransferQueueTest ext
1013          assertFalse(q.isEmpty());
1014          return q;
1015      }
1016 +
1017 +    /**
1018 +     * remove(null), contains(null) always return false
1019 +     */
1020 +    public void testNeverContainsNull() {
1021 +        Collection<?>[] qs = {
1022 +            new LinkedTransferQueue<Object>(),
1023 +            populatedQueue(2),
1024 +        };
1025 +
1026 +        for (Collection<?> q : qs) {
1027 +            assertFalse(q.contains(null));
1028 +            assertFalse(q.remove(null));
1029 +        }
1030 +    }
1031   }

Diff Legend

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