public MustacheViewRenderer() { this.factories = Caffeine.newBuilder().build(new CacheLoader<Class<? extends View>, MustacheFactory>() { @Override public MustacheFactory load(Class<? extends View> key) throws Exception { return createNewMustacheFactory(key); } }); }
RegexStringMatchingStrategy() { patternCache = Caffeine.newBuilder() .expireAfterWrite(1, TimeUnit.HOURS) .build(Pattern::compile); }
public FreemarkerViewRenderer() { this.loader = new TemplateLoader(); this.configurationCache = Caffeine.newBuilder().build(loader); }
@Test public void recordStats() { Caffeine<?, ?> builder = Caffeine.newBuilder().recordStats(); assertThat(builder.statsCounterSupplier, is(Caffeine.ENABLED_STATS_COUNTER_SUPPLIER)); builder.build(); }
@Before public void setUp() { nativeCache = Caffeine.newBuilder().build(); cache = new CaffeineCache(CACHE_NAME, nativeCache); com.github.benmanes.caffeine.cache.Cache<Object, Object> nativeCacheNoNull = Caffeine.newBuilder().build(); cacheNoNull = new CaffeineCache(CACHE_NAME_NO_NULL, nativeCacheNoNull, false); }
@Test public void refreshAfterWrite() { Caffeine<Object, Object> builder = Caffeine.newBuilder() .refreshAfterWrite(1, TimeUnit.MILLISECONDS); assertThat(builder.getRefreshAfterWriteNanos(), is(TimeUnit.MILLISECONDS.toNanos(1))); builder.build(k -> k); }
@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 writer() { Caffeine<?, ?> builder = Caffeine.newBuilder().writer(writer); assertThat(builder.getCacheWriter(), is(writer)); builder.build(); } }
@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 maximumWeight_large() { Caffeine<?, ?> builder = Caffeine.newBuilder() .maximumWeight(Integer.MAX_VALUE).weigher(Weigher.singletonWeigher()); assertThat(builder.maximumWeight, is((long) Integer.MAX_VALUE)); assertThat(builder.weigher, is(Weigher.singletonWeigher())); Eviction<?, ?> eviction = builder.build().policy().eviction().get(); assertThat(eviction.getMaximum(), is((long) Integer.MAX_VALUE)); assertThat(eviction.isWeighted(), is(true)); }
@GwtIncompatible // java.time.Duration public void testRefresh_zero_duration() { Caffeine<Object, Object> builder = Caffeine.newBuilder(); try { builder.refreshAfterWrite(java.time.Duration.ZERO); fail(); } catch (IllegalArgumentException expected) { } }
private static <K, V> ConcurrentMap<K, V> map() { return Caffeine.newBuilder() .maximumSize(Integer.MAX_VALUE) .<K, V>build().asMap(); }
public void testTimeToIdleAndToLive() { CaffeinatedGuava.build(Caffeine.newBuilder() .expireAfterWrite(1, NANOSECONDS) .expireAfterAccess(1, NANOSECONDS), identityLoader()); // well, it didn't blow up. }
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 testParse_recordStats() { CaffeineSpec spec = parse("recordStats"); assertTrue(spec.recordStats); assertCaffeineEquivalence(Caffeine.newBuilder().recordStats(), Caffeine.from(spec)); }
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 testParse_accessExpirationSeconds() { CaffeineSpec spec = parse("expireAfterAccess=10s"); assertEquals(TimeUnit.SECONDS, spec.expireAfterAccessTimeUnit); assertEquals(10L, spec.expireAfterAccessDuration); assertCaffeineEquivalence( Caffeine.newBuilder().expireAfterAccess(10L, TimeUnit.SECONDS), Caffeine.from(spec)); }
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); }
@Test public void changeCaffeineRecreateCache() { CaffeineCacheManager cm = new CaffeineCacheManager("c1"); Cache cache1 = cm.getCache("c1"); Caffeine<Object, Object> caffeine = Caffeine.newBuilder().maximumSize(10); cm.setCaffeine(caffeine); Cache cache1x = cm.getCache("c1"); assertTrue(cache1x != cache1); cm.setCaffeine(caffeine); // Set same instance Cache cache1xx = cm.getCache("c1"); assertSame(cache1x, cache1xx); }
public void testParse_empty() { CaffeineSpec spec = parse(""); assertEquals(spec.initialCapacity, UNSET_INT); assertEquals(spec.maximumSize, UNSET_INT); assertEquals(spec.maximumWeight, UNSET_INT); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.expireAfterAccessTimeUnit); assertNull(spec.expireAfterWriteTimeUnit); assertNull(spec.refreshAfterWriteTimeUnit); assertCaffeineEquivalence(Caffeine.newBuilder(), Caffeine.from(spec)); }