switch (keyStrength) { case WEAK: builder.weakKeys(); break; default:
public void testCacheBuilderFrom_string() { CacheBuilder<?, ?> fromString = CacheBuilder.from( "initialCapacity=10,maximumSize=20,concurrencyLevel=30," + "weakKeys,weakValues,expireAfterAccess=10m"); CacheBuilder<?, ?> expected = CacheBuilder.newBuilder() .initialCapacity(10) .maximumSize(20) .concurrencyLevel(30) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES); assertCacheBuilderEquivalence(expected, fromString); }
/** Returns an iterable containing all combinations weakKeys and weak/softValues. */ @SuppressWarnings("unchecked") // varargs private static Iterable<CacheBuilder<Object, Object>> allKeyValueStrengthMakers() { return ImmutableList.of( createCacheBuilder(), createCacheBuilder().weakValues(), createCacheBuilder().softValues(), createCacheBuilder().weakKeys(), createCacheBuilder().weakKeys().weakValues(), createCacheBuilder().weakKeys().softValues()); }
switch (keyStrength) { case WEAK: builder.weakKeys(); break; default:
CacheBuilder.newBuilder().weakKeys().build(computeFunction);
switch (keyStrength) { case WEAK: builder.weakKeys(); break; default:
public void testSetWeakKeys() { LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().weakKeys()); checkStrength(map, Strength.WEAK, Strength.STRONG); assertSame(EntryFactory.WEAK, map.entryFactory); }
public void testReloadAfterSimulatedKeyReclamation() throws ExecutionException { CountingLoader countingLoader = new CountingLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().concurrencyLevel(1).weakKeys().build(countingLoader); Object key = new Object(); assertNotNull(cache.getUnchecked(key)); assertEquals(1, cache.size()); CacheTesting.simulateKeyReclamation(cache, key); // this blocks if computation can't deal with partially-collected values assertNotNull(cache.getUnchecked(key)); assertEquals(2, countingLoader.getCount()); CacheTesting.simulateKeyReclamation(cache, key); cache.refresh(key); checkNothingLogged(); assertEquals(3, countingLoader.getCount()); }
public void testParse_multipleKeys() { CacheBuilderSpec spec = parse( "initialCapacity=10,maximumSize=20,concurrencyLevel=30," + "weakKeys,weakValues,expireAfterAccess=10m,expireAfterWrite=1h"); assertEquals(10, spec.initialCapacity.intValue()); assertEquals(20, spec.maximumSize.intValue()); assertNull(spec.maximumWeight); assertEquals(30, spec.concurrencyLevel.intValue()); assertEquals(Strength.WEAK, spec.keyStrength); assertEquals(Strength.WEAK, spec.valueStrength); assertEquals(TimeUnit.HOURS, spec.writeExpirationTimeUnit); assertEquals(TimeUnit.MINUTES, spec.accessExpirationTimeUnit); assertEquals(1L, spec.writeExpirationDuration); assertEquals(10L, spec.accessExpirationDuration); CacheBuilder<?, ?> expected = CacheBuilder.newBuilder() .initialCapacity(10) .maximumSize(20) .concurrencyLevel(30) .weakKeys() .weakValues() .expireAfterAccess(10L, TimeUnit.MINUTES) .expireAfterWrite(1L, TimeUnit.HOURS); assertCacheBuilderEquivalence(expected, CacheBuilder.from(spec)); }
public void testParse_whitespaceAllowed() { CacheBuilderSpec spec = parse( " initialCapacity=10,\nmaximumSize=20,\t\r" + "weakKeys \t ,softValues \n , \r expireAfterWrite \t = 15s\n\n"); assertEquals(10, spec.initialCapacity.intValue()); assertEquals(20, spec.maximumSize.intValue()); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertEquals(Strength.WEAK, spec.keyStrength); assertEquals(Strength.SOFT, spec.valueStrength); assertEquals(TimeUnit.SECONDS, spec.writeExpirationTimeUnit); assertEquals(15L, spec.writeExpirationDuration); assertNull(spec.accessExpirationTimeUnit); CacheBuilder<?, ?> expected = CacheBuilder.newBuilder() .initialCapacity(10) .maximumSize(20) .weakKeys() .softValues() .expireAfterWrite(15L, TimeUnit.SECONDS); assertCacheBuilderEquivalence(expected, CacheBuilder.from(spec)); }
public void testParse_weakKeys() { CacheBuilderSpec spec = parse("weakKeys"); assertNull(spec.initialCapacity); assertNull(spec.maximumSize); assertNull(spec.maximumWeight); assertNull(spec.concurrencyLevel); assertEquals(Strength.WEAK, spec.keyStrength); assertNull(spec.valueStrength); assertNull(spec.writeExpirationTimeUnit); assertNull(spec.accessExpirationTimeUnit); assertCacheBuilderEquivalence(CacheBuilder.newBuilder().weakKeys(), CacheBuilder.from(spec)); }
(LocalManualCache) CacheBuilder.newBuilder() .weakKeys() .softValues() .expireAfterAccess(123, NANOSECONDS)
(LocalLoadingCache) CacheBuilder.newBuilder() .weakKeys() .softValues() .expireAfterAccess(123, SECONDS)
public ModelApply() { resultCache = CacheBuilder.newBuilder() .concurrencyLevel(4) .weakKeys() .maximumSize(100000) .expireAfterWrite(10, TimeUnit.MINUTES) .build(); }
builder.weakKeys(); } else if (context.keyStrength == ReferenceType.SOFT) { throw new IllegalStateException();
@Override public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException { this.name = name; this.serviceId = ManagementServerNode.getManagementServerId(); final int poolSize = SyncThreadPoolSize.value(); hostAlertCache = CacheBuilder.newBuilder() .concurrencyLevel(4) .weakKeys() .maximumSize(100 * poolSize) .expireAfterWrite(1, TimeUnit.DAYS) .build(); backgroundSyncBlockingExecutor = new ThreadPoolExecutor(poolSize, poolSize, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10 * poolSize, true), new ThreadPoolExecutor.CallerRunsPolicy()); backgroundPollManager.submitTask(new OutOfBandManagementPowerStatePollTask()); LOG.info("Starting out-of-band management background sync executor with thread pool-size=" + poolSize); return true; }
.createTestSuite()); suite.addTest( MapTestSuiteBuilder.using(new TestStringCacheGenerator(createCacheBuilder().weakKeys())) .named("LocalCache with weakKeys") // keys are string literals and won't be GC'd .withFeatures(
blacklist = CacheBuilder.newBuilder() .concurrencyLevel(4) .weakKeys() .expireAfterWrite(blacklistExpirationMin, TimeUnit.MINUTES) .build();