RegexStringMatchingStrategy() { patternCache = Caffeine.newBuilder() .expireAfterWrite(1, TimeUnit.HOURS) .build(Pattern::compile); }
@Test(expectedExceptions = IllegalStateException.class) public void expireAfterWrite_twice() { Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.MILLISECONDS) .expireAfterWrite(1, TimeUnit.MILLISECONDS); }
@Test(expectedExceptions = IllegalStateException.class) public void expireAfterWrite_duration_twice() { Caffeine.newBuilder().expireAfterWrite(Duration.ofMillis(1)) .expireAfterWrite(Duration.ofMillis(1)); }
public void testTimeToLive_setTwice() { Caffeine<Object, Object> builder = Caffeine.newBuilder().expireAfterWrite(3600, SECONDS); try { // even to the same value is not allowed builder.expireAfterWrite(3600, SECONDS); fail(); } catch (IllegalStateException expected) {} }
/** Configures the write expiration and returns if set. */ private boolean configureExpireAfterWrite() { if (config.getExpireAfterWrite().isPresent()) { caffeine.expireAfterWrite(config.getExpireAfterWrite().getAsLong(), TimeUnit.NANOSECONDS); } return config.getExpireAfterWrite().isPresent(); }
@GwtIncompatible // java.time.Duration public void testTimeToLive_setTwice_duration() { Caffeine<Object, Object> builder = Caffeine.newBuilder().expireAfterWrite(java.time.Duration.ofSeconds(3600)); try { // even to the same value is not allowed builder.expireAfterWrite(java.time.Duration.ofSeconds(3600)); fail(); } catch (IllegalStateException expected) { } }
@Test public void expireAfterWrite_small() { Caffeine<?, ?> builder = Caffeine.newBuilder().expireAfterWrite(0, TimeUnit.MILLISECONDS); assertThat(builder.expireAfterWriteNanos, is(0L)); Expiration<?, ?> expiration = builder.build().policy().expireAfterWrite().get(); assertThat(expiration.getExpiresAfter(TimeUnit.MILLISECONDS), is(0L)); }
@Test public void expireAfterWrite_large() { Caffeine<?, ?> builder = Caffeine.newBuilder() .expireAfterWrite(Integer.MAX_VALUE, TimeUnit.NANOSECONDS); assertThat(builder.expireAfterWriteNanos, is((long) Integer.MAX_VALUE)); Expiration<?, ?> expiration = builder.build().policy().expireAfterWrite().get(); assertThat(expiration.getExpiresAfter(TimeUnit.NANOSECONDS), is((long) Integer.MAX_VALUE)); }
public void testTimeToLive_negative() { Caffeine<Object, Object> builder = Caffeine.newBuilder(); try { builder.expireAfterWrite(-1, SECONDS); fail(); } catch (IllegalArgumentException expected) {} }
public void testAsMapValues_iteratorRemove() { Cache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(1000, TimeUnit.MILLISECONDS) .executor(MoreExecutors.directExecutor()) .ticker(fakeTicker::read)); cache.put(10, 20); Iterator<Integer> iterator = cache.asMap().values().iterator(); iterator.next(); iterator.remove(); assertEquals(0, cache.size()); } }
@Test public void expireAfterWrite_duration_large() { Caffeine<?, ?> builder = Caffeine.newBuilder() .expireAfterWrite(Duration.ofNanos(Integer.MAX_VALUE)); assertThat(builder.expireAfterWriteNanos, is((long) Integer.MAX_VALUE)); Expiration<?, ?> expiration = builder.build().policy().expireAfterWrite().get(); assertThat(expiration.getExpiresAfter(TimeUnit.NANOSECONDS), is((long) Integer.MAX_VALUE)); }
public void testConcurrentExpirationLoading() throws InterruptedException { testConcurrentLoading(Caffeine.newBuilder() .expireAfterWrite(10, TimeUnit.SECONDS) .executor(MoreExecutors.directExecutor())); }
@GwtIncompatible // java.time.Duration public void testTimeToLive_negative_duration() { Caffeine<Object, Object> builder = Caffeine.newBuilder(); try { builder.expireAfterWrite(java.time.Duration.ofSeconds(-1)); fail(); } catch (IllegalArgumentException expected) { } }
public void testTimeToLive_small() { CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(1, NANOSECONDS), identityLoader()); // well, it didn't blow up. }
public void testTimeToIdleAndToLive() { CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(1, NANOSECONDS) .expireAfterAccess(1, NANOSECONDS), identityLoader()); // well, it didn't blow up. }
public void testParse_writeExpirationMinutes() { CaffeineSpec spec = parse("expireAfterWrite=10m"); assertEquals(TimeUnit.MINUTES, spec.expireAfterWriteTimeUnit); assertEquals(10L, spec.expireAfterWriteDuration); assertCaffeineEquivalence( Caffeine.newBuilder().expireAfterWrite(10L, TimeUnit.MINUTES), Caffeine.from(spec)); }
public void testParse_writeExpirationSeconds() { CaffeineSpec spec = parse("expireAfterWrite=10s"); assertEquals(TimeUnit.SECONDS, spec.expireAfterWriteTimeUnit); assertEquals(10L, spec.expireAfterWriteDuration); assertCaffeineEquivalence( Caffeine.newBuilder().expireAfterWrite(10L, TimeUnit.SECONDS), Caffeine.from(spec)); }
public void testParse_writeExpirationHours() { CaffeineSpec spec = parse("expireAfterWrite=150h"); assertEquals(TimeUnit.HOURS, spec.expireAfterWriteTimeUnit); assertEquals(150L, spec.expireAfterWriteDuration); assertCaffeineEquivalence( Caffeine.newBuilder().expireAfterWrite(150L, TimeUnit.HOURS), Caffeine.from(spec)); }
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 testParse_accessExpirationAndWriteExpiration() { CaffeineSpec spec = parse("expireAfterAccess=10s,expireAfterWrite=9m"); assertEquals(TimeUnit.MINUTES, spec.expireAfterWriteTimeUnit); assertEquals(9L, spec.expireAfterWriteDuration); assertEquals(TimeUnit.SECONDS, spec.expireAfterAccessTimeUnit); assertEquals(10L, spec.expireAfterAccessDuration); assertCaffeineEquivalence( Caffeine.newBuilder() .expireAfterAccess(10L, TimeUnit.SECONDS) .expireAfterWrite(9L, TimeUnit.MINUTES), Caffeine.from(spec)); }