@Override public LoadingCache<Object, Object> apply(CacheBuilder<Object, Object> builder) { return builder.build(identityLoader()); } });
public void testTimeToLive_small() { CacheBuilder.newBuilder().expireAfterWrite(1, NANOSECONDS).build(identityLoader()); // well, it didn't blow up. }
public void testTimeToIdleAndToLive() { CacheBuilder.newBuilder() .expireAfterWrite(1, NANOSECONDS) .expireAfterAccess(1, NANOSECONDS) .build(identityLoader()); // well, it didn't blow up. }
public void testTimeToIdle_small() { CacheBuilder.newBuilder().expireAfterAccess(1, NANOSECONDS).build(identityLoader()); // well, it didn't blow up. }
@Override public LoadingCache<Object, Object> apply(CacheBuilder<Object, Object> builder) { return builder.recordStats().build(identityLoader()); } });
public void testUpdateRecency_onGet() { IdentityLoader<Integer> loader = identityLoader(); final LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().maximumSize(MAX_SIZE).build(loader); CacheTesting.checkRecency( cache, MAX_SIZE, new Receiver<ReferenceEntry<Integer, Integer>>() { @Override public void accept(ReferenceEntry<Integer, Integer> entry) { cache.getUnchecked(entry.getKey()); } }); }
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 testEqualsAndHashCode_different() { for (CacheBuilder<Object, Object> builder : cacheFactory().buildAllPermutations()) { // all caches should be different: instance equality new EqualsTester() .addEqualityGroup(builder.build(identityLoader())) .addEqualityGroup(builder.build(identityLoader())) .addEqualityGroup(builder.build(identityLoader())) .testEquals(); } }
@GwtIncompatible // maximumWeight public void testMaximumWeight_withoutWeigher() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().maximumWeight(1); try { builder.build(identityLoader()); fail(); } catch (IllegalStateException expected) { } }
@GwtIncompatible // CacheTesting public void testSizingDefaults() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); // concurrency level assertEquals(4, map.segments[0].table.length()); // capacity / conc level }
@GwtIncompatible // CacheTesting public void testConcurrencyLevel_small() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().concurrencyLevel(1).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(1); }
public void testEviction_maxSizeOneSegment() { IdentityLoader<Integer> loader = identityLoader(); LoadingCache<Integer, Integer> cache = CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(MAX_SIZE).build(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); }
@GwtIncompatible // weigher public void testWeigher_withoutMaximumWeight() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().weigher(constantWeigher(42)); try { builder.build(identityLoader()); fail(); } catch (IllegalStateException expected) { } }
@GwtIncompatible // CacheTesting public void testInitialCapacity_small() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().initialCapacity(5).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); assertEquals(2, map.segments[0].table.length()); assertEquals(2, map.segments[1].table.length()); assertEquals(2, map.segments[2].table.length()); assertEquals(2, map.segments[3].table.length()); }
@GwtIncompatible // CacheTesting public void testInitialCapacity_smallest() { LoadingCache<?, ?> cache = CacheBuilder.newBuilder().initialCapacity(0).build(identityLoader()); LocalCache<?, ?> map = CacheTesting.toLocalCache(cache); assertThat(map.segments).hasLength(4); // 1 is as low as it goes, not 0. it feels dirty to know this/test this. assertEquals(1, map.segments[0].table.length()); assertEquals(1, map.segments[1].table.length()); assertEquals(1, map.segments[2].table.length()); assertEquals(1, map.segments[3].table.length()); }
@GwtIncompatible // CacheTesting public void testNullCache() { CountingRemovalListener<Object, Object> listener = countingRemovalListener(); LoadingCache<Object, Object> nullCache = CacheBuilder.newBuilder().maximumSize(0).removalListener(listener).build(identityLoader()); assertEquals(0, nullCache.size()); Object key = new Object(); assertSame(key, nullCache.getUnchecked(key)); assertEquals(1, listener.getCount()); assertEquals(0, nullCache.size()); CacheTesting.checkEmpty(nullCache.asMap()); }
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 testNullParameters() throws Exception { NullPointerTester tester = new NullPointerTester(); CacheLoader<Object, Object> loader = identityLoader(); tester.testAllPublicInstanceMethods(makeCache(createCacheBuilder(), loader)); }
public void testEviction_overflow() { CountingRemovalListener<Object, Object> removalListener = countingRemovalListener(); IdentityLoader<Object> loader = identityLoader(); LoadingCache<Object, Object> cache = CacheBuilder.newBuilder() .concurrencyLevel(1) .maximumWeight(1L << 31) .weigher(constantWeigher(Integer.MAX_VALUE)) .removalListener(removalListener) .build(loader); cache.getUnchecked(objectWithHash(0)); cache.getUnchecked(objectWithHash(0)); CacheTesting.processPendingNotifications(cache); assertEquals(1, removalListener.getCount()); }
public void testNullParameters() throws Exception { NullPointerTester tester = new NullPointerTester(); tester.testAllPublicInstanceMethods(makeLocalCache(createCacheBuilder())); CacheLoader<Object, Object> loader = identityLoader(); tester.testAllPublicInstanceMethods(makeLocalCache(createCacheBuilder())); }