/*
* Copyright (C) 2011 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.collect;
import static com.google.common.util.concurrent.Uninterruptibles.awaitUninterruptibly;
import static java.util.concurrent.TimeUnit.HOURS;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Function;
import com.google.common.collect.MapMaker.RemovalNotification;
import com.google.common.collect.MapMakerInternalMapTest.QueuingRemovalListener;
import com.google.common.testing.NullPointerTester;
import junit.framework.TestCase;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Charles Fry
*/
@GwtCompatible(emulated = true)
public class MapMakerTest extends TestCase {
@GwtIncompatible("NullPointerTester")
public void testNullParameters() throws Exception {
NullPointerTester tester = new NullPointerTester();
tester.testAllPublicInstanceMethods(new MapMaker());
}
@GwtIncompatible("threads")
public void testRemovalNotification_clear() throws InterruptedException {
// If a clear() happens while a computation is pending, we should not get a removal
// notification.
final CountDownLatch computingLatch = new CountDownLatch(1);
Function<String, String> computingFunction = new DelayingIdentityLoader<String>(computingLatch);
QueuingRemovalListener<String, String> listener = new QueuingRemovalListener<String, String>();
@SuppressWarnings("deprecation") // test of deprecated code
final ConcurrentMap<String, String> map = new MapMaker()
.concurrencyLevel(1)
.removalListener(listener)
.makeComputingMap(computingFunction);
// seed the map, so its segment's count > 0
map.put("a", "a");
final CountDownLatch computationStarted = new CountDownLatch(1);
final CountDownLatch computationComplete = new CountDownLatch(1);
new Thread(new Runnable() {
@Override public void run() {
computationStarted.countDown();
map.get("b");
computationComplete.countDown();
}
}).start();
// wait for the computingEntry to be created
computationStarted.await();
map.clear();
// let the computation proceed
computingLatch.countDown();
// don't check map.size() until we know the get("b") call is complete
computationComplete.await();
// At this point, the listener should be holding the seed value (a -> a), and the map should
// contain the computed value (b -> b), since the clear() happened before the computation
// completed.
assertEquals(1, listener.size());
RemovalNotification<String, String> notification = listener.remove();
assertEquals("a", notification.getKey());
assertEquals("a", notification.getValue());
assertEquals(1, map.size());
assertEquals("b", map.get("b"));
}
// "Basher tests", where we throw a bunch of stuff at a Cache and check basic invariants.
/**
* This is a less carefully-controlled version of {@link #testRemovalNotification_clear} - this is
* a black-box test that tries to create lots of different thread-interleavings, and asserts that
* each computation is affected by a call to {@code clear()} (and therefore gets passed to the
* removal listener), or else is not affected by the {@code clear()} (and therefore exists in the
* map afterward).
*/
@GwtIncompatible("threads")
public void testRemovalNotification_clear_basher() throws InterruptedException {
// If a clear() happens close to the end of computation, one of two things should happen:
// - computation ends first: the removal listener is called, and the map does not contain the
// key/value pair
// - clear() happens first: the removal listener is not called, and the map contains the pair
CountDownLatch computationLatch = new CountDownLatch(1);
QueuingRemovalListener<String, String> listener = new QueuingRemovalListener<String, String>();
@SuppressWarnings("deprecation") // test of deprecated code
final Map<String, String> map = new MapMaker()
.removalListener(listener)
.concurrencyLevel(20)
.makeComputingMap(new DelayingIdentityLoader<String>(computationLatch));
int nThreads = 100;
int nTasks = 1000;
int nSeededEntries = 100;
Set<String> expectedKeys = Sets.newHashSetWithExpectedSize(nTasks + nSeededEntries);
// seed the map, so its segments have a count>0; otherwise, clear() won't visit the in-progress
// entries
for (int i = 0; i < nSeededEntries; i++) {
String s = "b" + i;
map.put(s, s);
expectedKeys.add(s);
}
final AtomicInteger computedCount = new AtomicInteger();
ExecutorService threadPool = Executors.newFixedThreadPool(nThreads);
final CountDownLatch tasksFinished = new CountDownLatch(nTasks);
for (int i = 0; i < nTasks; i++) {
final String s = "a" + i;
threadPool.submit(new Runnable() {
@Override public void run() {
map.get(s);
computedCount.incrementAndGet();
tasksFinished.countDown();
}
});
expectedKeys.add(s);
}
computationLatch.countDown();
// let some computations complete
while (computedCount.get() < nThreads) {
Thread.yield();
}
map.clear();
tasksFinished.await();
// Check all of the removal notifications we received: they should have had correctly-associated
// keys and values. (An earlier bug saw removal notifications for in-progress computations,
// which had real keys with null values.)
Map<String, String> removalNotifications = Maps.newHashMap();
for (RemovalNotification<String, String> notification : listener) {
removalNotifications.put(notification.getKey(), notification.getValue());
assertEquals("Unexpected key/value pair passed to removalListener",
notification.getKey(), notification.getValue());
}
// All of the seed values should have been visible, so we should have gotten removal
// notifications for all of them.
for (int i = 0; i < nSeededEntries; i++) {
assertEquals("b" + i, removalNotifications.get("b" + i));
}
// Each of the values added to the map should either still be there, or have seen a removal
// notification.
assertEquals(expectedKeys, Sets.union(map.keySet(), removalNotifications.keySet()));
assertTrue(Sets.intersection(map.keySet(), removalNotifications.keySet()).isEmpty());
}
@GwtIncompatible("threads")
static final class DelayingIdentityLoader<T> implements Function<T, T> {
private final CountDownLatch delayLatch;
DelayingIdentityLoader(CountDownLatch delayLatch) {
this.delayLatch = delayLatch;
}
@Override public T apply(T key) {
awaitUninterruptibly(delayLatch);
return key;
}
}
/*
* TODO(cpovirk): eliminate duplication between these tests and those in LegacyMapMakerTests and
* anywhere else
*/
/** Tests for the builder. */
public static class MakerTest extends TestCase {
public void testInitialCapacity_negative() {
MapMaker maker = new MapMaker();
try {
maker.initialCapacity(-1);
fail();
} catch (IllegalArgumentException expected) {
}
}
// TODO(cpovirk): enable when ready
public void xtestInitialCapacity_setTwice() {
MapMaker maker = new MapMaker().initialCapacity(16);
try {
// even to the same value is not allowed
maker.initialCapacity(16);
fail();
} catch (IllegalArgumentException expected) {
}
}
@SuppressWarnings("deprecation") // test of deprecated method
public void testExpiration_setTwice() {
MapMaker maker = new MapMaker().expireAfterWrite(1, HOURS);
try {
// even to the same value is not allowed
maker.expireAfterWrite(1, HOURS);
fail();
} catch (IllegalStateException expected) {
}
}
public void testMaximumSize_setTwice() {
MapMaker maker = new MapMaker().maximumSize(16);
try {
// even to the same value is not allowed
maker.maximumSize(16);
fail();
} catch (IllegalStateException expected) {
}
}
public void testReturnsPlainConcurrentHashMapWhenPossible() {
Map<?, ?> map = new MapMaker()
.initialCapacity(5)
.makeMap();
assertTrue(map instanceof ConcurrentHashMap);
}
}
/** Tests of the built map with maximumSize. */
public static class MaximumSizeTest extends TestCase {
public void testPut_sizeIsZero() {
ConcurrentMap<Object, Object> map =
new MapMaker().maximumSize(0).makeMap();
assertEquals(0, map.size());
map.put(new Object(), new Object());
assertEquals(0, map.size());
}
public void testSizeBasedEviction() {
int numKeys = 10;
int mapSize = 5;
ConcurrentMap<Object, Object> map =
new MapMaker().maximumSize(mapSize).makeMap();
for (int i = 0; i < numKeys; i++) {
map.put(i, i);
}
assertEquals(mapSize, map.size());
for (int i = numKeys - mapSize; i < mapSize; i++) {
assertTrue(map.containsKey(i));
}
}
}
/** Tests for recursive computation. */
public static class RecursiveComputationTest extends TestCase {
Function<Integer, String> recursiveComputer
= new Function<Integer, String>() {
@Override
public String apply(Integer key) {
if (key > 0) {
return key + ", " + recursiveMap.get(key - 1);
} else {
return "0";
}
}
};
ConcurrentMap<Integer, String> recursiveMap = new MapMaker()
.makeComputingMap(recursiveComputer);
public void testRecursiveComputation() {
assertEquals("3, 2, 1, 0", recursiveMap.get(3));
}
}
/**
* Tests for computing functionality.
*/
public static class ComputingTest extends TestCase {
public void testComputerThatReturnsNull() {
ConcurrentMap<Integer, String> map = new MapMaker()
.makeComputingMap(new Function<Integer, String>() {
@Override
public String apply(Integer key) {
return null;
}
});
try {
map.get(1);
fail();
} catch (NullPointerException e) { /* expected */ }
}
public void testRuntimeException() {
final RuntimeException e = new RuntimeException();
ConcurrentMap<Object, Object> map = new MapMaker().makeComputingMap(
new Function<Object, Object>() {
@Override
public Object apply(Object from) {
throw e;
}
});
try {
map.get(new Object());
fail();
} catch (ComputationException ce) {
assertSame(e, ce.getCause());
}
}
}
}