How to use com.google.common.cache

void reclaimValue(ValueReference<K, V> valueReference) {
 ReferenceEntry<K, V> entry = valueReference.getEntry();
 int hash = entry.getHash();
 segmentFor(hash).reclaimValue(entry.getKey(), hash, valueReference);
}

public void testEviction_setMaxSegmentWeight() {
 IdentityLoader<Object> loader = identityLoader();
 for (int i = 1; i < 1000; i++) {
  LoadingCache<Object, Object> cache =
    CacheBuilder.newBuilder().maximumWeight(i).weigher(constantWeigher(1)).build(loader);
  assertEquals(i, CacheTesting.getTotalSegmentSize(cache));
 }
}

public void testEviction_setMaxSegmentSize() {
 IdentityLoader<Object> loader = identityLoader();
 for (int i = 1; i < 1000; i++) {
  LoadingCache<Object, Object> cache = CacheBuilder.newBuilder().maximumSize(i).build(loader);
  assertEquals(i, CacheTesting.getTotalSegmentSize(cache));
 }
}

public void testParse_writeExpirationHours() {
 CacheBuilderSpec spec = parse("expireAfterWrite=150h");
 assertEquals(TimeUnit.HOURS, spec.writeExpirationTimeUnit);
 assertEquals(150L, spec.writeExpirationDuration);
 assertCacheBuilderEquivalence(
   CacheBuilder.newBuilder().expireAfterWrite(150L, TimeUnit.HOURS), CacheBuilder.from(spec));
}

public void testParse_accessExpirationSeconds() {
 CacheBuilderSpec spec = parse("expireAfterAccess=10s");
 assertEquals(TimeUnit.SECONDS, spec.accessExpirationTimeUnit);
 assertEquals(10L, spec.accessExpirationDuration);
 assertCacheBuilderEquivalence(
   CacheBuilder.newBuilder().expireAfterAccess(10L, TimeUnit.SECONDS),
   CacheBuilder.from(spec));
}

public void testParse_recordStats() {
 CacheBuilderSpec spec = parse("recordStats");
 assertTrue(spec.recordStats);
 assertCacheBuilderEquivalence(CacheBuilder.newBuilder().recordStats(), CacheBuilder.from(spec));
}

public void testParse_softValues() {
 CacheBuilderSpec spec = parse("softValues");
 assertNull(spec.initialCapacity);
 assertNull(spec.maximumSize);
 assertNull(spec.maximumWeight);
 assertNull(spec.concurrencyLevel);
 assertNull(spec.keyStrength);
 assertEquals(Strength.SOFT, spec.valueStrength);
 assertNull(spec.writeExpirationTimeUnit);
 assertNull(spec.accessExpirationTimeUnit);
 assertCacheBuilderEquivalence(CacheBuilder.newBuilder().softValues(), 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));
}

public void testParse_weakValues() {
 CacheBuilderSpec spec = parse("weakValues");
 assertNull(spec.initialCapacity);
 assertNull(spec.maximumSize);
 assertNull(spec.maximumWeight);
 assertNull(spec.concurrencyLevel);
 assertNull(spec.keyStrength);
 assertEquals(Strength.WEAK, spec.valueStrength);
 assertNull(spec.writeExpirationTimeUnit);
 assertNull(spec.accessExpirationTimeUnit);
 assertCacheBuilderEquivalence(CacheBuilder.newBuilder().weakValues(), CacheBuilder.from(spec));
}

public void testParse_empty() {
 CacheBuilderSpec spec = parse("");
 assertNull(spec.initialCapacity);
 assertNull(spec.maximumSize);
 assertNull(spec.maximumWeight);
 assertNull(spec.concurrencyLevel);
 assertNull(spec.keyStrength);
 assertNull(spec.valueStrength);
 assertNull(spec.writeExpirationTimeUnit);
 assertNull(spec.accessExpirationTimeUnit);
 assertCacheBuilderEquivalence(CacheBuilder.newBuilder(), CacheBuilder.from(spec));
}

public void testInvalidateAll_empty() {
 for (LoadingCache<Object, Object> cache : caches()) {
  cache.getUnchecked("a");
  cache.getUnchecked("b");
  cache.getUnchecked("c");
  cache.invalidateAll();
  checkEmpty(cache);
 }
}

public void testGet_null() throws ExecutionException {
 for (LoadingCache<Object, Object> cache : caches()) {
  try {
   cache.get(null);
   fail("Expected NullPointerException");
  } catch (NullPointerException expected) {
  }
  checkEmpty(cache);
 }
}

public void testGetUnchecked_null() {
 for (LoadingCache<Object, Object> cache : caches()) {
  try {
   cache.getUnchecked(null);
   fail("Expected NullPointerException");
  } catch (NullPointerException expected) {
  }
  checkEmpty(cache);
 }
}

static <K, V> void assertNotified(
  QueuingRemovalListener<K, V> listener, K key, V value, RemovalCause cause) {
 RemovalNotification<K, V> notification = listener.remove();
 assertSame(key, notification.getKey());
 assertSame(value, notification.getValue());
 assertSame(cause, notification.getCause());
}

public void testSize_populated() {
 for (LoadingCache<Object, Object> cache : caches()) {
  // don't let the entries get GCed
  List<Entry<Object, Object>> warmed = warmUp(cache);
  assertEquals(WARMUP_SIZE, cache.size());
  assertMapSize(cache.asMap(), WARMUP_SIZE);
  checkValidState(cache);
 }
}

public void testGetOrDefault() {
 LocalCache<Object, Object> map =
   makeLocalCache(createCacheBuilder().concurrencyLevel(1).initialCapacity(1));
 map.put(1, 1);
 assertEquals(1, map.getOrDefault(1, 2));
 assertEquals(2, map.getOrDefault(2, 2));
}

public void testSetRemovalListener() {
 RemovalListener<Object, Object> testListener = TestingRemovalListeners.nullRemovalListener();
 LocalCache<Object, Object> map =
   makeLocalCache(createCacheBuilder().removalListener(testListener));
 assertSame(testListener, map.removalListener);
}

private static <K, V> void assertConnected(
  LocalCache<K, V> map, ReferenceEntry<K, V> one, ReferenceEntry<K, V> two) {
 if (map.usesWriteQueue()) {
  assertSame(two, one.getNextInWriteQueue());
 }
 if (map.usesAccessQueue()) {
  assertSame(two, one.getNextInAccessQueue());
 }
}

public void testParse_writeExpirationMinutes() {
 CacheBuilderSpec spec = parse("expireAfterWrite=10m");
 assertEquals(TimeUnit.MINUTES, spec.writeExpirationTimeUnit);
 assertEquals(10L, spec.writeExpirationDuration);
 assertCacheBuilderEquivalence(
   CacheBuilder.newBuilder().expireAfterWrite(10L, TimeUnit.MINUTES), CacheBuilder.from(spec));
}

public void testParse_accessExpirationMinutes() {
 CacheBuilderSpec spec = parse("expireAfterAccess=10m");
 assertEquals(TimeUnit.MINUTES, spec.accessExpirationTimeUnit);
 assertEquals(10L, spec.accessExpirationDuration);
 assertCacheBuilderEquivalence(
   CacheBuilder.newBuilder().expireAfterAccess(10L, TimeUnit.MINUTES),
   CacheBuilder.from(spec));
}