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.46 by jsr166, Fri May 27 20:07:24 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 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;
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;
15   import java.util.NoSuchElementException;
16 < import java.util.concurrent.*;
17 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
18 < import static java.util.concurrent.TimeUnit.NANOSECONDS;
16 > import java.util.Queue;
17 > import java.util.concurrent.BlockingQueue;
18 > import java.util.concurrent.CountDownLatch;
19 > import java.util.concurrent.Executors;
20 > import java.util.concurrent.ExecutorService;
21 > import java.util.concurrent.LinkedTransferQueue;
22 >
23   import junit.framework.Test;
23 – import junit.framework.TestSuite;
24  
25   @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 65 | Line 65 | public class LinkedTransferQueueTest ext
65       * NullPointerException
66       */
67      public void testConstructor3() {
68 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
69          try {
70 <            Integer[] ints = new Integer[SIZE];
70 <            new LinkedTransferQueue(Arrays.asList(ints));
70 >            new LinkedTransferQueue(elements);
71              shouldThrow();
72          } catch (NullPointerException success) {}
73      }
# Line 77 | Line 77 | public class LinkedTransferQueueTest ext
77       * throws NullPointerException
78       */
79      public void testConstructor4() {
80 +        Integer[] ints = new Integer[SIZE];
81 +        for (int i = 0; i < SIZE-1; ++i)
82 +            ints[i] = i;
83 +        Collection<Integer> elements = Arrays.asList(ints);
84          try {
85 <            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));
85 >            new LinkedTransferQueue(elements);
86              shouldThrow();
87          } catch (NullPointerException success) {}
88      }
# Line 129 | Line 129 | public class LinkedTransferQueueTest ext
129      }
130  
131      /**
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 –    /**
132       * addAll(this) throws IllegalArgumentException
133       */
134      public void testAddAllSelf() {
# Line 173 | Line 140 | public class LinkedTransferQueueTest ext
140      }
141  
142      /**
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 –    /**
143       * addAll of a collection with any null elements throws
144       * NullPointerException after possibly adding some elements
145       */
# Line 218 | Line 173 | public class LinkedTransferQueueTest ext
173      }
174  
175      /**
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 –    /**
176       * all elements successfully put are contained
177       */
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 425 | Line 369 | public class LinkedTransferQueueTest ext
369      }
370  
371      /**
428 –     * remove(x) removes x and returns true if present
429 –     */
430 –    public void testRemoveElement() throws InterruptedException {
431 –        LinkedTransferQueue q = populatedQueue(SIZE);
432 –        for (int i = 1; i < SIZE; i+=2) {
433 –            assertTrue(q.contains(i));
434 –            assertTrue(q.remove(i));
435 –            assertFalse(q.contains(i));
436 –            assertTrue(q.contains(i-1));
437 –        }
438 –        for (int i = 0; i < SIZE; i+=2) {
439 –            assertTrue(q.contains(i));
440 –            assertTrue(q.remove(i));
441 –            assertFalse(q.contains(i));
442 –            assertFalse(q.remove(i+1));
443 –            assertFalse(q.contains(i+1));
444 –        }
445 –        checkEmpty(q);
446 –    }
447 –
448 –    /**
372       * An add following remove(x) succeeds
373       */
374      public void testRemoveElementAndAdd() throws InterruptedException {
# Line 561 | Line 484 | public class LinkedTransferQueueTest ext
484      }
485  
486      /**
564 –     * toArray(null) throws NullPointerException
565 –     */
566 –    public void testToArray_NullArg() {
567 –        LinkedTransferQueue q = populatedQueue(SIZE);
568 –        try {
569 –            q.toArray(null);
570 –            shouldThrow();
571 –        } catch (NullPointerException success) {}
572 –    }
573 –
574 –    /**
487       * toArray(incompatible array type) throws ArrayStoreException
488       */
489      public void testToArray1_BadArg() {
# Line 711 | Line 623 | public class LinkedTransferQueueTest ext
623       * A deserialized serialized queue has same elements in same order
624       */
625      public void testSerialization() throws Exception {
626 <        LinkedTransferQueue q = populatedQueue(SIZE);
626 >        Queue x = populatedQueue(SIZE);
627 >        Queue y = serialClone(x);
628  
629 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
630 <        ObjectOutputStream out
631 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
632 <        out.writeObject(q);
633 <        out.close();
634 <
635 <        ByteArrayInputStream bin
723 <            = new ByteArrayInputStream(bout.toByteArray());
724 <        ObjectInputStream in
725 <            = new ObjectInputStream(new BufferedInputStream(bin));
726 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
727 <
728 <        assertEquals(q.size(), r.size());
729 <        assertEquals(q.toString(), r.toString());
730 <        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
731 <        while (!q.isEmpty()) {
732 <            assertEquals(q.remove(), r.remove());
629 >        assertNotSame(y, x);
630 >        assertEquals(x.size(), y.size());
631 >        assertEquals(x.toString(), y.toString());
632 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
633 >        while (!x.isEmpty()) {
634 >            assertFalse(y.isEmpty());
635 >            assertEquals(x.remove(), y.remove());
636          }
637 <    }
735 <
736 <    /**
737 <     * drainTo(null) throws NullPointerException
738 <     */
739 <    public void testDrainToNull() {
740 <        LinkedTransferQueue q = populatedQueue(SIZE);
741 <        try {
742 <            q.drainTo(null);
743 <            shouldThrow();
744 <        } catch (NullPointerException success) {}
745 <    }
746 <
747 <    /**
748 <     * drainTo(this) throws IllegalArgumentException
749 <     */
750 <    public void testDrainToSelf() {
751 <        LinkedTransferQueue q = populatedQueue(SIZE);
752 <        try {
753 <            q.drainTo(q);
754 <            shouldThrow();
755 <        } catch (IllegalArgumentException success) {}
637 >        assertTrue(y.isEmpty());
638      }
639  
640      /**
# Line 762 | 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 774 | 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 793 | 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);
798 <        }
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      }
683  
684      /**
804 –     * drainTo(null, n) throws NullPointerException
805 –     */
806 –    public void testDrainToNullN() {
807 –        LinkedTransferQueue q = populatedQueue(SIZE);
808 –        try {
809 –            q.drainTo(null, SIZE);
810 –            shouldThrow();
811 –        } catch (NullPointerException success) {}
812 –    }
813 –
814 –    /**
815 –     * drainTo(this, n) throws IllegalArgumentException
816 –     */
817 –    public void testDrainToSelfN() {
818 –        LinkedTransferQueue q = populatedQueue(SIZE);
819 –        try {
820 –            q.drainTo(q, SIZE);
821 –            shouldThrow();
822 –        } catch (IllegalArgumentException success) {}
823 –    }
824 –
825 –    /**
685       * drainTo(c, n) empties first min(n, size) elements of queue into c
686       */
687      public void testDrainToN() {
# Line 834 | 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);
841 <            }
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 850 | 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 858 | 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 1156 | 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