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 testRemove_byKeyAndValue() { 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++) { Object key = warmed.get(i - WARMUP_MIN).getKey(); Object value = warmed.get(i - WARMUP_MIN).getValue(); assertFalse(cache.asMap().remove(key, -1)); assertTrue(cache.asMap().remove(key, value)); assertFalse(cache.asMap().remove(key, -1)); assertFalse(cache.asMap().containsKey(key)); } 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 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 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 testValues_populated() { for (LoadingCache<Object, Object> cache : caches()) { Collection<Object> values = cache.asMap().values(); List<Entry<Object, Object>> warmed = warmUp(cache); Collection<Object> expected = Maps.newHashMap(cache.asMap()).values(); assertThat(values).containsExactlyElementsIn(expected); assertThat(values.toArray()).asList().containsExactlyElementsIn(expected); assertThat(values.toArray(new Object[0])).asList().containsExactlyElementsIn(expected); assertEquals(WARMUP_SIZE, values.size()); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Object value = warmed.get(i - WARMUP_MIN).getValue(); assertTrue(values.contains(value)); assertTrue(values.remove(value)); assertFalse(values.remove(value)); assertFalse(values.contains(value)); } checkEmpty(values); checkEmpty(cache); } }
public void testRemove_byKeyAndValue() { 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++) { Object key = warmed.get(i - WARMUP_MIN).getKey(); Object value = warmed.get(i - WARMUP_MIN).getValue(); assertFalse(cache.asMap().remove(key, -1)); assertTrue(cache.asMap().remove(key, value)); assertFalse(cache.asMap().remove(key, -1)); assertFalse(cache.asMap().containsKey(key)); } checkEmpty(cache); } }
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 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 testKeySet_populated() { for (LoadingCache<Object, Object> cache : caches()) { Set<Object> keys = cache.asMap().keySet(); List<Entry<Object, Object>> warmed = warmUp(cache); Set<Object> expected = Maps.newHashMap(cache.asMap()).keySet(); assertThat(keys).containsExactlyElementsIn(expected); assertThat(keys.toArray()).asList().containsExactlyElementsIn(expected); assertThat(keys.toArray(new Object[0])).asList().containsExactlyElementsIn(expected); new EqualsTester() .addEqualityGroup(cache.asMap().keySet(), keys) .addEqualityGroup(ImmutableSet.of()) .testEquals(); assertEquals(WARMUP_SIZE, keys.size()); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Object key = warmed.get(i - WARMUP_MIN).getKey(); assertTrue(keys.contains(key)); assertTrue(keys.remove(key)); assertFalse(keys.remove(key)); assertFalse(keys.contains(key)); } checkEmpty(keys); 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); } }
@SuppressWarnings("unchecked") // generic array creation public void testEntrySet_populated() { for (LoadingCache<Object, Object> cache : caches()) { Set<Entry<Object, Object>> entries = cache.asMap().entrySet(); List<Entry<Object, Object>> warmed = warmUp(cache, WARMUP_MIN, WARMUP_MAX); Set<?> expected = Maps.newHashMap(cache.asMap()).entrySet(); assertThat(entries).containsExactlyElementsIn((Collection<Entry<Object, Object>>) expected); assertThat(entries.toArray()) .asList() .containsExactlyElementsIn((Collection<Object>) expected); assertThat(entries.toArray(new Entry[0])) .asList() .containsExactlyElementsIn((Collection<Entry>) expected); new EqualsTester() .addEqualityGroup(cache.asMap().entrySet(), entries) .addEqualityGroup(ImmutableSet.of()) .testEquals(); assertEquals(WARMUP_SIZE, entries.size()); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Entry<Object, Object> newEntry = warmed.get(i - WARMUP_MIN); assertTrue(entries.contains(newEntry)); assertTrue(entries.remove(newEntry)); assertFalse(entries.remove(newEntry)); assertFalse(entries.contains(newEntry)); } checkEmpty(entries); checkEmpty(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 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 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 testValues_populated() { for (LoadingCache<Object, Object> cache : caches()) { Collection<Object> values = cache.asMap().values(); List<Entry<Object, Object>> warmed = warmUp(cache); Collection<Object> expected = Maps.newHashMap(cache.asMap()).values(); assertThat(values).containsExactlyElementsIn(expected); assertThat(values.toArray()).asList().containsExactlyElementsIn(expected); assertThat(values.toArray(new Object[0])).asList().containsExactlyElementsIn(expected); assertEquals(WARMUP_SIZE, values.size()); for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) { Object value = warmed.get(i - WARMUP_MIN).getValue(); assertTrue(values.contains(value)); assertTrue(values.remove(value)); assertFalse(values.remove(value)); assertFalse(values.contains(value)); } checkEmpty(values); checkEmpty(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 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); } }