public void testValues_addNotSupported() { for (LoadingCache<Object, Object> cache : caches()) { try { cache.asMap().values().add(1); fail(); } catch (UnsupportedOperationException expected) { } try { cache.asMap().values().addAll(asList(1, 2)); fail(); } catch (UnsupportedOperationException expected) { } } }
public void testKeySet_addNotSupported() { for (LoadingCache<Object, Object> cache : caches()) { try { cache.asMap().keySet().add(1); fail(); } catch (UnsupportedOperationException expected) { } try { cache.asMap().keySet().addAll(asList(1, 2)); fail(); } catch (UnsupportedOperationException expected) { } } }
public void testRemove_byKey() { 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 key = entry.getKey(); assertEquals(entry.getValue(), cache.asMap().remove(key)); assertNull(cache.asMap().remove(key)); assertFalse(cache.asMap().containsKey(key)); } checkEmpty(cache); } }
public void testEntrySet_nullToArray() { for (LoadingCache<Object, Object> cache : caches()) { Set<Entry<Object, Object>> entries = cache.asMap().entrySet(); try { entries.toArray((Entry<Object, Object>[]) null); fail(); } catch (NullPointerException expected) { } checkEmpty(cache); } }
public void testKeySet_nullToArray() { for (LoadingCache<Object, Object> cache : caches()) { Set<Object> keys = cache.asMap().keySet(); try { keys.toArray((Object[]) null); fail(); } catch (NullPointerException expected) { } checkEmpty(cache); } }
public void testValues_nullToArray() { for (LoadingCache<Object, Object> cache : caches()) { Collection<Object> values = cache.asMap().values(); try { values.toArray((Object[]) null); fail(); } catch (NullPointerException expected) { } checkEmpty(cache); } }
public void testEntrySet_addNotSupported() { for (LoadingCache<Object, Object> cache : caches()) { try { cache.asMap().entrySet().add(entryOf(1, 1)); fail(); } catch (UnsupportedOperationException expected) { } try { cache.asMap().values().addAll(asList(entryOf(1, 1), entryOf(2, 2))); fail(); } catch (UnsupportedOperationException expected) { } } }
public void testClear() { for (LoadingCache<Key, String> cache : caches()) { Key key = new Key(1); String value = key.toString(); assertSame(value, cache.getUnchecked(key)); assertFalse(cache.asMap().isEmpty()); cache.invalidateAll(); assertEquals(0, cache.size()); assertTrue(cache.asMap().isEmpty()); assertFalse(cache.asMap().containsKey(key)); assertFalse(cache.asMap().containsValue(value)); } }
public void testKeySet_empty_remove() { for (LoadingCache<Object, Object> cache : caches()) { Set<Object> keys = cache.asMap().keySet(); assertFalse(keys.remove(null)); assertFalse(keys.remove(6)); assertFalse(keys.remove(-6)); assertFalse(keys.removeAll(asList(null, 0, 15, 1500))); assertFalse(keys.retainAll(asList(null, 0, 15, 1500))); checkEmpty(keys); checkEmpty(cache); } }
public void testValues_empty_remove() { for (LoadingCache<Object, Object> cache : caches()) { Collection<Object> values = cache.asMap().values(); assertFalse(values.remove(null)); assertFalse(values.remove(6)); assertFalse(values.remove(-6)); assertFalse(values.removeAll(asList(null, 0, 15, 1500))); assertFalse(values.retainAll(asList(null, 0, 15, 1500))); checkEmpty(values); checkEmpty(cache); } }
public void testDisableCaching() { // Functional test: assert that CacheBuilderSpec.disableCaching() // disables caching. It's irrelevant how it does so. CacheBuilder<Object, Object> builder = CacheBuilder.from(CacheBuilderSpec.disableCaching()); Object key = new Object(); Object value = new Object(); LoadingCache<Object, Object> cache = builder.build(CacheLoader.from(Suppliers.ofInstance(value))); assertSame(value, cache.getUnchecked(key)); assertEquals(0, cache.size()); assertFalse(cache.asMap().containsKey(key)); }
public void testValues_clear() { for (LoadingCache<Object, Object> cache : caches()) { warmUp(cache, 0, 100); Collection<Object> values = cache.asMap().values(); values.clear(); checkEmpty(values); checkEmpty(cache); } }
public void testKeySet_clear() { for (LoadingCache<Object, Object> cache : caches()) { warmUp(cache, 0, 100); Set<Object> keys = cache.asMap().keySet(); keys.clear(); checkEmpty(keys); checkEmpty(cache); } }
public void testEntrySet_clear() { for (LoadingCache<Object, Object> cache : caches()) { warmUp(cache, 0, 100); Set<Entry<Object, Object>> entrySet = cache.asMap().entrySet(); entrySet.clear(); checkEmpty(entrySet); checkEmpty(cache); } }
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 testContainsKeyAndValue() { for (LoadingCache<Key, String> cache : caches()) { // maintain strong refs so these won't be collected, regardless of cache's key/value strength Key key = new Key(1); String value = key.toString(); assertSame(value, cache.getUnchecked(key)); assertTrue(cache.asMap().containsKey(key)); assertTrue(cache.asMap().containsValue(value)); assertEquals(1, cache.size()); } }
@GwtIncompatible // CacheTesting public void testNullCache() { CountingRemovalListener<Object, Object> listener = countingRemovalListener(); LoadingCache<Object, Object> nullCache = CacheBuilder.newBuilder().maximumSize(0).removalListener(listener).build(identityLoader()); assertEquals(0, nullCache.size()); Object key = new Object(); assertSame(key, nullCache.getUnchecked(key)); assertEquals(1, listener.getCount()); assertEquals(0, nullCache.size()); CacheTesting.checkEmpty(nullCache.asMap()); }
public void testEntrySet_empty_remove() { for (LoadingCache<Object, Object> cache : caches()) { Set<Entry<Object, Object>> entrySet = cache.asMap().entrySet(); assertFalse(entrySet.remove(null)); assertFalse(entrySet.remove(entryOf(6, 6))); assertFalse(entrySet.remove(entryOf(-6, -6))); assertFalse(entrySet.removeAll(asList(null, entryOf(0, 0), entryOf(15, 15)))); assertFalse(entrySet.retainAll(asList(null, entryOf(0, 0), entryOf(15, 15)))); checkEmpty(entrySet); checkEmpty(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); } }