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

Comparing jsr166/src/test/tck/CopyOnWriteArrayListTest.java (file contents):
Revision 1.31 by jsr166, Wed Dec 31 19:05:42 2014 UTC vs.
Revision 1.39 by jsr166, Wed Aug 24 22:22:39 2016 UTC

# Line 9 | Line 9
9   import java.util.ArrayList;
10   import java.util.Arrays;
11   import java.util.Collection;
12 – import java.util.Collections;
12   import java.util.Iterator;
13   import java.util.LinkedList;
14   import java.util.List;
15   import java.util.ListIterator;
16   import java.util.NoSuchElementException;
18 – import java.util.Vector;
17   import java.util.concurrent.CopyOnWriteArrayList;
18  
19   import junit.framework.Test;
# Line 24 | Line 22 | import junit.framework.TestSuite;
22   public class CopyOnWriteArrayListTest extends JSR166TestCase {
23  
24      public static void main(String[] args) {
25 <        junit.textui.TestRunner.run(suite());
25 >        main(suite(), args);
26      }
27  
28      public static Test suite() {
# Line 64 | Line 62 | public class CopyOnWriteArrayListTest ex
62       */
63      public void testConstructor2() {
64          Integer[] ints = new Integer[SIZE];
65 <        for (int i = 0; i < SIZE-1; ++i)
65 >        for (int i = 0; i < SIZE - 1; ++i)
66              ints[i] = new Integer(i);
67          CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints);
68          for (int i = 0; i < SIZE; ++i)
# Line 76 | Line 74 | public class CopyOnWriteArrayListTest ex
74       */
75      public void testConstructor3() {
76          Integer[] ints = new Integer[SIZE];
77 <        for (int i = 0; i < SIZE-1; ++i)
77 >        for (int i = 0; i < SIZE - 1; ++i)
78              ints[i] = new Integer(i);
79          CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints));
80          for (int i = 0; i < SIZE; ++i)
# Line 84 | Line 82 | public class CopyOnWriteArrayListTest ex
82      }
83  
84      /**
85 <     * addAll adds each element from the given collection
85 >     * addAll adds each element from the given collection, including duplicates
86       */
87      public void testAddAll() {
88          CopyOnWriteArrayList full = populatedArray(3);
89 <        Vector v = new Vector();
92 <        v.add(three);
93 <        v.add(four);
94 <        v.add(five);
95 <        full.addAll(v);
89 >        assertTrue(full.addAll(Arrays.asList(three, four, five)));
90          assertEquals(6, full.size());
91 +        assertTrue(full.addAll(Arrays.asList(three, four, five)));
92 +        assertEquals(9, full.size());
93      }
94  
95      /**
# Line 102 | Line 98 | public class CopyOnWriteArrayListTest ex
98       */
99      public void testAddAllAbsent() {
100          CopyOnWriteArrayList full = populatedArray(3);
101 <        Vector v = new Vector();
102 <        v.add(three);
103 <        v.add(four);
104 <        v.add(one); // will not add this element
109 <        full.addAllAbsent(v);
101 >        // "one" is duplicate and will not be added
102 >        assertEquals(2, full.addAllAbsent(Arrays.asList(three, four, one)));
103 >        assertEquals(5, full.size());
104 >        assertEquals(0, full.addAllAbsent(Arrays.asList(three, four, one)));
105          assertEquals(5, full.size());
106      }
107  
# Line 181 | Line 176 | public class CopyOnWriteArrayListTest ex
176          CopyOnWriteArrayList b = populatedArray(3);
177          assertTrue(a.equals(b));
178          assertTrue(b.equals(a));
179 +        assertTrue(a.containsAll(b));
180 +        assertTrue(b.containsAll(a));
181          assertEquals(a.hashCode(), b.hashCode());
182          a.add(m1);
183          assertFalse(a.equals(b));
184          assertFalse(b.equals(a));
185 +        assertTrue(a.containsAll(b));
186 +        assertFalse(b.containsAll(a));
187          b.add(m1);
188          assertTrue(a.equals(b));
189          assertTrue(b.equals(a));
190 +        assertTrue(a.containsAll(b));
191 +        assertTrue(b.containsAll(a));
192          assertEquals(a.hashCode(), b.hashCode());
193 +
194 +        assertFalse(a.equals(null));
195      }
196  
197      /**
198 <     * containsAll returns true for collection with subset of elements
198 >     * containsAll returns true for collections with subset of elements
199       */
200      public void testContainsAll() {
201          CopyOnWriteArrayList full = populatedArray(3);
202 <        Vector v = new Vector();
203 <        v.add(one);
204 <        v.add(two);
205 <        assertTrue(full.containsAll(v));
206 <        v.add(six);
207 <        assertFalse(full.containsAll(v));
202 >        assertTrue(full.containsAll(Arrays.asList()));
203 >        assertTrue(full.containsAll(Arrays.asList(one)));
204 >        assertTrue(full.containsAll(Arrays.asList(one, two)));
205 >        assertFalse(full.containsAll(Arrays.asList(one, two, six)));
206 >        assertFalse(full.containsAll(Arrays.asList(six)));
207 >
208 >        try {
209 >            full.containsAll(null);
210 >            shouldThrow();
211 >        } catch (NullPointerException success) {}
212      }
213  
214      /**
# Line 256 | Line 263 | public class CopyOnWriteArrayListTest ex
263          Integer[] elements = new Integer[SIZE];
264          for (int i = 0; i < SIZE; i++)
265              elements[i] = i;
266 <        Collections.shuffle(Arrays.asList(elements));
266 >        shuffle(elements);
267          Collection<Integer> full = populatedArray(elements);
268  
269          Iterator it = full.iterator();
# Line 264 | Line 271 | public class CopyOnWriteArrayListTest ex
271              assertTrue(it.hasNext());
272              assertEquals(elements[j], it.next());
273          }
274 <        assertFalse(it.hasNext());
275 <        try {
276 <            it.next();
277 <            shouldThrow();
278 <        } catch (NoSuchElementException success) {}
274 >        assertIteratorExhausted(it);
275 >    }
276 >
277 >    /**
278 >     * iterator of empty collection has no elements
279 >     */
280 >    public void testEmptyIterator() {
281 >        Collection c = new CopyOnWriteArrayList();
282 >        assertIteratorExhausted(c.iterator());
283      }
284  
285      /**
# Line 339 | Line 350 | public class CopyOnWriteArrayListTest ex
350          ListIterator i = full.listIterator(1);
351          int j;
352          for (j = 0; i.hasNext(); j++)
353 <            assertEquals(j+1, i.next());
353 >            assertEquals(j + 1, i.next());
354          assertEquals(2, j);
355      }
356  
# Line 383 | Line 394 | public class CopyOnWriteArrayListTest ex
394       */
395      public void testRemoveAll() {
396          CopyOnWriteArrayList full = populatedArray(3);
397 <        Vector v = new Vector();
398 <        v.add(one);
399 <        v.add(two);
389 <        full.removeAll(v);
397 >        assertTrue(full.removeAll(Arrays.asList(one, two)));
398 >        assertEquals(1, full.size());
399 >        assertFalse(full.removeAll(Arrays.asList(one, two)));
400          assertEquals(1, full.size());
401      }
402  
# Line 421 | Line 431 | public class CopyOnWriteArrayListTest ex
431          Integer[] elements = new Integer[SIZE];
432          for (int i = 0; i < SIZE; i++)
433              elements[i] = i;
434 <        Collections.shuffle(Arrays.asList(elements));
434 >        shuffle(elements);
435          Collection<Integer> full = populatedArray(elements);
436  
437          assertTrue(Arrays.equals(elements, full.toArray()));
# Line 439 | Line 449 | public class CopyOnWriteArrayListTest ex
449          a = new Integer[0];
450          assertSame(a, empty.toArray(a));
451  
452 <        a = new Integer[SIZE/2];
452 >        a = new Integer[SIZE / 2];
453          Arrays.fill(a, 42);
454          assertSame(a, empty.toArray(a));
455          assertNull(a[0]);
# Line 449 | Line 459 | public class CopyOnWriteArrayListTest ex
459          Integer[] elements = new Integer[SIZE];
460          for (int i = 0; i < SIZE; i++)
461              elements[i] = i;
462 <        Collections.shuffle(Arrays.asList(elements));
462 >        shuffle(elements);
463          Collection<Integer> full = populatedArray(elements);
464  
465          Arrays.fill(a, 42);
# Line 463 | Line 473 | public class CopyOnWriteArrayListTest ex
473          assertSame(a, full.toArray(a));
474          assertTrue(Arrays.equals(elements, a));
475  
476 <        a = new Integer[2*SIZE];
476 >        a = new Integer[2 * SIZE];
477          Arrays.fill(a, 42);
478          assertSame(a, full.toArray(a));
479          assertTrue(Arrays.equals(elements, Arrays.copyOf(a, SIZE)));

Diff Legend

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