@Test(expectedExceptions = IllegalStateException.class) public void initialCapacity_twice() { Caffeine.newBuilder().initialCapacity(1).initialCapacity(1); }
@Test public void initialCapacity_large() { // don't build! just check that it configures Caffeine<?, ?> builder = Caffeine.newBuilder().initialCapacity(Integer.MAX_VALUE); assertThat(builder.initialCapacity, is(Integer.MAX_VALUE)); }
public void testInitialCapacity_setTwice() { Caffeine<Object, Object> builder = Caffeine.newBuilder().initialCapacity(16); try { // even to the same value is not allowed builder.initialCapacity(16); fail(); } catch (IllegalStateException expected) {} }
public void testInitialCapacity_large() { Caffeine.newBuilder().initialCapacity(Integer.MAX_VALUE); // that the builder didn't blow up is enough; // don't actually create this monster! }
@Test(expectedExceptions = IllegalArgumentException.class) public void initialCapacity_negative() { Caffeine.newBuilder().initialCapacity(-1); }
@Test public void initialCapacity_small() { // can't check, so just assert that it builds Caffeine<?, ?> builder = Caffeine.newBuilder().initialCapacity(0); assertThat(builder.initialCapacity, is(0)); builder.build(); }
public void testInitialCapacity_negative() { Caffeine<Object, Object> builder = Caffeine.newBuilder(); try { builder.initialCapacity(-1); fail(); } catch (IllegalArgumentException 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()))); }
public void testSizeConstraint() { final Cache<Integer, Integer> cache = CaffeinatedGuava.build(Caffeine.newBuilder() .executor(MoreExecutors.directExecutor()) .initialCapacity(100) .maximumSize(4)); // Enforce full initialization of internal structures for (int i = 0; i < 4; i++) { cache.put(i, i); } cache.invalidateAll(); cache.put(1, 10); cache.put(2, 20); cache.put(3, 30); cache.put(4, 40); cache.put(5, 50); assertEquals(null, cache.getIfPresent(10)); // Order required to remove dependence on access order / write order constraint. assertEquals(Integer.valueOf(10), cache.getIfPresent(1)); assertEquals(Integer.valueOf(20), cache.getIfPresent(2)); assertEquals(Integer.valueOf(30), cache.getIfPresent(3)); assertEquals(Integer.valueOf(50), cache.getIfPresent(5)); cache.put(1, 10); assertEquals(Integer.valueOf(10), cache.getIfPresent(1)); assertEquals(Integer.valueOf(20), cache.getIfPresent(2)); assertEquals(Integer.valueOf(30), cache.getIfPresent(3)); assertEquals(Integer.valueOf(50), cache.getIfPresent(5)); assertEquals(null, cache.getIfPresent(4)); }
public CaffeinePolicy(Config config) { policyStats = new PolicyStats("product.Caffeine"); BasicSettings settings = new BasicSettings(config); maximumSize = settings.maximumSize(); cache = Caffeine.newBuilder() .initialCapacity(maximumSize) .maximumSize(maximumSize) .executor(Runnable::run) .build(); }
.executor(MoreExecutors.directExecutor()) .removalListener(countingListener) .initialCapacity(100) .ticker(fakeTicker::read) .maximumSize(2));
.initialCapacity(1000) .executor(MoreExecutors.directExecutor()), computeFunction); ConcurrentMap<String,String> map = cache.asMap();
Caffeine<Object, Object> builder = Caffeine.newBuilder(); if (initialCapacity != UNSET_INT) { builder.initialCapacity(initialCapacity);
public void testCaffeineFrom_string() { Caffeine<?, ?> fromString = Caffeine.from( "initialCapacity=10,maximumSize=20,weakKeys,weakValues,expireAfterAccess=10m"); Caffeine<?, ?> expected = Caffeine.newBuilder() .initialCapacity(10) .maximumSize(20) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES); assertCaffeineEquivalence(expected, fromString); }
builder.initialCapacity(initialCapacity);
public void testParse_initialCapacity() { CaffeineSpec spec = parse("initialCapacity=10"); assertEquals(10, spec.initialCapacity); assertEquals(spec.maximumSize, UNSET_INT); assertEquals(spec.maximumWeight, UNSET_INT); assertNull(spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.expireAfterWriteTimeUnit); assertNull(spec.expireAfterAccessTimeUnit); assertNull(spec.refreshAfterWriteTimeUnit); assertCaffeineEquivalence( Caffeine.newBuilder().initialCapacity(10), Caffeine.from(spec)); }
public void testParse_whitespaceAllowed() { CaffeineSpec spec = parse(" initialCapacity=10,\nmaximumSize=20,\t\r" + "weakKeys \t ,softValues \n , \r expireAfterWrite \t = 15s\n\n"); assertEquals(10, spec.initialCapacity); assertEquals(20, spec.maximumSize); assertEquals(spec.maximumWeight, UNSET_INT); assertEquals(Strength.WEAK, spec.keyStrength); assertEquals(Strength.SOFT, spec.valueStrength); assertEquals(TimeUnit.SECONDS, spec.expireAfterWriteTimeUnit); assertEquals(15L, spec.expireAfterWriteDuration); assertNull(spec.expireAfterAccessTimeUnit); Caffeine<?, ?> expected = Caffeine.newBuilder() .initialCapacity(10) .maximumSize(20) .weakKeys() .softValues() .expireAfterWrite(15L, TimeUnit.SECONDS); assertCaffeineEquivalence(expected, Caffeine.from(spec)); }
public void testParse_multipleKeys() { CaffeineSpec spec = parse("initialCapacity=10,maximumSize=20," + "weakKeys,weakValues,expireAfterAccess=10m,expireAfterWrite=1h"); assertEquals(10, spec.initialCapacity); assertEquals(20, spec.maximumSize); assertEquals(spec.maximumWeight, UNSET_INT); assertEquals(Strength.WEAK, spec.keyStrength); assertEquals(Strength.WEAK, spec.valueStrength); assertEquals(TimeUnit.HOURS, spec.expireAfterWriteTimeUnit); assertEquals(TimeUnit.MINUTES, spec.expireAfterAccessTimeUnit); assertEquals(1L, spec.expireAfterWriteDuration); assertEquals(10L, spec.expireAfterAccessDuration); Caffeine<?, ?> expected = Caffeine.newBuilder() .initialCapacity(10) .maximumSize(20) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES) .expireAfterWrite(1L, TimeUnit.HOURS); assertCaffeineEquivalence(expected, Caffeine.from(spec)); }
public PluginCache() { loadingCache = Caffeine.newBuilder() .expireAfterWrite(365 * 100, TimeUnit.DAYS) .initialCapacity(10) .maximumSize(100) .recordStats() .build(new CacheLoader<String, String>() { @Override public String load(String key) throws Exception { return StringUtils.EMPTY; } }); }
builder.initialCapacity(context.initialCapacity.size());