@Test(expectedExceptions = IllegalStateException.class) public void removalListener_twice() { Caffeine.newBuilder().removalListener((k, v, c) -> {}).removalListener((k, v, c) -> {}); }
@Test(expectedExceptions = NullPointerException.class) public void removalListener_null() { Caffeine.newBuilder().removalListener(null); }
public void testRemovalListener_setTwice() { RemovalListener<Object, Object> testListener = nullRemovalListener(); Caffeine<Object, Object> builder = Caffeine.newBuilder().removalListener(testListener); try { // even to the same instance is not allowed builder = builder.removalListener(testListener); fail(); } catch (IllegalStateException expected) {} }
@Test public void removalListener() { RemovalListener<Object, Object> removalListener = (k, v, c) -> {}; Caffeine<?, ?> builder = Caffeine.newBuilder().removalListener(removalListener); assertThat(builder.getRemovalListener(false), is(removalListener)); builder.build(); }
@Test public void configured() { Caffeine<Object, Object> configured = Caffeine.newBuilder() .initialCapacity(1).weakKeys() .expireAfterAccess(1, TimeUnit.SECONDS).expireAfterWrite(1, TimeUnit.SECONDS) .removalListener((k, v, c) -> {}).recordStats(); assertThat(configured.build(), is(not(nullValue()))); assertThat(configured.buildAsync(), is(not(nullValue()))); assertThat(configured.build(loader), is(not(nullValue()))); assertThat(configured.buildAsync(loader), is(not(nullValue()))); assertThat(configured.refreshAfterWrite(1, TimeUnit.SECONDS).toString(), is(not(Caffeine.newBuilder().toString()))); assertThat(Caffeine.newBuilder().maximumSize(1).toString(), is(not(Caffeine.newBuilder().maximumWeight(1).toString()))); }
public void testNewBuilder() { CacheLoader<Object, Integer> loader = constantLoader(1); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .removalListener(countingRemovalListener()), loader); assertEquals(Integer.valueOf(1), cache.getUnchecked("one")); assertEquals(1, cache.size()); }
public void testGet_computeNull() { LoadingCache<Object, Object> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumSize(0) .removalListener(listener), constantLoader(null)); try { cache.getUnchecked(new Object()); fail(); } catch (InvalidCacheLoadException e) { /* expected */} assertTrue(listener.isEmpty()); checkEmpty(cache); }
public void testEviction_overflow() { CountingRemovalListener<Object, Object> removalListener = countingRemovalListener(); IdentityLoader<Object> loader = identityLoader(); LoadingCache<Object, Object> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumWeight(1L << 31) .executor(MoreExecutors.directExecutor()) .weigher(constantWeigher(Integer.MAX_VALUE)) .removalListener(removalListener), loader); cache.getUnchecked(objectWithHash(0)); cache.getUnchecked(objectWithHash(0)); assertEquals(1, removalListener.getCount()); }
public void testGet_runtimeException() { final RuntimeException e = new RuntimeException(); LoadingCache<Object, Object> map = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumSize(0) .removalListener(listener), exceptionLoader(e)); try { map.getUnchecked(new Object()); fail(); } catch (UncheckedExecutionException uee) { assertSame(e, uee.getCause()); } assertTrue(listener.isEmpty()); checkEmpty(map); } }
public void testGet() { Object computed = new Object(); LoadingCache<Object, Object> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .maximumSize(0) .removalListener(listener), constantLoader(computed)); Object key = new Object(); assertSame(computed, cache.getUnchecked(key)); RemovalNotification<Object, Object> notification = listener.remove(); assertSame(key, notification.getKey()); assertSame(computed, notification.getValue()); assertSame(RemovalCause.SIZE, notification.getCause()); assertTrue(listener.isEmpty()); checkEmpty(cache); }
public void testExpiringGet_expireAfterAccess() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterAccess(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); runExpirationTest(cache, loader, ticker, removalListener); }
public void testExpiration_expireAfterAccess() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterAccess(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); checkExpiration(cache, loader, ticker, removalListener); }
@GwtIncompatible("CacheTesting") public void testNullCache() { CountingRemovalListener<Object, Object> listener = countingRemovalListener(); LoadingCache<Object, Object> nullCache = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumSize(0) .executor(MoreExecutors.directExecutor()) .removalListener(listener), 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 testExpiration_expireAfterWrite() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); checkExpiration(cache, loader, ticker, removalListener); }
public void testExpiringGet_expireAfterWrite() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); runExpirationTest(cache, loader, ticker, removalListener); }
public void testRemovalScheduler_expireAfterWrite() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME); }
public void testRemovalScheduler_expireAfterAccess() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterAccess(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME); }
public void testRemovalScheduler_expireAfterBoth() { FakeTicker ticker = new FakeTicker(); CountingRemovalListener<String, Integer> removalListener = countingRemovalListener(); WatchedCreatorLoader loader = new WatchedCreatorLoader(); LoadingCache<String, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterAccess(EXPIRING_TIME, MILLISECONDS) .expireAfterWrite(EXPIRING_TIME, MILLISECONDS) .executor(MoreExecutors.directExecutor()) .removalListener(removalListener) .ticker(ticker::read), loader); runRemovalScheduler(cache, removalListener, loader, ticker, KEY_PREFIX, EXPIRING_TIME); }
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); }
public void testEviction_maxWeight() { CountingRemovalListener<Integer, Integer> removalListener = countingRemovalListener(); IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)) .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); }