| /* |
| * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 8079136 |
| * @library /test/lib |
| * @build jdk.test.lib.RandomFactory |
| * @run testng SubList |
| * @summary Basic functionality of sublists |
| * @key randomness |
| */ |
| |
| import java.util.AbstractList; |
| import java.util.Arrays; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.ConcurrentModificationException; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.Random; |
| import java.util.Vector; |
| |
| import org.testng.annotations.Test; |
| import org.testng.annotations.DataProvider; |
| |
| import jdk.test.lib.RandomFactory; |
| |
| |
| public class SubList extends org.testng.Assert { |
| |
| final Random rnd = RandomFactory.getRandom(); |
| |
| @Test(dataProvider = "modifiable") |
| public void testAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Integer e = rnd.nextInt(); |
| subList.add(e); |
| assertEquals(list.get(to), e); |
| assertEquals(subList.size(), to - from + 1); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.add(42); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| subList.add(42); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testAddAtPos(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| int i = rnd.nextInt(1 + to - from); |
| Integer e = rnd.nextInt(); |
| subList.add(i, e); |
| assertEquals(list.get(from + i), e); |
| assertEquals(subList.size(), to - from + 1); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModAddAtPos(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| int i = rnd.nextInt(1 + to - from); |
| subList.add(i, 42); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodAddAtPos(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| int i = rnd.nextInt(1 + to - from); |
| subList.add(i, 42); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testClear(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| subList.clear(); |
| assertTrue(subList.isEmpty()); |
| assertEquals(subList.size(), 0); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModClear(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.clear(); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodClear(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| subList.clear(); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testEquals(List<Integer> list, int from, int to) { |
| List<Integer> subList1 = list.subList(from, to); |
| List<Integer> subList2 = list.subList(from, to); |
| assertTrue(subList1.equals(subList2)); |
| assertEquals(subList1.hashCode(), subList2.hashCode()); |
| for (int i = 0; i != 16; ++i) { |
| int from3 = rnd.nextInt(1 + list.size()); |
| int to3 = from3 + rnd.nextInt(1 + list.size() - from3); |
| boolean equal = (to - from) == (to3 - from3); |
| for (int j = 0; j < to - from && j < to3 - from3; ++j) |
| equal &= list.get(from + j) == list.get(from3 + j); |
| List<Integer> subList3 = list.subList(from3, to3); |
| assertEquals(subList1.equals(subList3), equal); |
| } |
| } |
| |
| // @Test(dataProvider = "modifiable", |
| // expectedExceptions = ConcurrentModificationException.class) |
| // public void testModEquals(List<Integer> list, int from, int to) { |
| // List<Integer> subList = list.subList(from, to); |
| // list.add(42); |
| // subList.equals(subList); |
| // } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModHashCode(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.hashCode(); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testGet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int i = 0; i < to - from; ++i) |
| assertEquals(list.get(from + i), subList.get(i)); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModGet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.get(from); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testIndexOf(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| if (from < to) { |
| Integer e = list.get(from); |
| int j = subList.indexOf(e); |
| assertTrue(j == 0); |
| } |
| for (int i = 0; i < list.size(); ++i) { |
| Integer e = list.get(i); |
| int j = subList.indexOf(e); |
| if (i < from || i >= to) { |
| assertTrue(j == -1 || subList.get(j) == e); |
| } else { |
| assertTrue(j >= 0); |
| assertTrue(j <= i - from); |
| assertEquals(subList.get(j), e); |
| } |
| } |
| for (int i = 0; i < 16; ++i) { |
| Integer r = rnd.nextInt(); |
| if (list.contains(r)) continue; |
| int j = subList.indexOf(r); |
| assertTrue(j == -1); |
| } |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModIndexOf(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.indexOf(from); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testIterator(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Iterator<Integer> it = subList.iterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| assertEquals(list.get(i), it.next()); |
| } |
| assertFalse(it.hasNext()); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModIteratorNext(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Iterator<Integer> it = subList.iterator(); |
| list.add(42); |
| it.next(); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testIteratorRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Iterator<Integer> it = subList.iterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| assertEquals(list.get(from), it.next()); |
| it.remove(); |
| } |
| assertFalse(it.hasNext()); |
| assertTrue(subList.isEmpty()); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModIteratorRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Iterator<Integer> it = subList.iterator(); |
| it.next(); |
| list.add(42); |
| it.remove(); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodIteratorRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| Iterator<Integer> it = subList.iterator(); |
| it.next(); |
| it.remove(); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testIteratorForEachRemaining(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int k = 0; k < 16; ++k) { |
| int r = from + rnd.nextInt(1 + to - from); |
| Iterator<Integer> it = subList.iterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| if (i == r) { |
| Iterator<Integer> jt = list.listIterator(r); |
| it.forEachRemaining(x -> |
| assertTrue(jt.hasNext() && x == jt.next())); |
| break; |
| } |
| assertEquals(list.get(i), it.next()); |
| } |
| it.forEachRemaining(x -> fail()); |
| } |
| } |
| |
| @Test(dataProvider = "all") |
| public void testLastIndexOf(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| if (from < to) { |
| Integer e = list.get(to - 1); |
| int j = subList.lastIndexOf(e); |
| assertTrue(j == to - from - 1); |
| } |
| for (int i = 0; i < list.size(); ++i) { |
| Integer e = list.get(i); |
| int j = subList.lastIndexOf(e); |
| if (i < from || i >= to) { |
| assertTrue(j == -1 || subList.get(j) == e); |
| } else { |
| assertTrue(j >= 0 && j >= i - from); |
| assertEquals(subList.get(j), e); |
| } |
| } |
| for (int i = 0; i < 16; ++i) { |
| Integer r = rnd.nextInt(); |
| if (list.contains(r)) continue; |
| int j = subList.lastIndexOf(r); |
| assertTrue(j == -1); |
| } |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModLastIndexOf(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.lastIndexOf(42); |
| } |
| |
| @Test(dataProvider = "unresizable") |
| public void testListIterator(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| assertTrue(it.nextIndex() == i - from); |
| assertEquals(list.get(i), it.next()); |
| } |
| assertFalse(it.hasNext()); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModListIteratorNext(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| list.add(42); |
| it.next(); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testListIteratorSet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| assertTrue(it.nextIndex() == i - from); |
| assertEquals(list.get(i), it.next()); |
| Integer e = rnd.nextInt(); |
| it.set(e); |
| assertEquals(list.get(i), e); |
| } |
| assertFalse(it.hasNext()); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModListIteratorSet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| it.next(); |
| list.add(42); |
| it.set(42); |
| } |
| |
| @Test(dataProvider = "unsettable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodListIteratorSet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| it.next(); |
| it.set(42); |
| } |
| |
| @Test(dataProvider = "unresizable") |
| public void testListIteratorPrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(subList.size()); |
| for (int i = to - 1; i >= from; --i) { |
| assertTrue(it.hasPrevious()); |
| assertTrue(it.previousIndex() == i - from); |
| assertEquals(list.get(i), it.previous()); |
| } |
| assertFalse(it.hasPrevious()); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModListIteratorPrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(to - from); |
| list.add(42); |
| it.previous(); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testListIteratorSetPrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(subList.size()); |
| for (int i = to - 1; i >= from; --i) { |
| assertTrue(it.hasPrevious()); |
| assertTrue(it.previousIndex() == i - from); |
| assertEquals(list.get(i), it.previous()); |
| Integer e = rnd.nextInt(); |
| it.set(e); |
| assertEquals(list.get(i), e); |
| } |
| assertFalse(it.hasPrevious()); |
| } |
| |
| @Test(dataProvider = "unsettable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodListIteratorSetPrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(to - from); |
| it.previous(); |
| it.set(42); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testListIteratorAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int i = 0; i < 16; ++i) { |
| int r = rnd.nextInt(1 + subList.size()); |
| ListIterator<Integer> it = subList.listIterator(r); |
| Integer e = rnd.nextInt(); |
| it.add(e); |
| assertEquals(it.previous(), e); |
| assertEquals(list.get(from + r), e); |
| } |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodListIteratorAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| int r = rnd.nextInt(1 + subList.size()); |
| ListIterator<Integer> it = subList.listIterator(r); |
| it.add(42); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModListIteratorAdd(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| it.next(); |
| list.add(42); |
| it.add(42); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testListIteratorRemoveNext(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| for (int i = from; i < to; ++i) { |
| assertTrue(it.hasNext()); |
| assertTrue(it.nextIndex() == 0); |
| assertEquals(list.get(from), it.next()); |
| it.remove(); |
| } |
| assertFalse(it.hasNext()); |
| assertTrue(subList.isEmpty()); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodListIteratorRemoveNext(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| it.next(); |
| it.remove(); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModListIteratorRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(); |
| it.next(); |
| list.add(42); |
| it.remove(); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testListIteratorRemovePrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(subList.size()); |
| for (int i = to - 1; i >= from; --i) { |
| assertTrue(it.hasPrevious()); |
| assertTrue(it.previousIndex() == i - from); |
| assertEquals(list.get(i), it.previous()); |
| it.remove(); |
| } |
| assertFalse(it.hasPrevious()); |
| assertTrue(subList.isEmpty()); |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodListIteratorRemovePrevious(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| ListIterator<Integer> it = subList.listIterator(subList.size()); |
| it.previous(); |
| it.remove(); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int i = 0; i < 16; ++i) { |
| if (subList.isEmpty()) break; |
| int r = rnd.nextInt(subList.size()); |
| Integer e = list.get(from + r); |
| assertEquals(subList.remove(r), e); |
| } |
| } |
| |
| @Test(dataProvider = "unresizable", |
| expectedExceptions = UnsupportedOperationException.class) |
| public void testUnmodRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| int r = rnd.nextInt(subList.size()); |
| subList.remove(r); |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModRemove(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.remove(0); |
| } |
| |
| @Test(dataProvider = "modifiable") |
| public void testSet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int i = 0; i < to - from; ++i) { |
| Integer e0 = list.get(from + i); |
| Integer e1 = rnd.nextInt(); |
| assertEquals(subList.set(i, e1), e0); |
| assertEquals(list.get(from + i), e1); |
| } |
| } |
| |
| @Test(dataProvider = "modifiable", |
| expectedExceptions = ConcurrentModificationException.class) |
| public void testModSet(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| list.add(42); |
| subList.set(0, 42); |
| } |
| |
| @Test(dataProvider = "all") |
| public void testSubList(List<Integer> list, int from, int to) { |
| List<Integer> subList = list.subList(from, to); |
| for (int i = 0; i < 16 && from < to; ++i) { |
| int from1 = rnd.nextInt(to - from); |
| int to1 = from1 + 1 + rnd.nextInt(to - from - from1); |
| List<Integer> subSubList = subList.subList(from1, to1); |
| for (int j = 0; j < to1 - from1; ++j) |
| assertEquals(list.get(from + from1 + j), subSubList.get(j)); |
| } |
| } |
| |
| /** |
| * All kinds of lists |
| */ |
| @DataProvider |
| public static Object[][] all() { |
| Object[][] l1 = modifiable(); |
| Object[][] l2 = unresizable(); |
| Object[][] res = Arrays.copyOf(l1, l1.length + l2.length); |
| System.arraycopy(l2, 0, res, l1.length, l2.length); |
| return res; |
| } |
| |
| /** |
| * Lists that allow any modifications: resizing and setting values |
| */ |
| @DataProvider |
| public static Object[][] modifiable() { |
| final List<Integer> c1 = Arrays.asList(42); |
| final List<Integer> c9 = Arrays.asList(40, 41, 42, 43, 44, 45, -1, |
| Integer.MIN_VALUE, 1000500); |
| |
| return new Object[][] { |
| {new ArrayList<>(c1), 0, 1}, |
| {new LinkedList<>(c1), 0, 1}, |
| {new Vector<>(c1), 0, 1}, |
| {new ArrayList<>(c1).subList(0, 1), 0, 1}, |
| {new LinkedList<>(c1).subList(0, 1), 0, 1}, |
| {new Vector<>(c1).subList(0, 1), 0, 1}, |
| {Collections.checkedList(new ArrayList<>(c1), Integer.class), 0, 1}, |
| {Collections.checkedList(new LinkedList<>(c1), Integer.class), 0, 1}, |
| {Collections.checkedList(new Vector<>(c1), Integer.class), 0, 1}, |
| {Collections.synchronizedList(new ArrayList<>(c1)), 0, 1}, |
| {Collections.synchronizedList(new LinkedList<>(c1)), 0, 1}, |
| {Collections.synchronizedList(new Vector<>(c1)), 0, 1}, |
| |
| {new ArrayList<>(c9), 2, 5}, |
| {new LinkedList<>(c9), 2, 5}, |
| {new Vector<>(c9), 2, 5}, |
| {new ArrayList<>(c9).subList(1, 8), 1, 4}, |
| {new LinkedList<>(c9).subList(1, 8), 1, 4}, |
| {new Vector<>(c9).subList(1, 8), 1, 4}, |
| {Collections.checkedList(new ArrayList<>(c9), Integer.class), 2, 5}, |
| {Collections.checkedList(new LinkedList<>(c9), Integer.class), 2, 5}, |
| {Collections.checkedList(new Vector<>(c9), Integer.class), 2, 5}, |
| {Collections.synchronizedList(new ArrayList<>(c9)), 2, 5}, |
| {Collections.synchronizedList(new LinkedList<>(c9)), 2, 5}, |
| {Collections.synchronizedList(new Vector<>(c9)), 2, 5}, |
| }; |
| } |
| |
| /** |
| * Lists that don't allow resizing, but allow setting values |
| */ |
| @DataProvider |
| public static Object[][] unresizable() { |
| final List<Integer> c1 = Arrays.asList(42); |
| final List<Integer> c9 = Arrays.asList(40, 41, 42, 43, 44, 45, -1, |
| Integer.MIN_VALUE, 1000500); |
| |
| Object[][] l1 = unsettable(); |
| Object[][] l2 = { |
| {c1, 0, 1}, |
| {c1.subList(0, 1), 0, 1}, |
| {Collections.checkedList(c1, Integer.class), 0, 1}, |
| {Collections.synchronizedList(c1), 0, 1}, |
| {c9, 0, 4}, |
| {c9, 4, 6}, |
| {c9.subList(1, 8), 1, 4}, |
| {c9.subList(1, 8), 0, 7}, |
| {Collections.checkedList(c9, Integer.class), 3, 6}, |
| {Collections.synchronizedList(c9), 3, 5}, |
| }; |
| Object[][] res = Arrays.copyOf(l1, l1.length + l2.length); |
| System.arraycopy(l2, 0, res, l1.length, l2.length); |
| return res; |
| } |
| |
| /** |
| * Lists that don't allow either resizing or setting values |
| */ |
| @DataProvider |
| public static Object[][] unsettable() { |
| final List<Integer> c1 = Arrays.asList(42); |
| final List<Integer> c9 = Arrays.asList(40, 41, 42, 43, 44, 45, -1, |
| Integer.MIN_VALUE, 1000500); |
| |
| return new Object[][] { |
| {new MyList(1), 0, 1}, |
| {new MyList(1).subList(0, 1), 0, 1}, |
| {Collections.singletonList(42), 0, 1}, |
| {Collections.singletonList(42).subList(0, 1), 0, 1}, |
| {Collections.unmodifiableList(c1), 0, 1}, |
| {Collections.unmodifiableList(new ArrayList<>(c1)), 0, 1}, |
| {Collections.unmodifiableList(new LinkedList<>(c1)), 0, 1}, |
| {Collections.unmodifiableList(new Vector<>(c1)), 0, 1}, |
| |
| {new MyList(9), 3, 6}, |
| {new MyList(9).subList(2, 8), 3, 6}, |
| {Collections.unmodifiableList(c9), 3, 6}, |
| {Collections.unmodifiableList(new ArrayList<>(c9)), 3, 6}, |
| {Collections.unmodifiableList(new LinkedList<>(c9)), 3, 6}, |
| {Collections.unmodifiableList(new Vector<>(c9)), 3, 6}, |
| }; |
| } |
| |
| static class MyList extends AbstractList<Integer> { |
| private int size; |
| MyList(int s) { size = s; } |
| public Integer get(int index) { return 42; } |
| public int size() { return size; } |
| } |
| } |
