/** * Peeks into the cache's internals to check its internal consistency. Verifies that each * segment's count matches its #elements (after cleanup), each segment is unlocked, each entry * contains a non-null key and value, and the eviction and expiration queues are consistent (see * {@link #checkEviction}, {@link #checkExpiration}). */ static void checkValidState(Cache<?, ?> cache) { if (hasLocalCache(cache)) { checkValidState(toLocalCache(cache)); } }
static void checkEmpty(ConcurrentMap<?, ?> map) { checkEmpty(map.keySet()); checkEmpty(map.values()); checkEmpty(map.entrySet()); assertEquals(ImmutableMap.of(), map); assertEquals(ImmutableMap.of().hashCode(), map.hashCode()); assertEquals(ImmutableMap.of().toString(), map.toString()); if (map instanceof LocalCache) { LocalCache<?, ?> cchm = (LocalCache<?, ?>) map; checkValidState(cchm); assertTrue(cchm.isEmpty()); assertEquals(0, cchm.size()); for (LocalCache.Segment<?, ?> segment : cchm.segments) { assertEquals(0, segment.count); assertEquals(0, segmentSize(segment)); assertTrue(segment.writeQueue.isEmpty()); assertTrue(segment.accessQueue.isEmpty()); } } }
public void testPutAll_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); Object newKey = new Object(); Object newValue = new Object(); cache.asMap().putAll(ImmutableMap.of(newKey, newValue)); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(newValue, cache.getUnchecked(newKey)); assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testEviction_maxSizeOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(MAX_SIZE).build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(cache); }
public void testReplace_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN); Object newValue = new Object(); assertSame(entry.getValue(), cache.asMap().replace(entry.getKey(), newValue)); assertTrue(cache.asMap().replace(entry.getKey(), newValue, entry.getValue())); Object newKey = new Object(); assertNull(cache.asMap().replace(newKey, entry.getValue())); assertFalse(cache.asMap().replace(newKey, entry.getValue(), newValue)); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey())); assertFalse(cache.asMap().containsKey(newKey)); } assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testPutIfAbsent_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN); Object newValue = new Object(); assertSame(entry.getValue(), cache.asMap().putIfAbsent(entry.getKey(), newValue)); Object newKey = new Object(); assertNull(cache.asMap().putIfAbsent(newKey, entry.getValue())); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey())); assertEquals(entry.getValue(), cache.getUnchecked(newKey)); // don't let the new entry get GCed warmed.add(entryOf(newKey, entry.getValue())); } assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testWriteThroughEntry() { for (LoadingCache<Object, Object> cache : caches()) { cache.getUnchecked(1); Entry<Object, Object> entry = Iterables.getOnlyElement(cache.asMap().entrySet()); cache.invalidate(1); assertEquals(0, cache.size()); entry.setValue(3); assertEquals(1, cache.size()); assertEquals(3, cache.getIfPresent(1)); checkValidState(cache); try { entry.setValue(null); fail(); } catch (NullPointerException expected) { } checkValidState(cache); } }
public void testContainsKey_found() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN); assertTrue(cache.asMap().containsKey(entry.getKey())); assertTrue(cache.asMap().containsValue(entry.getValue())); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey())); } assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testPut_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN); Object newValue = new Object(); assertSame(entry.getValue(), cache.asMap().put(entry.getKey(), newValue)); // don't let the new entry get GCed warmed.add(entryOf(entry.getKey(), newValue)); Object newKey = new Object(); assertNull(cache.asMap().put(newKey, entry.getValue())); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(newValue, cache.getUnchecked(entry.getKey())); assertEquals(entry.getValue(), cache.getUnchecked(newKey)); // don't let the new entry get GCed warmed.add(entryOf(newKey, entry.getValue())); } assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testSize_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); assertEquals(WARMUP_SIZE, cache.size()); assertMapSize(cache.asMap(), WARMUP_SIZE); checkValidState(cache); } }
public void testPutAll_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed @SuppressWarnings("unused") List<Entry<Object, Object>> warmed = warmUp(cache); Object newKey = new Object(); Object newValue = new Object(); cache.asMap().putAll(ImmutableMap.of(newKey, newValue)); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(newValue, cache.getUnchecked(newKey)); assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testEviction_maxWeightOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)) .build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(cache); }
public void testContainsKey_found() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed List<Entry<Object, Object>> warmed = warmUp(cache); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN); assertTrue(cache.asMap().containsKey(entry.getKey())); assertTrue(cache.asMap().containsValue(entry.getValue())); // this getUnchecked() call shouldn't be a cache miss; verified below assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey())); } assertEquals(WARMUP_SIZE, cache.stats().missCount()); checkValidState(cache); } }
public void testEviction_maxSize() { CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .maximumSize(MAX_SIZE) .removalListener(removalListener) .build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertTrue(cache.size() <= MAX_SIZE); } assertEquals(MAX_SIZE, CacheTesting.accessQueueSize(cache)); assertEquals(MAX_SIZE, cache.size()); CacheTesting.processPendingNotifications(cache); assertEquals(MAX_SIZE, removalListener.getCount()); CacheTesting.checkValidState(cache); }
CacheTesting.checkValidState(cache);
public void testSize_populated() { for (LoadingCache<Object, Object> cache : caches()) { // don't let the entries get GCed @SuppressWarnings("unused") List<Entry<Object, Object>> warmed = warmUp(cache); assertEquals(WARMUP_SIZE, cache.size()); assertMapSize(cache.asMap(), WARMUP_SIZE); checkValidState(cache); } }
public void testEviction_maxSizeOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .maximumSize(MAX_SIZE), loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(cache); }
public void testEviction_maxWeight() { CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder() .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)) .removalListener(removalListener) .build(loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertTrue(cache.size() <= MAX_SIZE); } assertEquals(MAX_SIZE, CacheTesting.accessQueueSize(cache)); assertEquals(MAX_SIZE, cache.size()); CacheTesting.processPendingNotifications(cache); assertEquals(MAX_SIZE, removalListener.getCount()); CacheTesting.checkValidState(cache); }
public void testEviction_maxWeightOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)), loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(cache); }
public void testEviction_maxSize() { CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumSize(MAX_SIZE) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener), loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertTrue(cache.size() <= MAX_SIZE); } assertEquals(MAX_SIZE, cache.size()); assertEquals(MAX_SIZE, removalListener.getCount()); CacheTesting.checkValidState(cache); }