/*

 * 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.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

import static java.util.Spliterator.CONCURRENT;

import static java.util.Spliterator.DISTINCT;

import static java.util.Spliterator.NONNULL;

import java.util.AbstractMap;

import java.util.Arrays;

import java.util.Collection;

import java.util.Iterator;

import java.util.Map;

import java.util.NoSuchElementException;

import java.util.Set;

import java.util.Spliterator;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.atomic.LongAdder;

import java.util.function.BiFunction;

import junit.framework.Test;

import junit.framework.TestSuite;

public class ConcurrentHashMap8Test extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(ConcurrentHashMap8Test.class);

    }

    /**

     * Returns a new map from Integers 1-5 to Strings "A"-"E".

     */

    private static ConcurrentHashMap map5() {

        ConcurrentHashMap map = new ConcurrentHashMap(5);

        assertTrue(map.isEmpty());

        map.put(one, "A");

        map.put(two, "B");

        map.put(three, "C");

        map.put(four, "D");

        map.put(five, "E");

        assertFalse(map.isEmpty());

        assertEquals(5, map.size());

        return map;

    }

    /**

     * getOrDefault returns value if present, else default

     */

    public void testGetOrDefault() {

        ConcurrentHashMap map = map5();

        assertEquals(map.getOrDefault(one, "Z"), "A");

        assertEquals(map.getOrDefault(six, "Z"), "Z");

    }

    /**

     * computeIfAbsent adds when the given key is not present

     */

    public void testComputeIfAbsent() {

        ConcurrentHashMap map = map5();

        map.computeIfAbsent(six, x -> "Z");

        assertTrue(map.containsKey(six));

    }

    /**

     * computeIfAbsent does not replace if the key is already present

     */

    public void testComputeIfAbsent2() {

        ConcurrentHashMap map = map5();

        assertEquals("A", map.computeIfAbsent(one, x -> "Z"));

    }

    /**

     * computeIfAbsent does not add if function returns null

     */

    public void testComputeIfAbsent3() {

        ConcurrentHashMap map = map5();

        map.computeIfAbsent(six, x -> null);

        assertFalse(map.containsKey(six));

    }

    /**

     * computeIfPresent does not replace if the key is already present

     */

    public void testComputeIfPresent() {

        ConcurrentHashMap map = map5();

        map.computeIfPresent(six, (x, y) -> "Z");

        assertFalse(map.containsKey(six));

    }

    /**

     * computeIfPresent adds when the given key is not present

     */

    public void testComputeIfPresent2() {

        ConcurrentHashMap map = map5();

        assertEquals("Z", map.computeIfPresent(one, (x, y) -> "Z"));

    }

    /**

     * compute does not replace if the function returns null

     */

    public void testCompute() {

        ConcurrentHashMap map = map5();

        map.compute(six, (x, y) -> null);

        assertFalse(map.containsKey(six));

    }

    /**

     * compute adds when the given key is not present

     */

    public void testCompute2() {

        ConcurrentHashMap map = map5();

        assertEquals("Z", map.compute(six, (x, y) -> "Z"));

    }

    /**

     * compute replaces when the given key is present

     */

    public void testCompute3() {

        ConcurrentHashMap map = map5();

        assertEquals("Z", map.compute(one, (x, y) -> "Z"));

    }

    /**

     * compute removes when the given key is present and function returns null

     */

    public void testCompute4() {

        ConcurrentHashMap map = map5();

        map.compute(one, (x, y) -> null);

        assertFalse(map.containsKey(one));

    }

    /**

     * merge adds when the given key is not present

     */

    public void testMerge1() {

        ConcurrentHashMap map = map5();

        assertEquals("Y", map.merge(six, "Y", (x, y) -> "Z"));

    }

    /**

     * merge replaces when the given key is present

     */

    public void testMerge2() {

        ConcurrentHashMap map = map5();

        assertEquals("Z", map.merge(one, "Y", (x, y) -> "Z"));

    }

    /**

     * merge removes when the given key is present and function returns null

     */

    public void testMerge3() {

        ConcurrentHashMap map = map5();

        map.merge(one, "Y", (x, y) -> null);

        assertFalse(map.containsKey(one));

    }

    static Set<Integer> populatedSet(int n) {

        Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();

        assertTrue(a.isEmpty());

        for (int i = 0; i < n; i++)

            assertTrue(a.add(i));

        assertEquals(n == 0, a.isEmpty());

        assertEquals(n, a.size());

        return a;

    }

    static Set populatedSet(Integer[] elements) {

        Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();

        assertTrue(a.isEmpty());

        for (int i = 0; i < elements.length; i++)

            assertTrue(a.add(elements[i]));

        assertFalse(a.isEmpty());

        assertEquals(elements.length, a.size());

        return a;

    }

    /**

     * replaceAll replaces all matching values.

     */

    public void testReplaceAll() {

        ConcurrentHashMap<Integer, String> map = map5();

        assertEquals("A", map.get(one));

        assertEquals("B", map.get(two));

        assertEquals("C", map.get(three));

        assertEquals("Z", map.get(four));

        assertEquals("Z", map.get(five));

    }

    /**

     * Default-constructed set is empty

     */

    public void testNewKeySet() {

        Set a = ConcurrentHashMap.newKeySet();

        assertTrue(a.isEmpty());

    }

    /**

     * keySet.add adds the key with the established value to the map;

     * remove removes it.

     */

    public void testKeySetAddRemove() {

        ConcurrentHashMap map = map5();

        Set set1 = map.keySet();

        Set set2 = map.keySet(true);

        set2.add(six);

        assertSame(map, ((ConcurrentHashMap.KeySetView)set2).getMap());

        assertSame(map, ((ConcurrentHashMap.KeySetView)set1).getMap());

        assertEquals(set2.size(), map.size());

        assertEquals(set1.size(), map.size());

        assertTrue((Boolean)map.get(six));

        assertTrue(set1.contains(six));

        assertTrue(set2.contains(six));

        set2.remove(six);

        assertNull(map.get(six));

        assertFalse(set1.contains(six));

        assertFalse(set2.contains(six));

    }

    /**

     * keySet.addAll adds each element from the given collection

     */

    public void testAddAll() {

        Set full = populatedSet(3);

        assertTrue(full.addAll(Arrays.asList(three, four, five)));

        assertEquals(6, full.size());

        assertFalse(full.addAll(Arrays.asList(three, four, five)));

        assertEquals(6, full.size());

    }

    /**

     * keySet.addAll adds each element from the given collection that did not

     * already exist in the set

     */

    public void testAddAll2() {

        Set full = populatedSet(3);

        // "one" is duplicate and will not be added

        assertTrue(full.addAll(Arrays.asList(three, four, one)));

        assertEquals(5, full.size());

        assertFalse(full.addAll(Arrays.asList(three, four, one)));

        assertEquals(5, full.size());

    }

    /**

     * keySet.add will not add the element if it already exists in the set

     */

    public void testAdd2() {

        Set full = populatedSet(3);

        assertFalse(full.add(one));

        assertEquals(3, full.size());

    }

    /**

     * keySet.add adds the element when it does not exist in the set

     */

    public void testAdd3() {

        Set full = populatedSet(3);

        assertTrue(full.add(three));

        assertTrue(full.contains(three));

        assertFalse(full.add(three));

        assertTrue(full.contains(three));

    }

    /**

     * keySet.add throws UnsupportedOperationException if no default

     * mapped value

     */

    public void testAdd4() {

        Set full = map5().keySet();

        try {

            full.add(three);

            shouldThrow();

        } catch (UnsupportedOperationException success) {}

    }

    /**

     * keySet.add throws NullPointerException if the specified key is

     * null

     */

    public void testAdd5() {

        Set full = populatedSet(3);

        try {

            full.add(null);

            shouldThrow();

        } catch (NullPointerException success) {}

    }

    /**

     * KeySetView.getMappedValue returns the map's mapped value

     */

    public void testGetMappedValue() {

        ConcurrentHashMap map = map5();

        assertNull(map.keySet().getMappedValue());

        try {

            map.keySet(null);

            shouldThrow();

        } catch (NullPointerException success) {}

        ConcurrentHashMap.KeySetView set = map.keySet(one);

        assertFalse(set.add(one));

        assertTrue(set.add(six));

        assertTrue(set.add(seven));

        assertSame(one, set.getMappedValue());

        assertNotSame(one, map.get(one));

        assertSame(one, map.get(six));

        assertSame(one, map.get(seven));

    }

    void checkSpliteratorCharacteristics(Spliterator<?> sp,

                                         int requiredCharacteristics) {

        assertEquals(requiredCharacteristics,

                     requiredCharacteristics & sp.characteristics());

    }

    /**

     * KeySetView.spliterator returns spliterator over the elements in this set

     */

    public void testKeySetSpliterator() {

        LongAdder adder = new LongAdder();

        ConcurrentHashMap map = map5();

        Set set = map.keySet();

        Spliterator<Integer> sp = set.spliterator();

        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);

        assertEquals(sp.estimateSize(), map.size());

        Spliterator<Integer> sp2 = sp.trySplit();

        sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));

        long v = adder.sumThenReset();

        sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));

        long v2 = adder.sum();

        assertEquals(v + v2, 15);

    }

    /**

     * keyset.clear removes all elements from the set

     */

    public void testClear() {

        Set full = populatedSet(3);

        full.clear();

        assertEquals(0, full.size());

    }

    /**

     * keyset.contains returns true for added elements

     */

    public void testContains() {

        Set full = populatedSet(3);

        assertTrue(full.contains(one));

        assertFalse(full.contains(five));

    }

    /**

     * KeySets with equal elements are equal

     */

    public void testEquals() {

        Set a = populatedSet(3);

        Set b = populatedSet(3);

        assertTrue(a.equals(b));

        assertTrue(b.equals(a));

        assertEquals(a.hashCode(), b.hashCode());

        a.add(m1);

        assertFalse(a.equals(b));

        assertFalse(b.equals(a));

        b.add(m1);

        assertTrue(a.equals(b));

        assertTrue(b.equals(a));

        assertEquals(a.hashCode(), b.hashCode());

    }

    /**

     * KeySet.containsAll returns true for collections with subset of elements

     */

    public void testContainsAll() {

        Collection full = populatedSet(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)));

    }

    /**

     * KeySet.isEmpty is true when empty, else false

     */

    public void testIsEmpty() {

        assertTrue(populatedSet(0).isEmpty());

        assertFalse(populatedSet(3).isEmpty());

    }

    /**

     * KeySet.iterator() returns an iterator containing the elements of the

     * set

     */

    public void testIterator() {

        Collection empty = ConcurrentHashMap.newKeySet();

        int size = 20;

        assertFalse(empty.iterator().hasNext());

        try {

            empty.iterator().next();

            shouldThrow();

        } catch (NoSuchElementException success) {}

        Integer[] elements = new Integer[size];

        for (int i = 0; i < size; i++)

            elements[i] = i;

        shuffle(elements);

        Collection<Integer> full = populatedSet(elements);

        Iterator it = full.iterator();

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

            assertTrue(it.hasNext());

            it.next();

        }

        assertIteratorExhausted(it);

    }

    /**

     * iterator of empty collections has no elements

     */

    public void testEmptyIterator() {

        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());

        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());

        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());

        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());

    }

    /**

     * KeySet.iterator.remove removes current element

     */

    public void testIteratorRemove() {

        Set q = populatedSet(3);

        Iterator it = q.iterator();

        Object removed = it.next();

        it.remove();

        it = q.iterator();

        assertFalse(it.next().equals(removed));

        assertFalse(it.next().equals(removed));

        assertFalse(it.hasNext());

    }

    /**

     * KeySet.toString holds toString of elements

     */

    public void testToString() {

        assertEquals("[]", ConcurrentHashMap.newKeySet().toString());

        Set full = populatedSet(3);

        String s = full.toString();

        for (int i = 0; i < 3; ++i)

            assertTrue(s.contains(String.valueOf(i)));

    }

    /**

     * KeySet.removeAll removes all elements from the given collection

     */

    public void testRemoveAll() {

        Set full = populatedSet(3);

        assertTrue(full.removeAll(Arrays.asList(one, two)));

        assertEquals(1, full.size());

        assertFalse(full.removeAll(Arrays.asList(one, two)));

        assertEquals(1, full.size());

    }

    /**

     * KeySet.remove removes an element

     */

    public void testRemove() {

        Set full = populatedSet(3);

        full.remove(one);

        assertFalse(full.contains(one));

        assertEquals(2, full.size());

    }

    /**

     * keySet.size returns the number of elements

     */

    public void testSize() {

        Set empty = ConcurrentHashMap.newKeySet();

        Set full = populatedSet(3);

        assertEquals(3, full.size());

        assertEquals(0, empty.size());

    }

    /**

     * KeySet.toArray() returns an Object array containing all elements from

     * the set

     */

    public void testToArray() {

        Object[] a = ConcurrentHashMap.newKeySet().toArray();

        assertTrue(Arrays.equals(new Object[0], a));

        assertSame(Object[].class, a.getClass());

        int size = 20;

        Integer[] elements = new Integer[size];

        for (int i = 0; i < size; i++)

            elements[i] = i;