--- jsr166/src/test/tck/VectorTest.java	2016/11/14 23:52:22	1.2
+++ jsr166/src/test/tck/VectorTest.java	2018/04/03 05:49:44	1.8
@@ -5,12 +5,15 @@
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
-import java.util.Vector;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.ThreadLocalRandom;
 
 import junit.framework.Test;
-import junit.framework.TestSuite;
 
 public class VectorTest extends JSR166TestCase {
     public static void main(String[] args) {
@@ -27,13 +30,424 @@ public class VectorTest extends JSR166Te
         }
         class SubListImplementation extends Implementation {
             public List emptyCollection() {
-                return super.emptyCollection().subList(0, 0);
+                List list = super.emptyCollection();
+                ThreadLocalRandom rnd = ThreadLocalRandom.current();
+                if (rnd.nextBoolean())
+                    list.add(makeElement(rnd.nextInt()));
+                int i = rnd.nextInt(list.size() + 1);
+                return list.subList(i, i);
             }
         }
         return newTestSuite(
-                // VectorTest.class,
+                VectorTest.class,
                 CollectionTest.testSuite(new Implementation()),
                 CollectionTest.testSuite(new SubListImplementation()));
     }
 
+    static Vector<Integer> populatedList(int n) {
+        Vector<Integer> list = new Vector<>();
+        assertTrue(list.isEmpty());
+        for (int i = 0; i < n; i++)
+            list.add(i);
+        assertEquals(n <= 0, list.isEmpty());
+        assertEquals(n, list.size());
+        return list;
+    }
+
+    /**
+     * addAll adds each element from the given collection, including duplicates
+     */
+    public void testAddAll() {
+        List list = populatedList(3);
+        assertTrue(list.addAll(Arrays.asList(three, four, five)));
+        assertEquals(6, list.size());
+        assertTrue(list.addAll(Arrays.asList(three, four, five)));
+        assertEquals(9, list.size());
+    }
+
+    /**
+     * clear removes all elements from the list
+     */
+    public void testClear() {
+        List list = populatedList(SIZE);
+        list.clear();
+        assertEquals(0, list.size());
+    }
+
+    /**
+     * Cloned list is equal
+     */
+    public void testClone() {
+        Vector l1 = populatedList(SIZE);
+        Vector l2 = (Vector)(l1.clone());
+        assertEquals(l1, l2);
+        l1.clear();
+        assertFalse(l1.equals(l2));
+    }
+
+    /**
+     * contains is true for added elements
+     */
+    public void testContains() {
+        List list = populatedList(3);
+        assertTrue(list.contains(one));
+        assertFalse(list.contains(five));
+    }
+
+    /**
+     * adding at an index places it in the indicated index
+     */
+    public void testAddIndex() {
+        List list = populatedList(3);
+        list.add(0, m1);
+        assertEquals(4, list.size());
+        assertEquals(m1, list.get(0));
+        assertEquals(zero, list.get(1));
+
+        list.add(2, m2);
+        assertEquals(5, list.size());
+        assertEquals(m2, list.get(2));
+        assertEquals(two, list.get(4));
+    }
+
+    /**
+     * lists with same elements are equal and have same hashCode
+     */
+    public void testEquals() {
+        List a = populatedList(3);
+        List b = populatedList(3);
+        assertTrue(a.equals(b));
+        assertTrue(b.equals(a));
+        assertTrue(a.containsAll(b));
+        assertTrue(b.containsAll(a));
+        assertEquals(a.hashCode(), b.hashCode());
+        a.add(m1);
+        assertFalse(a.equals(b));
+        assertFalse(b.equals(a));
+        assertTrue(a.containsAll(b));
+        assertFalse(b.containsAll(a));
+        b.add(m1);
+        assertTrue(a.equals(b));
+        assertTrue(b.equals(a));
+        assertTrue(a.containsAll(b));
+        assertTrue(b.containsAll(a));
+        assertEquals(a.hashCode(), b.hashCode());
+
+        assertFalse(a.equals(null));
+    }
+
+    /**
+     * containsAll returns true for collections with subset of elements
+     */
+    public void testContainsAll() {
+        List list = populatedList(3);
+        assertTrue(list.containsAll(Arrays.asList()));
+        assertTrue(list.containsAll(Arrays.asList(one)));
+        assertTrue(list.containsAll(Arrays.asList(one, two)));
+        assertFalse(list.containsAll(Arrays.asList(one, two, six)));
+        assertFalse(list.containsAll(Arrays.asList(six)));
+
+        try {
+            list.containsAll(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * get returns the value at the given index
+     */
+    public void testGet() {
+        List list = populatedList(3);
+        assertEquals(0, list.get(0));
+    }
+
+    /**
+     * indexOf(Object) returns the index of the first occurrence of the
+     * specified element in this list, or -1 if this list does not
+     * contain the element
+     */
+    public void testIndexOf() {
+        List list = populatedList(3);
+        assertEquals(-1, list.indexOf(-42));
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            assertEquals(i, list.indexOf(i));
+            assertEquals(i, list.subList(0, size).indexOf(i));
+            assertEquals(i, list.subList(0, i + 1).indexOf(i));
+            assertEquals(-1, list.subList(0, i).indexOf(i));
+            assertEquals(0, list.subList(i, size).indexOf(i));
+            assertEquals(-1, list.subList(i + 1, size).indexOf(i));
+        }
+
+        list.add(1);
+        assertEquals(1, list.indexOf(1));
+        assertEquals(1, list.subList(0, size + 1).indexOf(1));
+        assertEquals(0, list.subList(1, size + 1).indexOf(1));
+        assertEquals(size - 2, list.subList(2, size + 1).indexOf(1));
+        assertEquals(0, list.subList(size, size + 1).indexOf(1));
+        assertEquals(-1, list.subList(size + 1, size + 1).indexOf(1));
+    }
+
+    /**
+     * indexOf(E, int) returns the index of the first occurrence of the
+     * specified element in this list, searching forwards from index,
+     * or returns -1 if the element is not found
+     */
+    public void testIndexOf2() {
+        Vector list = populatedList(3);
+        int size = list.size();
+        assertEquals(-1, list.indexOf(-42, 0));
+
+        // we might expect IOOBE, but spec says otherwise
+        assertEquals(-1, list.indexOf(0, size));
+        assertEquals(-1, list.indexOf(0, Integer.MAX_VALUE));
+
+        assertThrows(
+            IndexOutOfBoundsException.class,
+            () -> list.indexOf(0, -1),
+            () -> list.indexOf(0, Integer.MIN_VALUE));
+
+        for (int i = 0; i < size; i++) {
+            assertEquals(i, list.indexOf(i, 0));
+            assertEquals(i, list.indexOf(i, i));
+            assertEquals(-1, list.indexOf(i, i + 1));
+        }
+
+        list.add(1);
+        assertEquals(1, list.indexOf(1, 0));
+        assertEquals(1, list.indexOf(1, 1));
+        assertEquals(size, list.indexOf(1, 2));
+        assertEquals(size, list.indexOf(1, size));
+    }
+
+    /**
+     * isEmpty returns true when empty, else false
+     */
+    public void testIsEmpty() {
+        List empty = new Vector();
+        assertTrue(empty.isEmpty());
+        assertTrue(empty.subList(0, 0).isEmpty());
+
+        List full = populatedList(SIZE);
+        assertFalse(full.isEmpty());
+        assertTrue(full.subList(0, 0).isEmpty());
+        assertTrue(full.subList(SIZE, SIZE).isEmpty());
+    }
+
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        Collection c = new Vector();
+        assertIteratorExhausted(c.iterator());
+    }
+
+    /**
+     * lastIndexOf(Object) returns the index of the last occurrence of
+     * the specified element in this list, or -1 if this list does not
+     * contain the element
+     */
+    public void testLastIndexOf1() {
+        List list = populatedList(3);
+        assertEquals(-1, list.lastIndexOf(-42));
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            assertEquals(i, list.lastIndexOf(i));
+            assertEquals(i, list.subList(0, size).lastIndexOf(i));
+            assertEquals(i, list.subList(0, i + 1).lastIndexOf(i));
+            assertEquals(-1, list.subList(0, i).lastIndexOf(i));
+            assertEquals(0, list.subList(i, size).lastIndexOf(i));
+            assertEquals(-1, list.subList(i + 1, size).lastIndexOf(i));
+        }
+
+        list.add(1);
+        assertEquals(size, list.lastIndexOf(1));
+        assertEquals(size, list.subList(0, size + 1).lastIndexOf(1));
+        assertEquals(1, list.subList(0, size).lastIndexOf(1));
+        assertEquals(0, list.subList(1, 2).lastIndexOf(1));
+        assertEquals(-1, list.subList(0, 1).indexOf(1));
+    }
+
+    /**
+     * lastIndexOf(E, int) returns the index of the last occurrence of the
+     * specified element in this list, searching backwards from index, or
+     * returns -1 if the element is not found
+     */
+    public void testLastIndexOf2() {
+        Vector list = populatedList(3);
+
+        // we might expect IOOBE, but spec says otherwise
+        assertEquals(-1, list.lastIndexOf(0, -1));
+
+        int size = list.size();
+        assertThrows(
+            IndexOutOfBoundsException.class,
+            () -> list.lastIndexOf(0, size),
+            () -> list.lastIndexOf(0, Integer.MAX_VALUE));
+
+        for (int i = 0; i < size; i++) {
+            assertEquals(i, list.lastIndexOf(i, i));
+            assertEquals(list.indexOf(i), list.lastIndexOf(i, i));
+            if (i > 0)
+                assertEquals(-1, list.lastIndexOf(i, i - 1));
+        }
+        list.add(one);
+        list.add(three);
+        assertEquals(1, list.lastIndexOf(one, 1));
+        assertEquals(1, list.lastIndexOf(one, 2));
+        assertEquals(3, list.lastIndexOf(one, 3));
+        assertEquals(3, list.lastIndexOf(one, 4));
+        assertEquals(-1, list.lastIndexOf(three, 3));
+    }
+
+    /**
+     * size returns the number of elements
+     */
+    public void testSize() {
+        List empty = new Vector();
+        assertEquals(0, empty.size());
+        assertEquals(0, empty.subList(0, 0).size());
+
+        List full = populatedList(SIZE);
+        assertEquals(SIZE, full.size());
+        assertEquals(0, full.subList(0, 0).size());
+        assertEquals(0, full.subList(SIZE, SIZE).size());
+    }
+
+    /**
+     * sublists contains elements at indexes offset from their base
+     */
+    public void testSubList() {
+        List a = populatedList(10);
+        assertTrue(a.subList(1,1).isEmpty());
+        for (int j = 0; j < 9; ++j) {
+            for (int i = j ; i < 10; ++i) {
+                List b = a.subList(j,i);
+                for (int k = j; k < i; ++k) {
+                    assertEquals(new Integer(k), b.get(k-j));
+                }
+            }
+        }
+
+        List s = a.subList(2, 5);
+        assertEquals(3, s.size());
+        s.set(2, m1);
+        assertEquals(a.get(4), m1);
+        s.clear();
+        assertEquals(7, a.size());
+
+        assertThrows(
+            IndexOutOfBoundsException.class,
+            () -> s.get(0),
+            () -> s.set(0, 42));
+    }
+
+    /**
+     * toArray throws an ArrayStoreException when the given array
+     * can not store the objects inside the list
+     */
+    public void testToArray_ArrayStoreException() {
+        List list = new Vector();
+        // Integers are not auto-converted to Longs
+        list.add(86);
+        list.add(99);
+        assertThrows(
+            ArrayStoreException.class,
+            () -> list.toArray(new Long[0]),
+            () -> list.toArray(new Long[5]));
+    }
+
+    void testIndexOutOfBoundsException(List list) {
+        int size = list.size();
+        assertThrows(
+            IndexOutOfBoundsException.class,
+            () -> list.get(-1),
+            () -> list.get(size),
+            () -> list.set(-1, "qwerty"),
+            () -> list.set(size, "qwerty"),
+            () -> list.add(-1, "qwerty"),
+            () -> list.add(size + 1, "qwerty"),
+            () -> list.remove(-1),
+            () -> list.remove(size),
+            () -> list.addAll(-1, Collections.emptyList()),
+            () -> list.addAll(size + 1, Collections.emptyList()),
+            () -> list.listIterator(-1),
+            () -> list.listIterator(size + 1),
+            () -> list.subList(-1, size),
+            () -> list.subList(0, size + 1));
+
+        // Conversely, operations that must not throw
+        list.addAll(0, Collections.emptyList());
+        list.addAll(size, Collections.emptyList());
+        list.add(0, "qwerty");
+        list.add(list.size(), "qwerty");
+        list.get(0);
+        list.get(list.size() - 1);
+        list.set(0, "azerty");
+        list.set(list.size() - 1, "azerty");
+        list.listIterator(0);
+        list.listIterator(list.size());
+        list.subList(0, list.size());
+        list.remove(list.size() - 1);
+    }
+
+    /**
+     * IndexOutOfBoundsException is thrown when specified
+     */
+    public void testIndexOutOfBoundsException() {
+        ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        List x = populatedList(rnd.nextInt(5));
+        testIndexOutOfBoundsException(x);
+
+        int start = rnd.nextInt(x.size() + 1);
+        int end = rnd.nextInt(start, x.size() + 1);
+
+        // Vector#subList spec deviates slightly from List#subList spec
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> x.subList(start, start - 1));
+
+        List subList = x.subList(start, end);
+        testIndexOutOfBoundsException(x);
+    }
+
+    /**
+     * a deserialized/reserialized list equals original
+     */
+    public void testSerialization() throws Exception {
+        List x = populatedList(SIZE);
+        List y = serialClone(x);
+
+        assertNotSame(x, y);
+        assertEquals(x.size(), y.size());
+        assertEquals(x.toString(), y.toString());
+        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
+        assertEquals(x, y);
+        assertEquals(y, x);
+        while (!x.isEmpty()) {
+            assertFalse(y.isEmpty());
+            assertEquals(x.remove(0), y.remove(0));
+        }
+        assertTrue(y.isEmpty());
+    }
+
+    /**
+     * tests for setSize()
+     */
+    public void testSetSize() {
+        final Vector v = new Vector();
+        for (int n : new int[] { 100, 5, 50 }) {
+            v.setSize(n);
+            assertEquals(n, v.size());
+            assertNull(v.get(0));
+            assertNull(v.get(n - 1));
+            assertThrows(
+                    ArrayIndexOutOfBoundsException.class,
+                    new Runnable() { public void run() { v.setSize(-1); }});
+            assertEquals(n, v.size());
+            assertNull(v.get(0));
+            assertNull(v.get(n - 1));
+        }
+    }
+
 }