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.16 by jsr166, Wed Dec 31 20:17:39 2014 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  
# 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 430 | Line 437 | public class ConcurrentLinkedDequeTest e
437       */
438      public void testRemoveElement() {
439          ConcurrentLinkedDeque q = populatedDeque(SIZE);
440 <        for (int i = 1; i < SIZE; i+=2) {
440 >        for (int i = 1; i < SIZE; i += 2) {
441              assertTrue(q.contains(i));
442              assertTrue(q.remove(i));
443              assertFalse(q.contains(i));
444              assertTrue(q.contains(i-1));
445          }
446 <        for (int i = 0; i < SIZE; i+=2) {
446 >        for (int i = 0; i < SIZE; i += 2) {
447              assertTrue(q.contains(i));
448              assertTrue(q.remove(i));
449              assertFalse(q.contains(i));
# Line 540 | Line 547 | public class ConcurrentLinkedDequeTest e
547       */
548      public void testRemoveFirstOccurrence() {
549          ConcurrentLinkedDeque q = populatedDeque(SIZE);
550 <        for (int i = 1; i < SIZE; i+=2) {
550 >        for (int i = 1; i < SIZE; i += 2) {
551              assertTrue(q.removeFirstOccurrence(new Integer(i)));
552          }
553 <        for (int i = 0; i < SIZE; i+=2) {
553 >        for (int i = 0; i < SIZE; i += 2) {
554              assertTrue(q.removeFirstOccurrence(new Integer(i)));
555              assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
556          }
# Line 555 | Line 562 | public class ConcurrentLinkedDequeTest e
562       */
563      public void testRemoveLastOccurrence() {
564          ConcurrentLinkedDeque q = populatedDeque(SIZE);
565 <        for (int i = 1; i < SIZE; i+=2) {
565 >        for (int i = 1; i < SIZE; i += 2) {
566              assertTrue(q.removeLastOccurrence(new Integer(i)));
567          }
568 <        for (int i = 0; i < SIZE; i+=2) {
568 >        for (int i = 0; i < SIZE; i += 2) {
569              assertTrue(q.removeLastOccurrence(new Integer(i)));
570              assertFalse(q.removeLastOccurrence(new Integer(i+1)));
571          }
# Line 634 | Line 641 | public class ConcurrentLinkedDequeTest e
641              assertTrue(q.removeAll(p));
642              assertEquals(SIZE-i, q.size());
643              for (int j = 0; j < i; ++j) {
644 <                Integer I = (Integer)(p.remove());
645 <                assertFalse(q.contains(I));
644 >                Integer x = (Integer)(p.remove());
645 >                assertFalse(q.contains(x));
646              }
647          }
648      }
# Line 843 | Line 850 | public class ConcurrentLinkedDequeTest e
850       * A deserialized serialized deque has same elements in same order
851       */
852      public void testSerialization() throws Exception {
853 <        ConcurrentLinkedDeque q = populatedDeque(SIZE);
854 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
855 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
856 <        out.writeObject(q);
857 <        out.close();
858 <
859 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
860 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
861 <        ConcurrentLinkedDeque r = (ConcurrentLinkedDeque)in.readObject();
862 <        assertEquals(q.size(), r.size());
863 <        while (!q.isEmpty())
864 <            assertEquals(q.remove(), r.remove());
853 >        Queue x = populatedDeque(SIZE);
854 >        Queue y = serialClone(x);
855 >
856 >        assertNotSame(x, y);
857 >        assertEquals(x.size(), y.size());
858 >        assertEquals(x.toString(), y.toString());
859 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
860 >        while (!x.isEmpty()) {
861 >            assertFalse(y.isEmpty());
862 >            assertEquals(x.remove(), y.remove());
863 >        }
864 >        assertTrue(y.isEmpty());
865      }
866  
867 +    /**
868 +     * contains(null) always return false.
869 +     * remove(null) always throws NullPointerException.
870 +     */
871 +    public void testNeverContainsNull() {
872 +        Deque<?>[] qs = {
873 +            new ConcurrentLinkedDeque<Object>(),
874 +            populatedDeque(2),
875 +        };
876 +
877 +        for (Deque<?> q : qs) {
878 +            assertFalse(q.contains(null));
879 +            try {
880 +                assertFalse(q.remove(null));
881 +                shouldThrow();
882 +            } catch (NullPointerException success) {}
883 +            try {
884 +                assertFalse(q.removeFirstOccurrence(null));
885 +                shouldThrow();
886 +            } catch (NullPointerException success) {}
887 +            try {
888 +                assertFalse(q.removeLastOccurrence(null));
889 +                shouldThrow();
890 +            } catch (NullPointerException success) {}
891 +        }
892 +    }
893   }

Diff Legend

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