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.55 by jsr166, Wed Dec 31 19:05:43 2014 UTC

# Line 5 | Line 5
5   * Other contributors include John Vint
6   */
7  
8 < import junit.framework.*;
9 < import java.util.Arrays;
8 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 >
10   import java.util.ArrayList;
11 + import java.util.Arrays;
12   import java.util.Collection;
13   import java.util.Iterator;
14   import java.util.List;
# Line 18 | Line 19 | import java.util.concurrent.CountDownLat
19   import java.util.concurrent.Executors;
20   import java.util.concurrent.ExecutorService;
21   import java.util.concurrent.LinkedTransferQueue;
22 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
23 < import static java.util.concurrent.TimeUnit.NANOSECONDS;
22 >
23 > import junit.framework.Test;
24  
25   @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 177 | Line 178 | public class LinkedTransferQueueTest ext
178      public void testPut() {
179          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
180          for (int i = 0; i < SIZE; ++i) {
181 <            assertEquals(q.size(), i);
181 >            assertEquals(i, q.size());
182              q.put(i);
183              assertTrue(q.contains(i));
184          }
# Line 625 | Line 626 | public class LinkedTransferQueueTest ext
626          Queue x = populatedQueue(SIZE);
627          Queue y = serialClone(x);
628  
629 <        assertTrue(x != y);
629 >        assertNotSame(y, x);
630          assertEquals(x.size(), y.size());
631          assertEquals(x.toString(), y.toString());
632          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 643 | Line 644 | public class LinkedTransferQueueTest ext
644          LinkedTransferQueue q = populatedQueue(SIZE);
645          ArrayList l = new ArrayList();
646          q.drainTo(l);
647 <        assertEquals(q.size(), 0);
648 <        assertEquals(l.size(), SIZE);
647 >        assertEquals(0, q.size());
648 >        assertEquals(SIZE, l.size());
649          for (int i = 0; i < SIZE; ++i) {
650 <            assertEquals(l.get(i), i);
650 >            assertEquals(i, l.get(i));
651          }
652          q.add(zero);
653          q.add(one);
# Line 655 | Line 656 | public class LinkedTransferQueueTest ext
656          assertTrue(q.contains(one));
657          l.clear();
658          q.drainTo(l);
659 <        assertEquals(q.size(), 0);
660 <        assertEquals(l.size(), 2);
659 >        assertEquals(0, q.size());
660 >        assertEquals(2, l.size());
661          for (int i = 0; i < 2; ++i) {
662 <            assertEquals(l.get(i), i);
662 >            assertEquals(i, l.get(i));
663          }
664      }
665  
# Line 674 | Line 675 | public class LinkedTransferQueueTest ext
675          ArrayList l = new ArrayList();
676          q.drainTo(l);
677          assertTrue(l.size() >= SIZE);
678 <        for (int i = 0; i < SIZE; ++i) {
679 <            assertEquals(l.get(i), i);
679 <        }
678 >        for (int i = 0; i < SIZE; ++i)
679 >            assertEquals(i, l.get(i));
680          awaitTermination(t, MEDIUM_DELAY_MS);
681          assertTrue(q.size() + l.size() >= SIZE);
682      }
# Line 693 | Line 693 | public class LinkedTransferQueueTest ext
693              ArrayList l = new ArrayList();
694              q.drainTo(l, i);
695              int k = (i < SIZE) ? i : SIZE;
696 <            assertEquals(l.size(), k);
697 <            assertEquals(q.size(), SIZE - k);
698 <            for (int j = 0; j < k; ++j) {
699 <                assertEquals(l.get(j), j);
700 <            }
696 >            assertEquals(k, l.size());
697 >            assertEquals(SIZE - k, q.size());
698 >            for (int j = 0; j < k; ++j)
699 >                assertEquals(j, l.get(j));
700              while (q.poll() != null)
701                  ;
702          }
# Line 709 | Line 708 | public class LinkedTransferQueueTest ext
708       */
709      public void testWaitingConsumer() throws InterruptedException {
710          final LinkedTransferQueue q = new LinkedTransferQueue();
711 <        assertEquals(q.getWaitingConsumerCount(), 0);
711 >        assertEquals(0, q.getWaitingConsumerCount());
712          assertFalse(q.hasWaitingConsumer());
713          final CountDownLatch threadStarted = new CountDownLatch(1);
714  
# Line 717 | Line 716 | public class LinkedTransferQueueTest ext
716              public void realRun() throws InterruptedException {
717                  threadStarted.countDown();
718                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
719 <                assertEquals(q.getWaitingConsumerCount(), 0);
719 >                assertEquals(0, q.getWaitingConsumerCount());
720                  assertFalse(q.hasWaitingConsumer());
721              }});
722  
723          threadStarted.await();
724          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
725 <        assertEquals(q.getWaitingConsumerCount(), 1);
725 >        assertEquals(1, q.getWaitingConsumerCount());
726          assertTrue(q.hasWaitingConsumer());
727  
728          assertTrue(q.offer(one));
729 <        assertEquals(q.getWaitingConsumerCount(), 0);
729 >        assertEquals(0, q.getWaitingConsumerCount());
730          assertFalse(q.hasWaitingConsumer());
731  
732          awaitTermination(t, MEDIUM_DELAY_MS);
# Line 1015 | Line 1014 | public class LinkedTransferQueueTest ext
1014          assertFalse(q.isEmpty());
1015          return q;
1016      }
1017 +
1018 +    /**
1019 +     * remove(null), contains(null) always return false
1020 +     */
1021 +    public void testNeverContainsNull() {
1022 +        Collection<?>[] qs = {
1023 +            new LinkedTransferQueue<Object>(),
1024 +            populatedQueue(2),
1025 +        };
1026 +
1027 +        for (Collection<?> q : qs) {
1028 +            assertFalse(q.contains(null));
1029 +            assertFalse(q.remove(null));
1030 +        }
1031 +    }
1032   }

Diff Legend

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