--- jsr166/src/test/tck/CopyOnWriteArrayListTest.java 2018/01/07 07:07:20 1.46 +++ jsr166/src/test/tck/CopyOnWriteArrayListTest.java 2018/04/03 05:49:43 1.49 @@ -9,12 +9,13 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Collections; import java.util.Iterator; -import java.util.LinkedList; import java.util.List; import java.util.ListIterator; import java.util.NoSuchElementException; import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.ThreadLocalRandom; import junit.framework.Test; @@ -34,7 +35,12 @@ public class CopyOnWriteArrayListTest ex } 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( @@ -43,67 +49,67 @@ public class CopyOnWriteArrayListTest ex CollectionTest.testSuite(new SubListImplementation())); } - static CopyOnWriteArrayList populatedArray(int n) { - CopyOnWriteArrayList a = new CopyOnWriteArrayList<>(); - assertTrue(a.isEmpty()); + static CopyOnWriteArrayList populatedList(int n) { + CopyOnWriteArrayList list = new CopyOnWriteArrayList<>(); + assertTrue(list.isEmpty()); for (int i = 0; i < n; i++) - a.add(i); - assertFalse(a.isEmpty()); - assertEquals(n, a.size()); - return a; + list.add(i); + assertEquals(n <= 0, list.isEmpty()); + assertEquals(n, list.size()); + return list; } - static CopyOnWriteArrayList populatedArray(Integer[] elements) { - CopyOnWriteArrayList a = new CopyOnWriteArrayList<>(); - assertTrue(a.isEmpty()); + static CopyOnWriteArrayList populatedList(Integer[] elements) { + CopyOnWriteArrayList list = new CopyOnWriteArrayList<>(); + assertTrue(list.isEmpty()); for (Integer element : elements) - a.add(element); - assertFalse(a.isEmpty()); - assertEquals(elements.length, a.size()); - return a; + list.add(element); + assertFalse(list.isEmpty()); + assertEquals(elements.length, list.size()); + return list; } /** * a new list is empty */ public void testConstructor() { - CopyOnWriteArrayList a = new CopyOnWriteArrayList(); - assertTrue(a.isEmpty()); + List list = new CopyOnWriteArrayList(); + assertTrue(list.isEmpty()); } /** * new list contains all elements of initializing array */ public void testConstructor2() { - Integer[] ints = new Integer[SIZE]; + Integer[] elts = new Integer[SIZE]; for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); - CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints); + elts[i] = i; + List list = new CopyOnWriteArrayList(elts); for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], a.get(i)); + assertEquals(elts[i], list.get(i)); } /** * new list contains all elements of initializing collection */ public void testConstructor3() { - Integer[] ints = new Integer[SIZE]; + Integer[] elts = new Integer[SIZE]; for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); - CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints)); + elts[i] = i; + List list = new CopyOnWriteArrayList(Arrays.asList(elts)); for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], a.get(i)); + assertEquals(elts[i], list.get(i)); } /** * addAll adds each element from the given collection, including duplicates */ public void testAddAll() { - CopyOnWriteArrayList full = populatedArray(3); - assertTrue(full.addAll(Arrays.asList(three, four, five))); - assertEquals(6, full.size()); - assertTrue(full.addAll(Arrays.asList(three, four, five))); - assertEquals(9, full.size()); + 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()); } /** @@ -111,46 +117,46 @@ public class CopyOnWriteArrayListTest ex * already exist in the List */ public void testAddAllAbsent() { - CopyOnWriteArrayList full = populatedArray(3); + CopyOnWriteArrayList list = populatedList(3); // "one" is duplicate and will not be added - assertEquals(2, full.addAllAbsent(Arrays.asList(three, four, one))); - assertEquals(5, full.size()); - assertEquals(0, full.addAllAbsent(Arrays.asList(three, four, one))); - assertEquals(5, full.size()); + assertEquals(2, list.addAllAbsent(Arrays.asList(three, four, one))); + assertEquals(5, list.size()); + assertEquals(0, list.addAllAbsent(Arrays.asList(three, four, one))); + assertEquals(5, list.size()); } /** * addIfAbsent will not add the element if it already exists in the list */ public void testAddIfAbsent() { - CopyOnWriteArrayList full = populatedArray(SIZE); - full.addIfAbsent(one); - assertEquals(SIZE, full.size()); + CopyOnWriteArrayList list = populatedList(SIZE); + list.addIfAbsent(one); + assertEquals(SIZE, list.size()); } /** * addIfAbsent adds the element when it does not exist in the list */ public void testAddIfAbsent2() { - CopyOnWriteArrayList full = populatedArray(SIZE); - full.addIfAbsent(three); - assertTrue(full.contains(three)); + CopyOnWriteArrayList list = populatedList(SIZE); + list.addIfAbsent(three); + assertTrue(list.contains(three)); } /** * clear removes all elements from the list */ public void testClear() { - CopyOnWriteArrayList full = populatedArray(SIZE); - full.clear(); - assertEquals(0, full.size()); + List list = populatedList(SIZE); + list.clear(); + assertEquals(0, list.size()); } /** * Cloned list is equal */ public void testClone() { - CopyOnWriteArrayList l1 = populatedArray(SIZE); + CopyOnWriteArrayList l1 = populatedList(SIZE); CopyOnWriteArrayList l2 = (CopyOnWriteArrayList)(l1.clone()); assertEquals(l1, l2); l1.clear(); @@ -161,33 +167,33 @@ public class CopyOnWriteArrayListTest ex * contains is true for added elements */ public void testContains() { - CopyOnWriteArrayList full = populatedArray(3); - assertTrue(full.contains(one)); - assertFalse(full.contains(five)); + 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() { - CopyOnWriteArrayList full = populatedArray(3); - full.add(0, m1); - assertEquals(4, full.size()); - assertEquals(m1, full.get(0)); - assertEquals(zero, full.get(1)); - - full.add(2, m2); - assertEquals(5, full.size()); - assertEquals(m2, full.get(2)); - assertEquals(two, full.get(4)); + 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() { - CopyOnWriteArrayList a = populatedArray(3); - CopyOnWriteArrayList b = populatedArray(3); + List a = populatedList(3); + List b = populatedList(3); assertTrue(a.equals(b)); assertTrue(b.equals(a)); assertTrue(a.containsAll(b)); @@ -212,15 +218,15 @@ public class CopyOnWriteArrayListTest ex * containsAll returns true for collections with subset of elements */ public void testContainsAll() { - CopyOnWriteArrayList full = populatedArray(3); - assertTrue(full.containsAll(Arrays.asList())); - assertTrue(full.containsAll(Arrays.asList(one))); - assertTrue(full.containsAll(Arrays.asList(one, two))); - assertFalse(full.containsAll(Arrays.asList(one, two, six))); - assertFalse(full.containsAll(Arrays.asList(six))); + 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 { - full.containsAll(null); + list.containsAll(null); shouldThrow(); } catch (NullPointerException success) {} } @@ -229,37 +235,81 @@ public class CopyOnWriteArrayListTest ex * get returns the value at the given index */ public void testGet() { - CopyOnWriteArrayList full = populatedArray(3); - assertEquals(0, full.get(0)); + List list = populatedList(3); + assertEquals(0, list.get(0)); } /** - * indexOf gives the index for the given object + * 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() { - CopyOnWriteArrayList full = populatedArray(3); - assertEquals(1, full.indexOf(one)); - assertEquals(-1, full.indexOf("puppies")); + 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 gives the index based on the given index - * at which to start searching + * 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() { - CopyOnWriteArrayList full = populatedArray(3); - assertEquals(1, full.indexOf(one, 0)); - assertEquals(-1, full.indexOf(one, 2)); + CopyOnWriteArrayList 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() { - CopyOnWriteArrayList empty = new CopyOnWriteArrayList(); - CopyOnWriteArrayList full = populatedArray(SIZE); + List empty = new CopyOnWriteArrayList(); 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()); } /** @@ -278,7 +328,7 @@ public class CopyOnWriteArrayListTest ex for (int i = 0; i < SIZE; i++) elements[i] = i; shuffle(elements); - Collection full = populatedArray(elements); + Collection full = populatedList(elements); Iterator it = full.iterator(); for (int j = 0; j < SIZE; j++) { @@ -300,8 +350,8 @@ public class CopyOnWriteArrayListTest ex * iterator.remove throws UnsupportedOperationException */ public void testIteratorRemove() { - CopyOnWriteArrayList full = populatedArray(SIZE); - Iterator it = full.iterator(); + CopyOnWriteArrayList list = populatedList(SIZE); + Iterator it = list.iterator(); it.next(); try { it.remove(); @@ -314,42 +364,78 @@ public class CopyOnWriteArrayListTest ex */ public void testToString() { assertEquals("[]", new CopyOnWriteArrayList().toString()); - CopyOnWriteArrayList full = populatedArray(3); - String s = full.toString(); + List list = populatedList(3); + String s = list.toString(); for (int i = 0; i < 3; ++i) assertTrue(s.contains(String.valueOf(i))); - assertEquals(new ArrayList(full).toString(), - full.toString()); + assertEquals(new ArrayList(list).toString(), + list.toString()); } /** - * lastIndexOf returns the index for the given object + * 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() { - CopyOnWriteArrayList full = populatedArray(3); - full.add(one); - full.add(three); - assertEquals(3, full.lastIndexOf(one)); - assertEquals(-1, full.lastIndexOf(six)); + 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 returns the index from the given starting point + * 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() { - CopyOnWriteArrayList full = populatedArray(3); - full.add(one); - full.add(three); - assertEquals(3, full.lastIndexOf(one, 4)); - assertEquals(-1, full.lastIndexOf(three, 3)); + CopyOnWriteArrayList 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)); } /** * listIterator traverses all elements */ public void testListIterator1() { - CopyOnWriteArrayList full = populatedArray(SIZE); - ListIterator i = full.listIterator(); + List list = populatedList(SIZE); + ListIterator i = list.listIterator(); int j; for (j = 0; i.hasNext(); j++) assertEquals(j, i.next()); @@ -360,8 +446,8 @@ public class CopyOnWriteArrayListTest ex * listIterator only returns those elements after the given index */ public void testListIterator2() { - CopyOnWriteArrayList full = populatedArray(3); - ListIterator i = full.listIterator(1); + List list = populatedList(3); + ListIterator i = list.listIterator(1); int j; for (j = 0; i.hasNext(); j++) assertEquals(j + 1, i.next()); @@ -374,10 +460,10 @@ public class CopyOnWriteArrayListTest ex public void testRemove_int() { int SIZE = 3; for (int i = 0; i < SIZE; i++) { - CopyOnWriteArrayList full = populatedArray(SIZE); - assertEquals(i, full.remove(i)); - assertEquals(SIZE - 1, full.size()); - assertFalse(full.contains(new Integer(i))); + List list = populatedList(SIZE); + assertEquals(i, list.remove(i)); + assertEquals(SIZE - 1, list.size()); + assertFalse(list.contains(new Integer(i))); } } @@ -387,11 +473,11 @@ public class CopyOnWriteArrayListTest ex public void testRemove_Object() { int SIZE = 3; for (int i = 0; i < SIZE; i++) { - CopyOnWriteArrayList full = populatedArray(SIZE); - assertFalse(full.remove(new Integer(-42))); - assertTrue(full.remove(new Integer(i))); - assertEquals(SIZE - 1, full.size()); - assertFalse(full.contains(new Integer(i))); + List list = populatedList(SIZE); + assertFalse(list.remove(new Integer(-42))); + assertTrue(list.remove(new Integer(i))); + assertEquals(SIZE - 1, list.size()); + assertFalse(list.contains(new Integer(i))); } CopyOnWriteArrayList x = new CopyOnWriteArrayList(Arrays.asList(4, 5, 6)); assertTrue(x.remove(new Integer(6))); @@ -407,30 +493,34 @@ public class CopyOnWriteArrayListTest ex * removeAll removes all elements from the given collection */ public void testRemoveAll() { - CopyOnWriteArrayList full = populatedArray(3); - assertTrue(full.removeAll(Arrays.asList(one, two))); - assertEquals(1, full.size()); - assertFalse(full.removeAll(Arrays.asList(one, two))); - assertEquals(1, full.size()); + List list = populatedList(3); + assertTrue(list.removeAll(Arrays.asList(one, two))); + assertEquals(1, list.size()); + assertFalse(list.removeAll(Arrays.asList(one, two))); + assertEquals(1, list.size()); } /** * set changes the element at the given index */ public void testSet() { - CopyOnWriteArrayList full = populatedArray(3); - assertEquals(2, full.set(2, four)); - assertEquals(4, full.get(2)); + List list = populatedList(3); + assertEquals(2, list.set(2, four)); + assertEquals(4, list.get(2)); } /** * size returns the number of elements */ public void testSize() { - CopyOnWriteArrayList empty = new CopyOnWriteArrayList(); - CopyOnWriteArrayList full = populatedArray(SIZE); - assertEquals(SIZE, full.size()); + List empty = new CopyOnWriteArrayList(); 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()); } /** @@ -446,7 +536,7 @@ public class CopyOnWriteArrayListTest ex for (int i = 0; i < SIZE; i++) elements[i] = i; shuffle(elements); - Collection full = populatedArray(elements); + Collection full = populatedList(elements); assertTrue(Arrays.equals(elements, full.toArray())); assertSame(Object[].class, full.toArray().getClass()); @@ -474,7 +564,7 @@ public class CopyOnWriteArrayListTest ex for (int i = 0; i < SIZE; i++) elements[i] = i; shuffle(elements); - Collection full = populatedArray(elements); + Collection full = populatedList(elements); Arrays.fill(a, 42); assertTrue(Arrays.equals(elements, full.toArray(a))); @@ -500,7 +590,7 @@ public class CopyOnWriteArrayListTest ex * sublists contains elements at indexes offset from their base */ public void testSubList() { - CopyOnWriteArrayList a = populatedArray(10); + List a = populatedList(10); assertTrue(a.subList(1,1).isEmpty()); for (int j = 0; j < 9; ++j) { for (int i = j ; i < 10; ++i) { @@ -517,6 +607,11 @@ public class CopyOnWriteArrayListTest ex assertEquals(a.get(4), m1); s.clear(); assertEquals(7, a.size()); + + assertThrows( + IndexOutOfBoundsException.class, + () -> s.get(0), + () -> s.set(0, 42)); } // Exception tests @@ -526,231 +621,72 @@ public class CopyOnWriteArrayListTest ex * can not store the objects inside the list */ public void testToArray_ArrayStoreException() { - CopyOnWriteArrayList c = new CopyOnWriteArrayList(); - c.add("zfasdfsdf"); - c.add("asdadasd"); - try { - c.toArray(new Long[5]); - shouldThrow(); - } catch (ArrayStoreException success) {} - } - - /** - * get throws an IndexOutOfBoundsException on a negative index - */ - public void testGet1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.get(-1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * get throws an IndexOutOfBoundsException on a too high index - */ - public void testGet2_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.get(list.size()); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } + List list = new CopyOnWriteArrayList(); + // 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); } /** - * set throws an IndexOutOfBoundsException on a negative index - */ - public void testSet1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.set(-1, "qwerty"); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * set throws an IndexOutOfBoundsException on a too high index - */ - public void testSet2() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.set(list.size(), "qwerty"); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * add throws an IndexOutOfBoundsException on a negative index - */ - public void testAdd1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.add(-1, "qwerty"); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * add throws an IndexOutOfBoundsException on a too high index - */ - public void testAdd2_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.add(list.size() + 1, "qwerty"); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * remove throws an IndexOutOfBoundsException on a negative index - */ - public void testRemove1_IndexOutOfBounds() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.remove(-1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * remove throws an IndexOutOfBoundsException on a too high index - */ - public void testRemove2_IndexOutOfBounds() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.remove(list.size()); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * addAll throws an IndexOutOfBoundsException on a negative index - */ - public void testAddAll1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.addAll(-1, new LinkedList()); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * addAll throws an IndexOutOfBoundsException on a too high index - */ - public void testAddAll2_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.addAll(list.size() + 1, new LinkedList()); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * listIterator throws an IndexOutOfBoundsException on a negative index - */ - public void testListIterator1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.listIterator(-1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * listIterator throws an IndexOutOfBoundsException on a too high index - */ - public void testListIterator2_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.listIterator(list.size() + 1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * subList throws an IndexOutOfBoundsException on a negative index - */ - public void testSubList1_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.subList(-1, list.size()); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * subList throws an IndexOutOfBoundsException on a too high index - */ - public void testSubList2_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.subList(0, list.size() + 1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } - } - - /** - * subList throws IndexOutOfBoundsException when the second index - * is lower then the first - */ - public void testSubList3_IndexOutOfBoundsException() { - CopyOnWriteArrayList c = populatedArray(5); - List[] lists = { c, c.subList(1, c.size() - 1) }; - for (List list : lists) { - try { - list.subList(list.size() - 1, 1); - shouldThrow(); - } catch (IndexOutOfBoundsException success) {} - } + * 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); + assertThrows( + IndexOutOfBoundsException.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 = populatedArray(SIZE); + List x = populatedList(SIZE); List y = serialClone(x); assertNotSame(x, y);