@Test(expectedExceptions = IllegalStateException.class) public void maximumWeight_twice() { Caffeine.newBuilder().maximumWeight(1).maximumWeight(1); }
@Test(expectedExceptions = IllegalArgumentException.class) public void maximumWeight_negative() { Caffeine.newBuilder().maximumWeight(-1); }
/** Configures the maximum weight and returns if set. */ private boolean configureMaximumWeight() { if (config.getMaximumWeight().isPresent()) { caffeine.maximumWeight(config.getMaximumWeight().getAsLong()); Weigher<K, V> weigher = config.getWeigherFactory().map(Factory::create) .orElseThrow(() -> new IllegalStateException("Weigher not configured")); caffeine.weigher((K key, Expirable<V> expirable) -> { return weigher.weigh(key, expirable.get()); }); } return config.getMaximumWeight().isPresent(); }
@Test(expectedExceptions = IllegalStateException.class) public void maximumWeight_noWeigher() { Caffeine.newBuilder().maximumWeight(1).build(); }
@Test(expectedExceptions = IllegalStateException.class) public void maximumWeight_maximumSize() { Caffeine.newBuilder().maximumSize(1).maximumWeight(1); }
@Test(expectedExceptions = IllegalStateException.class) public void maximumSize_maximumWeight() { Caffeine.newBuilder().maximumWeight(1).maximumSize(1); }
public static CaffeineCache create(final CaffeineCacheConfig config, final Executor executor) { Caffeine<Object, Object> builder = Caffeine.newBuilder().recordStats(); if (config.getExpireAfter() >= 0) { builder .expireAfterAccess(config.getExpireAfter(), TimeUnit.MILLISECONDS); } if (config.getSizeInBytes() >= 0) { builder.maximumWeight(config.getSizeInBytes()); } else { builder.maximumWeight(Math.min(MAX_DEFAULT_BYTES, JvmUtils.getRuntimeInfo().getMaxHeapSizeBytes() / 10)); } builder .weigher((NamedKey key, byte[] value) -> value.length + key.key.length + key.namespace.length() * Character.BYTES + FIXED_COST) .executor(executor); return new CaffeineCache(builder.build(), config); }
@Test public void maximumWeight_small() { Caffeine<?, ?> builder = Caffeine.newBuilder() .maximumWeight(0).weigher(Weigher.singletonWeigher()); assertThat(builder.weigher, is(Weigher.singletonWeigher())); assertThat(builder.maximumWeight, is(0L)); Eviction<?, ?> eviction = builder.build().policy().eviction().get(); assertThat(eviction.getMaximum(), is(0L)); assertThat(eviction.isWeighted(), is(true)); }
@Test public void weigher() { Weigher<Object, Object> weigher = (k, v) -> 0; Caffeine<?, ?> builder = Caffeine.newBuilder().maximumWeight(0).weigher(weigher); assertThat(builder.weigher, is(sameInstance(weigher))); 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)); }
@GwtIncompatible("maximumWeight") public void testMaximumWeight_setTwice() { Caffeine<Object, Object> builder = Caffeine.newBuilder().maximumWeight(16); try { // even to the same value is not allowed builder.maximumWeight(16); fail(); } catch (IllegalStateException expected) {} try { builder.maximumSize(16); fail(); } catch (IllegalStateException expected) {} }
@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()))); }
@GwtIncompatible("maximumWeight") public void testMaximumWeight_negative() { Caffeine<Object, Object> builder = Caffeine.newBuilder(); try { builder.maximumWeight(-1); fail(); } catch (IllegalArgumentException expected) {} }
@GwtIncompatible("maximumWeight") public void testMaximumSize_andWeight() { Caffeine<Object, Object> builder = Caffeine.newBuilder().maximumSize(16); try { builder.maximumWeight(16); fail(); } catch (IllegalStateException expected) {} }
@GwtIncompatible("maximumWeight") public void testMaximumWeight_withoutWeigher() { Caffeine<Object, Object> builder = Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .maximumWeight(1); try { CaffeinatedGuava.build(builder, identityLoader()); fail(); } catch (IllegalStateException expected) {} }
@Test public void putWeighted_noOverflow() { Cache<Integer, Integer> cache = Caffeine.newBuilder() .executor(CacheExecutor.DIRECT.create()) .weigher(CacheWeigher.MAX_VALUE) .maximumWeight(Long.MAX_VALUE) .build(); BoundedLocalCache<Integer, Integer> map = asBoundedLocalCache(cache); cache.put(1, 1); map.lazySetEdenMaximum(0L); map.lazySetWeightedSize(BoundedLocalCache.MAXIMUM_CAPACITY); cache.put(2, 2); assertThat(map.size(), is(1)); assertThat(map.adjustedWeightedSize(), is(BoundedLocalCache.MAXIMUM_CAPACITY)); }
public void testEviction_maxWeightOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .maximumWeight(2 * MAX_SIZE) .weigher(constantWeigher(2)), loader); for (int i = 0; i < 2 * MAX_SIZE; i++) { cache.getUnchecked(i); assertEquals(Math.min(i + 1, MAX_SIZE), cache.size()); } assertEquals(MAX_SIZE, cache.size()); CacheTesting.checkValidState(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 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); }
public void testParse_maximumWeight() { CaffeineSpec spec = parse("maximumWeight=9000"); assertEquals(spec.initialCapacity, UNSET_INT); assertEquals(9000, spec.maximumWeight); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.expireAfterWriteTimeUnit); assertNull(spec.expireAfterAccessTimeUnit); assertNull(spec.refreshAfterWriteTimeUnit); assertCaffeineEquivalence( Caffeine.newBuilder().maximumWeight(9000), Caffeine.from(spec)); }