/** * Create a native Caffeine Cache instance for the specified cache name. * @param name the name of the cache * @return the native Caffeine Cache instance */ protected com.github.benmanes.caffeine.cache.Cache<Object, Object> createNativeCaffeineCache(String name) { if (this.cacheLoader != null) { return this.cacheBuilder.build(this.cacheLoader); } else { return this.cacheBuilder.build(); } }
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); }
/** * Returns a Caffeine cache wrapped in a Guava {@link Cache} facade. * * @param builder the configured cache builder * @return a cache exposed under the Guava APIs */ @NonNull public static <K, V, K1 extends K, V1 extends V> Cache<K1, V1> build( @NonNull Caffeine<K, V> builder) { return new CaffeinatedGuavaCache<>(builder.build()); }
@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 executor() { Caffeine<?, ?> builder = Caffeine.newBuilder().executor(MoreExecutors.directExecutor()); assertThat(builder.getExecutor(), is(MoreExecutors.directExecutor())); builder.build(); }
@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 ticker() { Ticker ticker = new FakeTicker()::read; Caffeine<?, ?> builder = Caffeine.newBuilder().ticker(ticker); assertThat(builder.ticker, is(ticker)); builder.build(); }
@Test public void expireAfterAccess_duration_small() { Caffeine<?, ?> builder = Caffeine.newBuilder().expireAfterAccess(Duration.ofMillis(0)); assertThat(builder.expireAfterAccessNanos, is(0L)); Expiration<?, ?> expiration = builder.build().policy().expireAfterAccess().get(); assertThat(expiration.getExpiresAfter(TimeUnit.MILLISECONDS), is(0L)); }
@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)); }
@Test public void recordStats_custom() { Supplier<StatsCounter> supplier = () -> statsCounter; Caffeine<?, ?> builder = Caffeine.newBuilder().recordStats(supplier); builder.statsCounterSupplier.get().recordEviction(1); verify(statsCounter).recordEviction(1); builder.build(); }
@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)); }
private static <K, V> ConcurrentMap<K, V> map() { return Caffeine.newBuilder() .maximumSize(Integer.MAX_VALUE) .<K, V>build().asMap(); }
@Test public void sanity() { LoadingCache<Integer, Integer> cache = Caffeine.newBuilder().build(k -> -k); assertEquals(-1, cache.get(1).intValue()); } }
public void testMaximumWeight_withoutWeigher() { Caffeine<Object, Object> builder = Caffeine.from(parse("maximumWeight=9000")); try { builder.build(k -> null); fail(); } catch (IllegalStateException expected) {} }