* Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

/**

 * @bug 4327164 8229338

 * @run testng Basic

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

import static org.testng.Assert.assertEquals;

import java.util.*;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.function.Function;

import java.util.function.Supplier;

    /*

     * Lists which implement Random Access interface

     */

    @DataProvider(name = "testLists")

    public Object[][] testData() {

        var intArray = new Integer[100];

        var stack = new Stack<>();

        var random = new Random();

        for (int i = 0; i < 100; i++) {

            var r = random.nextInt(100);

            stack.push(r);

            intArray[i] = r;

        }

        List<Integer> list = Arrays.asList(intArray);

        return new Object[][]{

                {list, true, "Arrays.asList"},

                {stack, true, "Stack"},

                {new ArrayList<>(list), true, "ArrayList"},

                {new LinkedList<>(list), false, "LinkedList"},

                {new Vector<>(list), true, "Vector"},

                {new CopyOnWriteArrayList<>(list), true, "CopyOnWriteArrayList"}

        };

    }

    @Test(dataProvider = "testLists")

    public void testRandomAccess(List<Integer> list, boolean expectedRA, String failMsg) {

        var actualRA = list instanceof RandomAccess;

        assertEquals(actualRA, expectedRA, failMsg);

        List<Integer> unmodList = Collections.unmodifiableList(list);

        List<Integer> syncList = Collections.synchronizedList(list);

        assertEquals((unmodList instanceof RandomAccess), actualRA,

                "Unmodifiable fails to preserve RandomAccess");

        assertEquals((syncList instanceof RandomAccess), actualRA,

                "Synchronized fails to preserve RandomAccess");

        while (list.size() > 0) {

            list = list.subList(0, list.size() - 1);

            assertEquals((list instanceof RandomAccess), actualRA,

                    "SubList fails to preserve RandomAccess: " + list.size());

            unmodList = unmodList.subList(0, unmodList.size() - 1);

            assertEquals((unmodList instanceof RandomAccess), actualRA,

                    "SubList(unmodifiable) fails to preserve RandomAccess: "

                            + unmodList.size());

            syncList = syncList.subList(0, syncList.size() - 1);

            assertEquals((syncList instanceof RandomAccess), actualRA,

                    "SubList(synchronized) fails to preserve RandomAccess: "

                            + syncList.size());

        }

    }

    @Test(dataProvider = "testLists")

    public void testListCopy(List<Integer> list, boolean expectedRA, String failMsg) {

        ArrayList testCollection = new ArrayList<>(Collections.nCopies(100, 0));

        // Test that copy works on random & sequential access

        Collections.copy(list, testCollection);

        assertEquals(list, testCollection, "Copy failed: " + failMsg);

    }

    @Test(dataProvider = "testLists")

    public void testListFill(List<Integer> list, boolean expectedRA, String failMsg) {

        ArrayList testCollection = new ArrayList<>(Collections.nCopies(100, 0));

        // Test that copy works on random & sequential access

        Collections.fill(list, 0);

        assertEquals(list, testCollection, "Fill failed: " + failMsg);

    }

    /*

     * Test that shuffle and binarySearch work the same on random and sequential access lists.

     */

    @DataProvider(name = "testFactoryLists")

    public Object[][] testDataFactory() {

        return new Object[][]{

                {"ArrayList -> LinkedList", supplier(ArrayList::new), copyCtor(LinkedList::new)},

                {"CopyOnWriteArrayList -> Stack", supplier(CopyOnWriteArrayList::new),

                        copyCtor((list) -> { var s = new Stack();s.addAll(list);return s; })}

        };

    }

    private Supplier<List<Integer>> supplier(Supplier<List<Integer>> supplier) {

        return supplier;

    }

    private Function<List<Integer>, List<Integer>> copyCtor(Function<List<Integer>, List<Integer>> ctor) {

        return ctor;

    }

    @Test(dataProvider = "testFactoryLists")

    public void testListShuffle(String description, Supplier<List<Integer>> randomAccessListSupplier,

                                Function<List<Integer>, List<Integer>> otherListFactory) {

        //e.g: ArrayList<Integer> al = new ArrayList<>();

        List<Integer> l1 = randomAccessListSupplier.get();

        for (int j = 0; j < 100; j++) {

            l1.add(Integer.valueOf(2 * j));

        }

        // e.g: List<Integer> ll = new LinkedList<>(al);

        List<Integer> l2 = otherListFactory.apply(l1);

        for (int i = 0; i < 100; i++) {

            Collections.shuffle(l1, new Random(666));

            Collections.shuffle(l2, new Random(666));

            assertEquals(l1, l2, "Shuffle failed: " + description);

        }

    }

    @Test(dataProvider = "testFactoryLists")

    public void testListBinarySearch(String description, Supplier<List<Integer>> randomAccessListSupplier,

                                     Function<List<Integer>, List<Integer>> otherListFactory) {

        //e.g: ArrayList<Integer> al = new ArrayList<>();

        List<Integer> l1 = randomAccessListSupplier.get();

        for (int i = 0; i < 10000; i++) {

            l1.add(Integer.valueOf(2 * i));

        }

        // e.g: List<Integer> ll = new LinkedList<>(al);

        List<Integer> l2 = otherListFactory.apply(l1);

            Integer key = Integer.valueOf(new Random(666).nextInt(20000));

            assertEquals(Collections.binarySearch(l1, key), Collections

                    .binarySearch(l2, key), "Binary search failed: " + description);