ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentLinkedDequeTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ConcurrentLinkedDequeTest.java (file contents):
Revision 1.8 by jsr166, Fri May 27 19:47:55 2011 UTC vs.
Revision 1.20 by jsr166, Fri May 15 18:21:19 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.*;
11 < import java.util.concurrent.*;
12 < import java.io.*;
9 > import java.util.Arrays;
10 > import java.util.Collection;
11 > import java.util.Deque;
12 > import java.util.Iterator;
13 > import java.util.NoSuchElementException;
14 > import java.util.Queue;
15 > import java.util.Random;
16 > import java.util.concurrent.ConcurrentLinkedDeque;
17 >
18 > import junit.framework.Test;
19 > import junit.framework.TestSuite;
20  
21   public class ConcurrentLinkedDequeTest extends JSR166TestCase {
22  
23      public static void main(String[] args) {
24 <        junit.textui.TestRunner.run(suite());
24 >        main(suite(), args);
25      }
26  
27      public static Test suite() {
# Line 22 | Line 29 | public class ConcurrentLinkedDequeTest e
29      }
30  
31      /**
32 <     * Create a deque of given size containing consecutive
32 >     * Returns a new deque of given size containing consecutive
33       * Integers 0 ... n.
34       */
35      private ConcurrentLinkedDeque<Integer> populatedDeque(int n) {
# Line 48 | Line 55 | public class ConcurrentLinkedDequeTest e
55       */
56      public void testConstructor3() {
57          try {
58 <            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque((Collection)null);
58 >            new ConcurrentLinkedDeque((Collection)null);
59              shouldThrow();
60          } catch (NullPointerException success) {}
61      }
# Line 58 | Line 65 | public class ConcurrentLinkedDequeTest e
65       */
66      public void testConstructor4() {
67          try {
68 <            Integer[] ints = new Integer[SIZE];
62 <            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints));
68 >            new ConcurrentLinkedDeque(Arrays.asList(new Integer[SIZE]));
69              shouldThrow();
70          } catch (NullPointerException success) {}
71      }
# Line 68 | Line 74 | public class ConcurrentLinkedDequeTest e
74       * Initializing from Collection with some null elements throws NPE
75       */
76      public void testConstructor5() {
77 +        Integer[] ints = new Integer[SIZE];
78 +        for (int i = 0; i < SIZE-1; ++i)
79 +            ints[i] = new Integer(i);
80          try {
81 <            Integer[] ints = new Integer[SIZE];
73 <            for (int i = 0; i < SIZE-1; ++i)
74 <                ints[i] = new Integer(i);
75 <            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints));
81 >            new ConcurrentLinkedDeque(Arrays.asList(ints));
82              shouldThrow();
83          } catch (NullPointerException success) {}
84      }
# Line 122 | Line 128 | public class ConcurrentLinkedDequeTest e
128       * push(null) throws NPE
129       */
130      public void testPushNull() {
131 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
132          try {
126 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
133              q.push(null);
134              shouldThrow();
135          } catch (NullPointerException success) {}
# Line 157 | Line 163 | public class ConcurrentLinkedDequeTest e
163       * offer(null) throws NPE
164       */
165      public void testOfferNull() {
166 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
167          try {
161 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
168              q.offer(null);
169              shouldThrow();
170          } catch (NullPointerException success) {}
# Line 168 | Line 174 | public class ConcurrentLinkedDequeTest e
174       * offerFirst(null) throws NPE
175       */
176      public void testOfferFirstNull() {
177 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
178          try {
172 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
179              q.offerFirst(null);
180              shouldThrow();
181          } catch (NullPointerException success) {}
# Line 179 | Line 185 | public class ConcurrentLinkedDequeTest e
185       * offerLast(null) throws NPE
186       */
187      public void testOfferLastNull() {
188 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
189          try {
183 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
190              q.offerLast(null);
191              shouldThrow();
192          } catch (NullPointerException success) {}
# Line 223 | Line 229 | public class ConcurrentLinkedDequeTest e
229       * add(null) throws NPE
230       */
231      public void testAddNull() {
232 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
233          try {
227 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
234              q.add(null);
235              shouldThrow();
236          } catch (NullPointerException success) {}
# Line 234 | Line 240 | public class ConcurrentLinkedDequeTest e
240       * addFirst(null) throws NPE
241       */
242      public void testAddFirstNull() {
243 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
244          try {
238 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
245              q.addFirst(null);
246              shouldThrow();
247          } catch (NullPointerException success) {}
# Line 245 | Line 251 | public class ConcurrentLinkedDequeTest e
251       * addLast(null) throws NPE
252       */
253      public void testAddLastNull() {
254 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
255          try {
249 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
256              q.addLast(null);
257              shouldThrow();
258          } catch (NullPointerException success) {}
# Line 289 | Line 295 | public class ConcurrentLinkedDequeTest e
295       * addAll(null) throws NPE
296       */
297      public void testAddAll1() {
298 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
299          try {
293 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
300              q.addAll(null);
301              shouldThrow();
302          } catch (NullPointerException success) {}
# Line 300 | Line 306 | public class ConcurrentLinkedDequeTest e
306       * addAll(this) throws IAE
307       */
308      public void testAddAllSelf() {
309 +        ConcurrentLinkedDeque q = populatedDeque(SIZE);
310          try {
304 –            ConcurrentLinkedDeque q = populatedDeque(SIZE);
311              q.addAll(q);
312              shouldThrow();
313          } catch (IllegalArgumentException success) {}
# Line 311 | Line 317 | public class ConcurrentLinkedDequeTest e
317       * addAll of a collection with null elements throws NPE
318       */
319      public void testAddAll2() {
320 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
321          try {
322 <            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
316 <            Integer[] ints = new Integer[SIZE];
317 <            q.addAll(Arrays.asList(ints));
322 >            q.addAll(Arrays.asList(new Integer[SIZE]));
323              shouldThrow();
324          } catch (NullPointerException success) {}
325      }
# Line 324 | Line 329 | public class ConcurrentLinkedDequeTest e
329       * possibly adding some elements
330       */
331      public void testAddAll3() {
332 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
333 +        Integer[] ints = new Integer[SIZE];
334 +        for (int i = 0; i < SIZE-1; ++i)
335 +            ints[i] = new Integer(i);
336          try {
328 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
329 –            Integer[] ints = new Integer[SIZE];
330 –            for (int i = 0; i < SIZE-1; ++i)
331 –                ints[i] = new Integer(i);
337              q.addAll(Arrays.asList(ints));
338              shouldThrow();
339          } catch (NullPointerException success) {}
# Line 430 | Line 435 | public class ConcurrentLinkedDequeTest e
435       */
436      public void testRemoveElement() {
437          ConcurrentLinkedDeque q = populatedDeque(SIZE);
438 <        for (int i = 1; i < SIZE; i+=2) {
438 >        for (int i = 1; i < SIZE; i += 2) {
439              assertTrue(q.contains(i));
440              assertTrue(q.remove(i));
441              assertFalse(q.contains(i));
442              assertTrue(q.contains(i-1));
443          }
444 <        for (int i = 0; i < SIZE; i+=2) {
444 >        for (int i = 0; i < SIZE; i += 2) {
445              assertTrue(q.contains(i));
446              assertTrue(q.remove(i));
447              assertFalse(q.contains(i));
# Line 540 | Line 545 | public class ConcurrentLinkedDequeTest e
545       */
546      public void testRemoveFirstOccurrence() {
547          ConcurrentLinkedDeque q = populatedDeque(SIZE);
548 <        for (int i = 1; i < SIZE; i+=2) {
548 >        for (int i = 1; i < SIZE; i += 2) {
549              assertTrue(q.removeFirstOccurrence(new Integer(i)));
550          }
551 <        for (int i = 0; i < SIZE; i+=2) {
551 >        for (int i = 0; i < SIZE; i += 2) {
552              assertTrue(q.removeFirstOccurrence(new Integer(i)));
553              assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
554          }
# Line 555 | Line 560 | public class ConcurrentLinkedDequeTest e
560       */
561      public void testRemoveLastOccurrence() {
562          ConcurrentLinkedDeque q = populatedDeque(SIZE);
563 <        for (int i = 1; i < SIZE; i+=2) {
563 >        for (int i = 1; i < SIZE; i += 2) {
564              assertTrue(q.removeLastOccurrence(new Integer(i)));
565          }
566 <        for (int i = 0; i < SIZE; i+=2) {
566 >        for (int i = 0; i < SIZE; i += 2) {
567              assertTrue(q.removeLastOccurrence(new Integer(i)));
568              assertFalse(q.removeLastOccurrence(new Integer(i+1)));
569          }
# Line 634 | Line 639 | public class ConcurrentLinkedDequeTest e
639              assertTrue(q.removeAll(p));
640              assertEquals(SIZE-i, q.size());
641              for (int j = 0; j < i; ++j) {
642 <                Integer I = (Integer)(p.remove());
643 <                assertFalse(q.contains(I));
642 >                Integer x = (Integer)(p.remove());
643 >                assertFalse(q.contains(x));
644              }
645          }
646      }
# Line 689 | Line 694 | public class ConcurrentLinkedDequeTest e
694       */
695      public void testIterator() {
696          ConcurrentLinkedDeque q = populatedDeque(SIZE);
692 –        int i = 0;
697          Iterator it = q.iterator();
698 <        while (it.hasNext()) {
698 >        int i;
699 >        for (i = 0; it.hasNext(); i++)
700              assertTrue(q.contains(it.next()));
696 –            ++i;
697 –        }
701          assertEquals(i, SIZE);
702 +        assertIteratorExhausted(it);
703 +    }
704 +
705 +    /**
706 +     * iterator of empty collection has no elements
707 +     */
708 +    public void testEmptyIterator() {
709 +        Deque c = new ConcurrentLinkedDeque();
710 +        assertIteratorExhausted(c.iterator());
711 +        assertIteratorExhausted(c.descendingIterator());
712      }
713  
714      /**
# Line 843 | Line 856 | public class ConcurrentLinkedDequeTest e
856       * A deserialized serialized deque has same elements in same order
857       */
858      public void testSerialization() throws Exception {
859 <        ConcurrentLinkedDeque q = populatedDeque(SIZE);
860 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
861 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
862 <        out.writeObject(q);
863 <        out.close();
864 <
865 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
866 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
867 <        ConcurrentLinkedDeque r = (ConcurrentLinkedDeque)in.readObject();
868 <        assertEquals(q.size(), r.size());
869 <        while (!q.isEmpty())
870 <            assertEquals(q.remove(), r.remove());
859 >        Queue x = populatedDeque(SIZE);
860 >        Queue y = serialClone(x);
861 >
862 >        assertNotSame(x, y);
863 >        assertEquals(x.size(), y.size());
864 >        assertEquals(x.toString(), y.toString());
865 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
866 >        while (!x.isEmpty()) {
867 >            assertFalse(y.isEmpty());
868 >            assertEquals(x.remove(), y.remove());
869 >        }
870 >        assertTrue(y.isEmpty());
871      }
872  
873 +    /**
874 +     * contains(null) always return false.
875 +     * remove(null) always throws NullPointerException.
876 +     */
877 +    public void testNeverContainsNull() {
878 +        Deque<?>[] qs = {
879 +            new ConcurrentLinkedDeque<Object>(),
880 +            populatedDeque(2),
881 +        };
882 +
883 +        for (Deque<?> q : qs) {
884 +            assertFalse(q.contains(null));
885 +            try {
886 +                assertFalse(q.remove(null));
887 +                shouldThrow();
888 +            } catch (NullPointerException success) {}
889 +            try {
890 +                assertFalse(q.removeFirstOccurrence(null));
891 +                shouldThrow();
892 +            } catch (NullPointerException success) {}
893 +            try {
894 +                assertFalse(q.removeLastOccurrence(null));
895 +                shouldThrow();
896 +            } catch (NullPointerException success) {}
897 +        }
898 +    }
899   }

Diff Legend

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