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.50 by jsr166, Sat Nov 26 05:19:17 2011 UTC vs.
Revision 1.62 by jsr166, Sun Jun 14 20:58:14 2015 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 {
27 +    static class Implementation implements CollectionImplementation {
28 +        public Class<?> klazz() { return LinkedTransferQueue.class; }
29 +        public Collection emptyCollection() { return new LinkedTransferQueue(); }
30 +        public Object makeElement(int i) { return i; }
31 +        public boolean isConcurrent() { return true; }
32 +        public boolean permitsNulls() { return false; }
33 +    }
34  
35      public static class Generic extends BlockingQueueTest {
36          protected BlockingQueue emptyCollection() {
# Line 31 | Line 39 | public class LinkedTransferQueueTest ext
39      }
40  
41      public static void main(String[] args) {
42 <        junit.textui.TestRunner.run(suite());
42 >        main(suite(), args);
43      }
44  
45      public static Test suite() {
46          return newTestSuite(LinkedTransferQueueTest.class,
47 <                            new Generic().testSuite());
47 >                            new Generic().testSuite(),
48 >                            CollectionTest.testSuite(new Implementation()));
49      }
50  
51      /**
# Line 77 | Line 86 | public class LinkedTransferQueueTest ext
86       */
87      public void testConstructor4() {
88          Integer[] ints = new Integer[SIZE];
89 <        for (int i = 0; i < SIZE-1; ++i)
89 >        for (int i = 0; i < SIZE - 1; ++i)
90              ints[i] = i;
91          Collection<Integer> elements = Arrays.asList(ints);
92          try {
# Line 114 | Line 123 | public class LinkedTransferQueueTest ext
123       * remainingCapacity() always returns Integer.MAX_VALUE
124       */
125      public void testRemainingCapacity() {
126 <        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
126 >        BlockingQueue q = populatedQueue(SIZE);
127          for (int i = 0; i < SIZE; ++i) {
128              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
129              assertEquals(SIZE - i, q.size());
130 <            q.remove();
130 >            assertEquals(i, q.remove());
131          }
132          for (int i = 0; i < SIZE; ++i) {
133              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
134              assertEquals(i, q.size());
135 <            q.add(i);
135 >            assertTrue(q.add(i));
136          }
137      }
138  
# Line 131 | Line 140 | public class LinkedTransferQueueTest ext
140       * addAll(this) throws IllegalArgumentException
141       */
142      public void testAddAllSelf() {
143 +        LinkedTransferQueue q = populatedQueue(SIZE);
144          try {
135 –            LinkedTransferQueue q = populatedQueue(SIZE);
145              q.addAll(q);
146              shouldThrow();
147          } catch (IllegalArgumentException success) {}
# Line 143 | Line 152 | public class LinkedTransferQueueTest ext
152       * NullPointerException after possibly adding some elements
153       */
154      public void testAddAll3() {
155 +        LinkedTransferQueue q = new LinkedTransferQueue();
156 +        Integer[] ints = new Integer[SIZE];
157 +        for (int i = 0; i < SIZE - 1; ++i)
158 +            ints[i] = i;
159          try {
147 –            LinkedTransferQueue q = new LinkedTransferQueue();
148 –            Integer[] ints = new Integer[SIZE];
149 –            for (int i = 0; i < SIZE - 1; ++i) {
150 –                ints[i] = i;
151 –            }
160              q.addAll(Arrays.asList(ints));
161              shouldThrow();
162          } catch (NullPointerException success) {}
# Line 177 | Line 185 | public class LinkedTransferQueueTest ext
185      public void testPut() {
186          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
187          for (int i = 0; i < SIZE; ++i) {
188 <            assertEquals(q.size(), i);
188 >            assertEquals(i, q.size());
189              q.put(i);
190              assertTrue(q.contains(i));
191          }
# Line 499 | Line 507 | public class LinkedTransferQueueTest ext
507      public void testIterator() throws InterruptedException {
508          LinkedTransferQueue q = populatedQueue(SIZE);
509          Iterator it = q.iterator();
510 <        int i = 0;
511 <        while (it.hasNext()) {
512 <            assertEquals(it.next(), i++);
505 <        }
510 >        int i;
511 >        for (i = 0; it.hasNext(); i++)
512 >            assertTrue(q.contains(it.next()));
513          assertEquals(i, SIZE);
514 +        assertIteratorExhausted(it);
515 +
516 +        it = q.iterator();
517 +        for (i = 0; it.hasNext(); i++)
518 +            assertEquals(it.next(), q.take());
519 +        assertEquals(i, SIZE);
520 +        assertIteratorExhausted(it);
521 +    }
522 +
523 +    /**
524 +     * iterator of empty collection has no elements
525 +     */
526 +    public void testEmptyIterator() {
527 +        assertIteratorExhausted(new LinkedTransferQueue().iterator());
528      }
529  
530      /**
# Line 625 | Line 646 | public class LinkedTransferQueueTest ext
646          Queue x = populatedQueue(SIZE);
647          Queue y = serialClone(x);
648  
649 <        assertTrue(x != y);
649 >        assertNotSame(y, x);
650          assertEquals(x.size(), y.size());
651          assertEquals(x.toString(), y.toString());
652          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 646 | Line 667 | public class LinkedTransferQueueTest ext
667          assertEquals(0, q.size());
668          assertEquals(SIZE, l.size());
669          for (int i = 0; i < SIZE; ++i) {
670 <            assertEquals(l.get(i), i);
670 >            assertEquals(i, l.get(i));
671          }
672          q.add(zero);
673          q.add(one);
# Line 658 | Line 679 | public class LinkedTransferQueueTest ext
679          assertEquals(0, q.size());
680          assertEquals(2, l.size());
681          for (int i = 0; i < 2; ++i) {
682 <            assertEquals(l.get(i), i);
682 >            assertEquals(i, l.get(i));
683          }
684      }
685  
# Line 674 | Line 695 | public class LinkedTransferQueueTest ext
695          ArrayList l = new ArrayList();
696          q.drainTo(l);
697          assertTrue(l.size() >= SIZE);
698 <        for (int i = 0; i < SIZE; ++i) {
699 <            assertEquals(l.get(i), i);
679 <        }
698 >        for (int i = 0; i < SIZE; ++i)
699 >            assertEquals(i, l.get(i));
700          awaitTermination(t, MEDIUM_DELAY_MS);
701          assertTrue(q.size() + l.size() >= SIZE);
702      }
# Line 693 | Line 713 | public class LinkedTransferQueueTest ext
713              ArrayList l = new ArrayList();
714              q.drainTo(l, i);
715              int k = (i < SIZE) ? i : SIZE;
716 <            assertEquals(l.size(), k);
717 <            assertEquals(q.size(), SIZE - k);
718 <            for (int j = 0; j < k; ++j) {
719 <                assertEquals(l.get(j), j);
720 <            }
701 <            while (q.poll() != null)
702 <                ;
716 >            assertEquals(k, l.size());
717 >            assertEquals(SIZE - k, q.size());
718 >            for (int j = 0; j < k; ++j)
719 >                assertEquals(j, l.get(j));
720 >            do {} while (q.poll() != null);
721          }
722      }
723  
# Line 851 | Line 869 | public class LinkedTransferQueueTest ext
869       * tryTransfer(null) throws NullPointerException
870       */
871      public void testTryTransfer1() {
872 +        final LinkedTransferQueue q = new LinkedTransferQueue();
873          try {
855 –            final LinkedTransferQueue q = new LinkedTransferQueue();
874              q.tryTransfer(null);
875              shouldThrow();
876          } catch (NullPointerException success) {}
# Line 1015 | Line 1033 | public class LinkedTransferQueueTest ext
1033          assertFalse(q.isEmpty());
1034          return q;
1035      }
1036 +
1037 +    /**
1038 +     * remove(null), contains(null) always return false
1039 +     */
1040 +    public void testNeverContainsNull() {
1041 +        Collection<?>[] qs = {
1042 +            new LinkedTransferQueue<Object>(),
1043 +            populatedQueue(2),
1044 +        };
1045 +
1046 +        for (Collection<?> q : qs) {
1047 +            assertFalse(q.contains(null));
1048 +            assertFalse(q.remove(null));
1049 +        }
1050 +    }
1051   }

Diff Legend

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