1 /*
2  * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 /**
25  * @test
26  * @bug 4327164 8229338
27  * @summary Basic test for new RandomAccess interface
28  * @run testng Basic
29  */
30 
31 import org.testng.annotations.DataProvider;
32 import org.testng.annotations.Test;
33 
34 import static org.testng.Assert.assertEquals;
35 
36 import java.util.*;
37 import java.util.concurrent.CopyOnWriteArrayList;
38 import java.util.function.Function;
39 import java.util.function.Supplier;
40 
41 public class Basic {
42 
43     /*
44      * Lists which implement Random Access interface
45      */
46     @DataProvider(name = "testLists")
testData()47     public Object[][] testData() {
48         var intArray = new Integer[100];
49         var stack = new Stack<>();
50         var random = new Random();
51         for (int i = 0; i < 100; i++) {
52             var r = random.nextInt(100);
53             stack.push(r);
54             intArray[i] = r;
55         }
56         List<Integer> list = Arrays.asList(intArray);
57         return new Object[][]{
58                 {list, true, "Arrays.asList"},
59                 {stack, true, "Stack"},
60                 {new ArrayList<>(list), true, "ArrayList"},
61                 {new LinkedList<>(list), false, "LinkedList"},
62                 {new Vector<>(list), true, "Vector"},
63                 {new CopyOnWriteArrayList<>(list), true, "CopyOnWriteArrayList"}
64         };
65     }
66 
67     @Test(dataProvider = "testLists")
testRandomAccess(List<Integer> list, boolean expectedRA, String failMsg)68     public void testRandomAccess(List<Integer> list, boolean expectedRA, String failMsg) {
69 
70         var actualRA = list instanceof RandomAccess;
71         assertEquals(actualRA, expectedRA, failMsg);
72 
73         List<Integer> unmodList = Collections.unmodifiableList(list);
74         List<Integer> syncList = Collections.synchronizedList(list);
75         assertEquals((unmodList instanceof RandomAccess), actualRA,
76                 "Unmodifiable fails to preserve RandomAccess");
77         assertEquals((syncList instanceof RandomAccess), actualRA,
78                 "Synchronized fails to preserve RandomAccess");
79 
80         while (list.size() > 0) {
81             list = list.subList(0, list.size() - 1);
82             assertEquals((list instanceof RandomAccess), actualRA,
83                     "SubList fails to preserve RandomAccess: " + list.size());
84 
85             unmodList = unmodList.subList(0, unmodList.size() - 1);
86             assertEquals((unmodList instanceof RandomAccess), actualRA,
87                     "SubList(unmodifiable) fails to preserve RandomAccess: "
88                             + unmodList.size());
89 
90             syncList = syncList.subList(0, syncList.size() - 1);
91             assertEquals((syncList instanceof RandomAccess), actualRA,
92                     "SubList(synchronized) fails to preserve RandomAccess: "
93                             + syncList.size());
94         }
95     }
96 
97     @Test(dataProvider = "testLists")
testListCopy(List<Integer> list, boolean expectedRA, String failMsg)98     public void testListCopy(List<Integer> list, boolean expectedRA, String failMsg) {
99         ArrayList testCollection = new ArrayList<>(Collections.nCopies(100, 0));
100         // Test that copy works on random & sequential access
101         Collections.copy(list, testCollection);
102         assertEquals(list, testCollection, "Copy failed: " + failMsg);
103     }
104 
105     @Test(dataProvider = "testLists")
testListFill(List<Integer> list, boolean expectedRA, String failMsg)106     public void testListFill(List<Integer> list, boolean expectedRA, String failMsg) {
107         ArrayList testCollection = new ArrayList<>(Collections.nCopies(100, 0));
108         // Test that copy works on random & sequential access
109         Collections.fill(list, 0);
110         assertEquals(list, testCollection, "Fill failed: " + failMsg);
111     }
112 
113     /*
114      * Test that shuffle and binarySearch work the same on random and sequential access lists.
115      */
116     @DataProvider(name = "testFactoryLists")
testDataFactory()117     public Object[][] testDataFactory() {
118         return new Object[][]{
119                 {"ArrayList -> LinkedList", supplier(ArrayList::new), copyCtor(LinkedList::new)},
120                 {"CopyOnWriteArrayList -> Stack", supplier(CopyOnWriteArrayList::new),
121                         copyCtor((list) -> { var s = new Stack();s.addAll(list);return s; })}
122         };
123     }
124 
125     private Supplier<List<Integer>> supplier(Supplier<List<Integer>> supplier) {
126         return supplier;
127     }
128 
129     private Function<List<Integer>, List<Integer>> copyCtor(Function<List<Integer>, List<Integer>> ctor) {
130         return ctor;
131     }
132 
133     @Test(dataProvider = "testFactoryLists")
134     public void testListShuffle(String description, Supplier<List<Integer>> randomAccessListSupplier,
135                                 Function<List<Integer>, List<Integer>> otherListFactory) {
136 
137         //e.g: ArrayList<Integer> al = new ArrayList<>();
138         List<Integer> l1 = randomAccessListSupplier.get();
139         for (int j = 0; j < 100; j++) {
140             l1.add(Integer.valueOf(2 * j));
141         }
142         // e.g: List<Integer> ll = new LinkedList<>(al);
143         List<Integer> l2 = otherListFactory.apply(l1);
144         for (int i = 0; i < 100; i++) {
145             Collections.shuffle(l1, new Random(666));
146             Collections.shuffle(l2, new Random(666));
147             assertEquals(l1, l2, "Shuffle failed: " + description);
148         }
149     }
150 
151     @Test(dataProvider = "testFactoryLists")
152     public void testListBinarySearch(String description, Supplier<List<Integer>> randomAccessListSupplier,
153                                      Function<List<Integer>, List<Integer>> otherListFactory) {
154 
155         //e.g: ArrayList<Integer> al = new ArrayList<>();
156         List<Integer> l1 = randomAccessListSupplier.get();
157         for (int i = 0; i < 10000; i++) {
158             l1.add(Integer.valueOf(2 * i));
159         }
160         // e.g: List<Integer> ll = new LinkedList<>(al);
161         List<Integer> l2 = otherListFactory.apply(l1);
162         for (int i = 0; i < 500; i++) {
163             Integer key = Integer.valueOf(new Random(666).nextInt(20000));
164             assertEquals(Collections.binarySearch(l1, key), Collections
165                     .binarySearch(l2, key), "Binary search failed: " + description);
166         }
167     }
168 }
169