public void testNoStats() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumSize(2); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); assertEquals(EMPTY_STATS, cache.stats()); Object one = new Object(); cache.getUnchecked(one); assertEquals(EMPTY_STATS, cache.stats()); cache.getUnchecked(one); assertEquals(EMPTY_STATS, cache.stats()); Object two = new Object(); cache.getUnchecked(two); assertEquals(EMPTY_STATS, cache.stats()); Object three = new Object(); cache.getUnchecked(three); assertEquals(EMPTY_STATS, cache.stats()); }
/** * Lookups on the map view shouldn't impact the recency queue. */ public void testAsMapRecency() { CacheBuilder<Object, Object> builder = createCacheBuilder() .concurrencyLevel(1) .maximumSize(SMALL_MAX_SIZE); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); Segment<Object, Object> segment = cache.localCache.segments[0]; ConcurrentMap<Object, Object> map = cache.asMap(); Object one = new Object(); assertSame(one, cache.getUnchecked(one)); assertTrue(segment.recencyQueue.isEmpty()); assertSame(one, map.get(one)); assertSame(one, segment.recencyQueue.peek().getKey()); assertSame(one, cache.getUnchecked(one)); assertFalse(segment.recencyQueue.isEmpty()); }
public void testNoStats() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(2); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); assertEquals(EMPTY_STATS, cache.stats()); Object one = new Object(); cache.getUnchecked(one); assertEquals(EMPTY_STATS, cache.stats()); cache.getUnchecked(one); assertEquals(EMPTY_STATS, cache.stats()); Object two = new Object(); cache.getUnchecked(two); assertEquals(EMPTY_STATS, cache.stats()); Object three = new Object(); cache.getUnchecked(three); assertEquals(EMPTY_STATS, cache.stats()); }
public void testRecordStats() { CacheBuilder<Object, Object> builder = createCacheBuilder().recordStats().concurrencyLevel(1).maximumSize(2); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); assertEquals(0, cache.stats().hitCount()); assertEquals(0, cache.stats().missCount()); Object one = new Object(); cache.getUnchecked(one); assertEquals(0, cache.stats().hitCount()); assertEquals(1, cache.stats().missCount()); cache.getUnchecked(one); assertEquals(1, cache.stats().hitCount()); assertEquals(1, cache.stats().missCount()); Object two = new Object(); cache.getUnchecked(two); assertEquals(1, cache.stats().hitCount()); assertEquals(2, cache.stats().missCount()); Object three = new Object(); cache.getUnchecked(three); assertEquals(1, cache.stats().hitCount()); assertEquals(3, cache.stats().missCount()); }
/** Lookups on the map view shouldn't impact the recency queue. */ public void testAsMapRecency() { CacheBuilder<Object, Object> builder = createCacheBuilder().concurrencyLevel(1).maximumSize(SMALL_MAX_SIZE); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); Segment<Object, Object> segment = cache.localCache.segments[0]; ConcurrentMap<Object, Object> map = cache.asMap(); Object one = new Object(); assertSame(one, cache.getUnchecked(one)); assertTrue(segment.recencyQueue.isEmpty()); assertSame(one, map.get(one)); assertSame(one, segment.recencyQueue.peek().getKey()); assertSame(one, cache.getUnchecked(one)); assertFalse(segment.recencyQueue.isEmpty()); }
public void testComputingFunction() { CacheLoader<Object, Object> loader = new CacheLoader<Object, Object>() { @Override public Object load(Object from) { return new Object(); } }; LocalLoadingCache<Object, Object> cache = makeCache(createCacheBuilder(), loader); assertSame(loader, cache.localCache.defaultLoader); }
public void testRecordStats() { CacheBuilder<Object, Object> builder = createCacheBuilder() .recordStats() .concurrencyLevel(1) .maximumSize(2); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); assertEquals(0, cache.stats().hitCount()); assertEquals(0, cache.stats().missCount()); Object one = new Object(); cache.getUnchecked(one); assertEquals(0, cache.stats().hitCount()); assertEquals(1, cache.stats().missCount()); cache.getUnchecked(one); assertEquals(1, cache.stats().hitCount()); assertEquals(1, cache.stats().missCount()); Object two = new Object(); cache.getUnchecked(two); assertEquals(1, cache.stats().hitCount()); assertEquals(2, cache.stats().missCount()); Object three = new Object(); cache.getUnchecked(three); assertEquals(1, cache.stats().hitCount()); assertEquals(3, cache.stats().missCount()); }
/** * Gets the {@link LocalCache} used by the given {@link Cache}, if any, or throws an * IllegalArgumentException if this is a Cache type that doesn't have a LocalCache. */ static <K, V> LocalCache<K, V> toLocalCache(Cache<K, V> cache) { if (cache instanceof LocalLoadingCache) { return ((LocalLoadingCache<K, V>) cache).localCache; } throw new IllegalArgumentException("Cache of type " + cache.getClass() + " doesn't have a LocalCache."); }
/** * Gets the {@link LocalCache} used by the given {@link Cache}, if any, or throws an * IllegalArgumentException if this is a Cache type that doesn't have a LocalCache. */ static <K, V> LocalCache<K, V> toLocalCache(Cache<K, V> cache) { if (cache instanceof LocalLoadingCache) { return ((LocalLoadingCache<K, V>) cache).localCache; } throw new IllegalArgumentException( "Cache of type " + cache.getClass() + " doesn't have a LocalCache."); }
public void testSerializationProxyLoading() { CacheLoader<Object, Object> loader = new SerializableCacheLoader(); RemovalListener<Object, Object> listener = new SerializableRemovalListener<Object, Object>(); SerializableWeigher<Object, Object> weigher = new SerializableWeigher<Object, Object>(); Ticker ticker = new SerializableTicker(); @SuppressWarnings("unchecked") // createMock LocalLoadingCache<Object, Object> one = (LocalLoadingCache) CacheBuilder.newBuilder() .weakKeys() .softValues() .expireAfterAccess(123, SECONDS) .expireAfterWrite(456, MINUTES) .maximumWeight(789) .weigher(weigher) .concurrencyLevel(12) .removalListener(listener) .ticker(ticker) .build(loader); // add a non-serializable entry one.getUnchecked(new Object()); assertEquals(1, one.size()); assertFalse(one.asMap().isEmpty()); LocalLoadingCache<Object, Object> two = SerializableTester.reserialize(one); assertEquals(0, two.size()); assertTrue(two.asMap().isEmpty()); LocalCache<Object, Object> localCacheOne = one.localCache; LocalCache<Object, Object> localCacheTwo = two.localCache; assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength); assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength); assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence); assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence); assertEquals(localCacheOne.maxWeight, localCacheTwo.maxWeight); assertEquals(localCacheOne.weigher, localCacheTwo.weigher); assertEquals(localCacheOne.expireAfterAccessNanos, localCacheTwo.expireAfterAccessNanos); assertEquals(localCacheOne.expireAfterWriteNanos, localCacheTwo.expireAfterWriteNanos); assertEquals(localCacheOne.refreshNanos, localCacheTwo.refreshNanos); assertEquals(localCacheOne.removalListener, localCacheTwo.removalListener); assertEquals(localCacheOne.ticker, localCacheTwo.ticker); // serialize the reconstituted version to be sure we haven't lost the ability to reserialize LocalLoadingCache<Object, Object> three = SerializableTester.reserialize(two); LocalCache<Object, Object> localCacheThree = three.localCache; assertEquals(localCacheTwo.defaultLoader, localCacheThree.defaultLoader); assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength); assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength); assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence); assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence); assertEquals(localCacheTwo.maxWeight, localCacheThree.maxWeight); assertEquals(localCacheTwo.weigher, localCacheThree.weigher); assertEquals(localCacheTwo.expireAfterAccessNanos, localCacheThree.expireAfterAccessNanos); assertEquals(localCacheTwo.expireAfterWriteNanos, localCacheThree.expireAfterWriteNanos); assertEquals(localCacheTwo.removalListener, localCacheThree.removalListener); assertEquals(localCacheTwo.ticker, localCacheThree.ticker); }
private static <K, V> LocalLoadingCache<K, V> makeCache( CacheBuilder<K, V> builder, CacheLoader<? super K, V> loader) { return new LocalLoadingCache<K, V>(builder, loader); }
public void testAsMap() { CacheBuilder<Object, Object> builder = createCacheBuilder(); LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader()); assertEquals(EMPTY_STATS, cache.stats()); Object one = new Object(); Object two = new Object(); Object three = new Object(); ConcurrentMap<Object, Object> map = cache.asMap(); assertNull(map.put(one, two)); assertSame(two, map.get(one)); map.putAll(ImmutableMap.of(two, three)); assertSame(three, map.get(two)); assertSame(two, map.putIfAbsent(one, three)); assertSame(two, map.get(one)); assertNull(map.putIfAbsent(three, one)); assertSame(one, map.get(three)); assertSame(two, map.replace(one, three)); assertSame(three, map.get(one)); assertFalse(map.replace(one, two, three)); assertSame(three, map.get(one)); assertTrue(map.replace(one, three, two)); assertSame(two, map.get(one)); assertEquals(3, map.size()); map.clear(); assertTrue(map.isEmpty()); assertEquals(0, map.size()); cache.getUnchecked(one); assertEquals(1, map.size()); assertSame(one, map.get(one)); assertTrue(map.containsKey(one)); assertTrue(map.containsValue(one)); assertSame(one, map.remove(one)); assertEquals(0, map.size()); cache.getUnchecked(one); assertEquals(1, map.size()); assertFalse(map.remove(one, two)); assertTrue(map.remove(one, one)); assertEquals(0, map.size()); cache.getUnchecked(one); Map<Object, Object> newMap = ImmutableMap.of(one, one); assertEquals(newMap, map); assertEquals(newMap.entrySet(), map.entrySet()); assertEquals(newMap.keySet(), map.keySet()); Set<Object> expectedValues = ImmutableSet.of(one); Set<Object> actualValues = ImmutableSet.copyOf(map.values()); assertEquals(expectedValues, actualValues); }
public void testSerializationProxyLoading() { CacheLoader<Object, Object> loader = new SerializableCacheLoader(); RemovalListener<Object, Object> listener = new SerializableRemovalListener<>(); SerializableWeigher<Object, Object> weigher = new SerializableWeigher<>(); Ticker ticker = new SerializableTicker(); @SuppressWarnings("unchecked") // createMock LocalLoadingCache<Object, Object> one = (LocalLoadingCache) CacheBuilder.newBuilder() .weakKeys() .softValues() .expireAfterAccess(123, SECONDS) .expireAfterWrite(456, MINUTES) .maximumWeight(789) .weigher(weigher) .concurrencyLevel(12) .removalListener(listener) .ticker(ticker) .build(loader); // add a non-serializable entry one.getUnchecked(new Object()); assertEquals(1, one.size()); assertFalse(one.asMap().isEmpty()); LocalLoadingCache<Object, Object> two = SerializableTester.reserialize(one); assertEquals(0, two.size()); assertTrue(two.asMap().isEmpty()); LocalCache<Object, Object> localCacheOne = one.localCache; LocalCache<Object, Object> localCacheTwo = two.localCache; assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength); assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength); assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence); assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence); assertEquals(localCacheOne.maxWeight, localCacheTwo.maxWeight); assertEquals(localCacheOne.weigher, localCacheTwo.weigher); assertEquals(localCacheOne.expireAfterAccessNanos, localCacheTwo.expireAfterAccessNanos); assertEquals(localCacheOne.expireAfterWriteNanos, localCacheTwo.expireAfterWriteNanos); assertEquals(localCacheOne.refreshNanos, localCacheTwo.refreshNanos); assertEquals(localCacheOne.removalListener, localCacheTwo.removalListener); assertEquals(localCacheOne.ticker, localCacheTwo.ticker); // serialize the reconstituted version to be sure we haven't lost the ability to reserialize LocalLoadingCache<Object, Object> three = SerializableTester.reserialize(two); LocalCache<Object, Object> localCacheThree = three.localCache; assertEquals(localCacheTwo.defaultLoader, localCacheThree.defaultLoader); assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength); assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength); assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence); assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence); assertEquals(localCacheTwo.maxWeight, localCacheThree.maxWeight); assertEquals(localCacheTwo.weigher, localCacheThree.weigher); assertEquals(localCacheTwo.expireAfterAccessNanos, localCacheThree.expireAfterAccessNanos); assertEquals(localCacheTwo.expireAfterWriteNanos, localCacheThree.expireAfterWriteNanos); assertEquals(localCacheTwo.removalListener, localCacheThree.removalListener); assertEquals(localCacheTwo.ticker, localCacheThree.ticker); }
private static <K, V> LocalLoadingCache<K, V> makeCache( CacheBuilder<K, V> builder, CacheLoader<? super K, V> loader) { return new LocalLoadingCache<>(builder, loader); }