304 lines
12 KiB
Java
304 lines
12 KiB
Java
/*
|
|
* 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 and Martin Buchholz 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 java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.concurrent.ThreadLocalRandom;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.function.BiFunction;
|
|
|
|
import junit.framework.Test;
|
|
|
|
/**
|
|
* Contains tests applicable to all Map implementations.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public class MapTest extends JSR166TestCase {
|
|
final MapImplementation impl;
|
|
|
|
/** Tests are parameterized by a Map implementation. */
|
|
MapTest(MapImplementation impl, String methodName) {
|
|
super(methodName);
|
|
this.impl = impl;
|
|
}
|
|
|
|
public static Test testSuite(MapImplementation impl) {
|
|
return newTestSuite(
|
|
parameterizedTestSuite(MapTest.class,
|
|
MapImplementation.class,
|
|
impl));
|
|
}
|
|
|
|
public void testImplSanity() {
|
|
final ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
{
|
|
Map m = impl.emptyMap();
|
|
assertTrue(m.isEmpty());
|
|
mustEqual(0, m.size());
|
|
Object k = impl.makeKey(rnd.nextInt());
|
|
Object v = impl.makeValue(rnd.nextInt());
|
|
m.put(k, v);
|
|
assertFalse(m.isEmpty());
|
|
mustEqual(1, m.size());
|
|
assertTrue(m.containsKey(k));
|
|
assertTrue(m.containsValue(v));
|
|
}
|
|
{
|
|
Map m = impl.emptyMap();
|
|
Object v = impl.makeValue(rnd.nextInt());
|
|
if (impl.permitsNullKeys()) {
|
|
m.put(null, v);
|
|
assertTrue(m.containsKey(null));
|
|
assertTrue(m.containsValue(v));
|
|
} else {
|
|
assertThrows(NullPointerException.class, () -> m.put(null, v));
|
|
}
|
|
}
|
|
{
|
|
Map m = impl.emptyMap();
|
|
Object k = impl.makeKey(rnd.nextInt());
|
|
if (impl.permitsNullValues()) {
|
|
m.put(k, null);
|
|
assertTrue(m.containsKey(k));
|
|
assertTrue(m.containsValue(null));
|
|
} else {
|
|
assertThrows(NullPointerException.class, () -> m.put(k, null));
|
|
}
|
|
}
|
|
{
|
|
Map m = impl.emptyMap();
|
|
Object k = impl.makeKey(rnd.nextInt());
|
|
Object v1 = impl.makeValue(rnd.nextInt());
|
|
Object v2 = impl.makeValue(rnd.nextInt());
|
|
m.put(k, v1);
|
|
if (impl.supportsSetValue()) {
|
|
((Map.Entry)(m.entrySet().iterator().next())).setValue(v2);
|
|
assertSame(v2, m.get(k));
|
|
assertTrue(m.containsKey(k));
|
|
assertTrue(m.containsValue(v2));
|
|
assertFalse(m.containsValue(v1));
|
|
} else {
|
|
assertThrows(UnsupportedOperationException.class,
|
|
() -> ((Map.Entry)(m.entrySet().iterator().next())).setValue(v2));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tests and extends the scenario reported in
|
|
* https://bugs.openjdk.org/browse/JDK-8186171
|
|
* HashMap: Entry.setValue may not work after Iterator.remove() called for previous entries
|
|
* ant -Djsr166.tckTestClass=HashMapTest -Djsr166.methodFilter=testBug8186171 -Djsr166.runsPerTest=1000 tck
|
|
*/
|
|
public void testBug8186171() {
|
|
if (!impl.supportsSetValue()) return;
|
|
if (!atLeastJava10()) return; // jdk9 is no longer maintained
|
|
final ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
final boolean permitsNullValues = impl.permitsNullValues();
|
|
final Object v1 = (permitsNullValues && rnd.nextBoolean())
|
|
? null : impl.makeValue(1);
|
|
final Object v2 = (permitsNullValues && rnd.nextBoolean() && v1 != null)
|
|
? null : impl.makeValue(2);
|
|
|
|
// If true, always lands in first bucket in hash tables.
|
|
final boolean poorHash = rnd.nextBoolean();
|
|
class Key implements Comparable<Key> {
|
|
final int i;
|
|
Key(int i) { this.i = i; }
|
|
public int hashCode() { return poorHash ? 0 : super.hashCode(); }
|
|
public int compareTo(Key x) {
|
|
return Integer.compare(this.i, x.i);
|
|
}
|
|
}
|
|
|
|
// Both HashMap and ConcurrentHashMap have:
|
|
// TREEIFY_THRESHOLD = 8; UNTREEIFY_THRESHOLD = 6;
|
|
final int size = rnd.nextInt(1, 25);
|
|
|
|
List<Key> keys = new ArrayList<>();
|
|
for (int i = size; i-->0; ) keys.add(new Key(i));
|
|
Key keyToFrob = keys.get(rnd.nextInt(keys.size()));
|
|
|
|
Map<Key, Object> m = impl.emptyMap();
|
|
for (Key key : keys) m.put(key, v1);
|
|
|
|
for (Iterator<Map.Entry<Key, Object>> it = m.entrySet().iterator();
|
|
it.hasNext(); ) {
|
|
Map.Entry<Key, Object> entry = it.next();
|
|
if (entry.getKey() == keyToFrob)
|
|
entry.setValue(v2); // does this have the expected effect?
|
|
else
|
|
it.remove();
|
|
}
|
|
|
|
assertFalse(m.containsValue(v1));
|
|
assertTrue(m.containsValue(v2));
|
|
assertTrue(m.containsKey(keyToFrob));
|
|
mustEqual(1, m.size());
|
|
}
|
|
|
|
/**
|
|
* "Missing" test found while investigating JDK-8210280.
|
|
* ant -Djsr166.tckTestClass=HashMapTest -Djsr166.methodFilter=testBug8210280 -Djsr166.runsPerTest=1000000 tck
|
|
*/
|
|
public void testBug8210280() {
|
|
final ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
final int size1 = rnd.nextInt(32);
|
|
final int size2 = rnd.nextInt(128);
|
|
|
|
final Map m1 = impl.emptyMap();
|
|
for (int i = 0; i < size1; i++) {
|
|
int elt = rnd.nextInt(1024 * i, 1024 * (i + 1));
|
|
assertNull(m1.put(impl.makeKey(elt), impl.makeValue(elt)));
|
|
}
|
|
|
|
final Map m2 = impl.emptyMap();
|
|
for (int i = 0; i < size2; i++) {
|
|
int elt = rnd.nextInt(Integer.MIN_VALUE + 1024 * i,
|
|
Integer.MIN_VALUE + 1024 * (i + 1));
|
|
assertNull(m2.put(impl.makeKey(elt), impl.makeValue(-elt)));
|
|
}
|
|
|
|
final Map m1Copy = impl.emptyMap();
|
|
m1Copy.putAll(m1);
|
|
|
|
m1.putAll(m2);
|
|
|
|
for (Object elt : m2.keySet())
|
|
mustEqual(m2.get(elt), m1.get(elt));
|
|
for (Object elt : m1Copy.keySet())
|
|
assertSame(m1Copy.get(elt), m1.get(elt));
|
|
mustEqual(size1 + size2, m1.size());
|
|
}
|
|
|
|
/**
|
|
* 8222930: ConcurrentSkipListMap.clone() shares size variable between original and clone
|
|
*/
|
|
public void testClone() {
|
|
final ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
final int size = rnd.nextInt(4);
|
|
final Map map = impl.emptyMap();
|
|
for (int i = 0; i < size; i++)
|
|
map.put(impl.makeKey(i), impl.makeValue(i));
|
|
final Map clone = cloneableClone(map);
|
|
if (clone == null) return; // not cloneable?
|
|
|
|
mustEqual(size, map.size());
|
|
mustEqual(size, clone.size());
|
|
mustEqual(map.isEmpty(), clone.isEmpty());
|
|
|
|
clone.put(impl.makeKey(-1), impl.makeValue(-1));
|
|
mustEqual(size, map.size());
|
|
mustEqual(size + 1, clone.size());
|
|
|
|
clone.clear();
|
|
mustEqual(size, map.size());
|
|
mustEqual(0, clone.size());
|
|
assertTrue(clone.isEmpty());
|
|
}
|
|
|
|
/**
|
|
* Concurrent access by compute methods behaves as expected
|
|
*/
|
|
public void testConcurrentAccess() throws Throwable {
|
|
final Map map = impl.emptyMap();
|
|
final long testDurationMillis = expensiveTests ? 1000 : 2;
|
|
final int nTasks = impl.isConcurrent()
|
|
? ThreadLocalRandom.current().nextInt(1, 10)
|
|
: 1;
|
|
final AtomicBoolean done = new AtomicBoolean(false);
|
|
final boolean remappingFunctionCalledAtMostOnce
|
|
= impl.remappingFunctionCalledAtMostOnce();
|
|
final List<CompletableFuture> futures = new ArrayList<>();
|
|
final AtomicLong expectedSum = new AtomicLong(0);
|
|
final Action[] tasks = {
|
|
// repeatedly increment values using compute()
|
|
() -> {
|
|
long[] invocations = new long[2];
|
|
ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
BiFunction<Object, Object, Object> incValue = (k, v) -> {
|
|
invocations[1]++;
|
|
int vi = (v == null) ? 1 : impl.valueToInt(v) + 1;
|
|
return impl.makeValue(vi);
|
|
};
|
|
while (!done.getAcquire()) {
|
|
invocations[0]++;
|
|
Object key = impl.makeKey(3 * rnd.nextInt(10));
|
|
map.compute(key, incValue);
|
|
}
|
|
if (remappingFunctionCalledAtMostOnce)
|
|
mustEqual(invocations[0], invocations[1]);
|
|
expectedSum.getAndAdd(invocations[0]);
|
|
},
|
|
// repeatedly increment values using computeIfPresent()
|
|
() -> {
|
|
long[] invocations = new long[2];
|
|
ThreadLocalRandom rnd = ThreadLocalRandom.current();
|
|
BiFunction<Object, Object, Object> incValue = (k, v) -> {
|
|
invocations[1]++;
|
|
int vi = impl.valueToInt(v) + 1;
|
|
return impl.makeValue(vi);
|
|
};
|
|
while (!done.getAcquire()) {
|
|
Object key = impl.makeKey(3 * rnd.nextInt(10));
|
|
if (map.computeIfPresent(key, incValue) != null)
|
|
invocations[0]++;
|
|
}
|
|
if (remappingFunctionCalledAtMostOnce)
|
|
mustEqual(invocations[0], invocations[1]);
|
|
expectedSum.getAndAdd(invocations[0]);
|
|
},
|
|
};
|
|
for (int i = nTasks; i--> 0; ) {
|
|
Action task = chooseRandomly(tasks);
|
|
futures.add(CompletableFuture.runAsync(checkedRunnable(task)));
|
|
}
|
|
Thread.sleep(testDurationMillis);
|
|
done.setRelease(true);
|
|
for (var future : futures)
|
|
checkTimedGet(future, null);
|
|
|
|
long sum = map.values().stream().mapToLong(x -> (int) x).sum();
|
|
mustEqual(expectedSum.get(), sum);
|
|
}
|
|
|
|
// public void testFailsIntentionallyForDebugging() {
|
|
// fail(impl.klazz().getSimpleName());
|
|
// }
|
|
}
|