@Override public ConcurrentMap<K, V> asMap() { return delegate().asMap(); }
public void testInvalidate() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build(); cache.put(654, 2675); cache.put(2456, 56); cache.put(2, 15); cache.invalidate(654); assertFalse(cache.asMap().containsKey(654)); assertTrue(cache.asMap().containsKey(2456)); assertTrue(cache.asMap().containsKey(2)); }
public void testValuesIsNotASet() { assertFalse(CacheBuilder.newBuilder().build().asMap().values() instanceof Set); }
public void testComputeIfAbsentEviction() { // b/80241237 Cache<String, String> c = CacheBuilder.newBuilder().maximumSize(1).build(); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo(""); assertThat(c.size()).isEqualTo(1); assertThat(c.asMap().computeIfAbsent("hash-2", k -> "")).isEqualTo(""); }
@Override public Map<Integer, Object> apply(final Consumer<Object> action) throws Exception { return CacheBuilder.newBuilder() // .expireAfterAccess(5, TimeUnit.SECONDS).removalListener(new RemovalListener<Object, Object>() { @Override public void onRemoval(RemovalNotification<Object, Object> notification) { try { action.accept(notification.getValue()); } catch (Exception ex) { throw new RuntimeException(ex); } } }).ticker(testTicker) // .<Integer, Object>build().asMap(); } };
public void testComputeIfAbsent_RemovalListener() { List<RemovalNotification<Object, Object>> notifications = new ArrayList<>(); RemovalListener<Object, Object> removalListener = new RemovalListener<Object, Object>() { @Override public void onRemoval(RemovalNotification<Object, Object> notification) { notifications.add(notification); } }; Cache<Object, Object> cache = CacheBuilder.newBuilder().removalListener(removalListener).build(); cache.put("a", "b"); cache.asMap().computeIfAbsent("a", k -> "c"); assertTrue(notifications.toString(), notifications.isEmpty()); }
public void testAsMapValues_iteratorRemove() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); Iterator<Integer> iterator = cache.asMap().values().iterator(); iterator.next(); iterator.remove(); assertEquals(0, cache.size()); } }
public void testComputeEviction() { // b/80241237 Cache<String, String> c = CacheBuilder.newBuilder().maximumSize(1).build(); assertThat(c.asMap().compute("hash-1", (k, v) -> "a")).isEqualTo("a"); assertThat(c.asMap().compute("hash-1", (k, v) -> "b")).isEqualTo("b"); assertThat(c.asMap().compute("hash-1", (k, v) -> "c")).isEqualTo("c"); assertThat(c.size()).isEqualTo(1); assertThat(c.asMap().computeIfAbsent("hash-2", k -> "")).isEqualTo(""); }
public void testAsMapKeySet_contains() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); assertTrue(cache.asMap().keySet().contains(20)); assertTrue(cache.asMap().keySet().contains(5)); assertFalse(cache.asMap().keySet().contains(10)); }
public void testAsMapValues_contains() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); assertTrue(cache.asMap().values().contains(22)); assertTrue(cache.asMap().values().contains(10)); assertFalse(cache.asMap().values().contains(20)); }
public void testPutAll() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build(); cache.putAll(ImmutableMap.of(10, 20, 30, 50, 60, 90)); assertEquals(Integer.valueOf(20), cache.getIfPresent(10)); assertEquals(Integer.valueOf(50), cache.getIfPresent(30)); assertEquals(Integer.valueOf(90), cache.getIfPresent(60)); cache.asMap().putAll(ImmutableMap.of(10, 50, 30, 20, 60, 70, 5, 5)); assertEquals(Integer.valueOf(50), cache.getIfPresent(10)); assertEquals(Integer.valueOf(20), cache.getIfPresent(30)); assertEquals(Integer.valueOf(70), cache.getIfPresent(60)); assertEquals(Integer.valueOf(5), cache.getIfPresent(5)); }
public void testAsMap_containsKey() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(20000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(654, 2675); fakeTicker.advance(10000, TimeUnit.MILLISECONDS); cache.put(2456, 56); cache.put(2, 15); fakeTicker.advance(10001, TimeUnit.MILLISECONDS); assertTrue(cache.asMap().containsKey(2)); assertTrue(cache.asMap().containsKey(2456)); assertFalse(cache.asMap().containsKey(654)); }
public void testAsMapKeySet() { Cache<Integer, Integer> cache = CacheBuilder.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .ticker(fakeTicker) .build(); cache.put(10, 20); fakeTicker.advance(500, TimeUnit.MILLISECONDS); cache.put(20, 22); cache.put(5, 10); fakeTicker.advance(501, TimeUnit.MILLISECONDS); Set<Integer> foundKeys = new HashSet<>(cache.asMap().keySet()); assertEquals(ImmutableSet.of(20, 5), foundKeys); }
public void testComputeIfPresent() { cache.put(key, "1"); // simultaneous update for same key, expect count successful updates doParallelCacheOp( count, n -> { cache.asMap().computeIfPresent(key, (k, v) -> v + delimiter + n); }); assertEquals(1, cache.size()); assertThat(cache.getIfPresent(key).split(delimiter)).hasLength(count + 1); }
public void testComputeIfAbsent() { // simultaneous insertion for same key, expect 1 winner doParallelCacheOp( count, n -> { cache.asMap().computeIfAbsent(key, k -> "value" + n); }); assertEquals(1, cache.size()); }
public void testComputeExceptionally() { try { doParallelCacheOp(count, n -> { cache.asMap().compute(key, (k, v) -> { throw new RuntimeException(); }); }); fail("Should not get here"); } catch (RuntimeException ex) { } } }
public void testUpdates() { cache.put(key, "1"); // simultaneous update for same key, some null, some non-null doParallelCacheOp( count, n -> { cache.asMap().compute(key, (k, v) -> n % 2 == 0 ? v + delimiter + n : null); }); assertTrue(1 >= cache.size()); }
public void testCompute() { cache.put(key, "1"); // simultaneous deletion doParallelCacheOp( count, n -> { cache.asMap().compute(key, (k, v) -> null); }); assertEquals(0, cache.size()); }