@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAllPresent_ordered_present( LoadingCache<Integer, Integer> cache, CacheContext context) { List<Integer> keys = new ArrayList<>(context.original().keySet()); Collections.shuffle(keys); List<Integer> result = new ArrayList<>(cache.getAll(keys).keySet()); assertThat(result, is(equalTo(keys))); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAllPresent_ordered_absent( LoadingCache<Integer, Integer> cache, CacheContext context) { List<Integer> keys = new ArrayList<>(context.absentKeys()); Collections.shuffle(keys); List<Integer> result = new ArrayList<>(cache.getAll(keys).keySet()); assertThat(result, is(equalTo(keys))); }
@CheckNoWriter @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) @Test(dataProvider = "caches", expectedExceptions = NullPointerException.class) public void getAll_iterable_nullKey(LoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(Collections.singletonList(null)); }
@CacheSpec @Test(dataProvider = "caches", expectedExceptions = UnsupportedOperationException.class) public void getAll_immutable(LoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(context.absentKeys()).clear(); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = Loader.NULL) public void getAll_absent_null(LoadingCache<Integer, Integer> cache, CacheContext context) { assertThat(cache.getAll(context.absentKeys()), is(ImmutableMap.of())); }
@CheckNoWriter @CacheSpec(removalListener = { Listener.DEFAULT, Listener.REJECTING }) @Test(dataProvider = "caches", expectedExceptions = NullPointerException.class) public void getAll_iterable_null(LoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(null); }
@Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, population = Population.EMPTY, keys = ReferenceType.STRONG, writer = Writer.DISABLED) public void getAll_jdk8186171(CacheContext context) { class Key { @Override public int hashCode() { return 0; // to put keys in one bucket } } LoadingCache<Object, Integer> cache = context.build(key -> null); List<Key> keys = new ArrayList<>(); for (int i = 0; i < Population.FULL.size(); i++) { keys.add(new Key()); } Key key = Iterables.getLast(keys); Integer value = context.absentValue(); cache.put(key, value); Map<Object, Integer> result = cache.getAll(keys); assertThat(result.values(), not(hasItem(nullValue()))); assertThat(result, is(equalTo(ImmutableMap.of(key, value)))); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_iterable_empty(LoadingCache<Integer, Integer> cache, CacheContext context) { Map<Integer, Integer> result = cache.getAll(ImmutableList.of()); assertThat(result.size(), is(0)); assertThat(context, both(hasMissCount(0)).and(hasHitCount(0))); }
@CheckNoWriter @CacheSpec(loader = Loader.BULK_NULL) @Test(dataProvider = "caches", expectedExceptions = Exception.class) public void getAll_absent_bulkNull(LoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(context.absentKeys()); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_present_full(LoadingCache<Integer, Integer> cache, CacheContext context) { Map<Integer, Integer> result = cache.getAll(context.original().keySet()); assertThat(result, is(equalTo(context.original()))); assertThat(context, both(hasMissCount(0)).and(hasHitCount(result.size()))); assertThat(context, both(hasLoadSuccessCount(0)).and(hasLoadFailureCount(0))); }
@Test(dataProvider = "caches", expectedExceptions = DeleteException.class) @CacheSpec(keys = ReferenceType.STRONG, values = {ReferenceType.WEAK, ReferenceType.SOFT}, implementation = Implementation.Caffeine, expireAfterAccess = Expire.DISABLED, expireAfterWrite = Expire.DISABLED, maximumSize = Maximum.DISABLED, weigher = CacheWeigher.DEFAULT, population = Population.FULL, stats = Stats.ENABLED, removalListener = Listener.CONSUMING, writer = Writer.EXCEPTIONAL, compute = Compute.SYNC, loader = {Loader.IDENTITY, Loader.BULK_IDENTITY}) public void getAll_writerFails(LoadingCache<Integer, Integer> cache, CacheContext context) { Set<Integer> keys = context.firstMiddleLastKeys(); try { context.clear(); GcFinalization.awaitFullGc(); cache.getAll(keys); } finally { context.disableRejectingCacheWriter(); assertThat(cache.asMap().isEmpty(), is(false)); } }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_present_partial(LoadingCache<Integer, Integer> cache, CacheContext context) { Map<Integer, Integer> expect = new HashMap<>(); expect.put(context.firstKey(), -context.firstKey()); expect.put(context.middleKey(), -context.middleKey()); expect.put(context.lastKey(), -context.lastKey()); Map<Integer, Integer> result = cache.getAll(expect.keySet()); assertThat(result, is(equalTo(expect))); assertThat(context, both(hasMissCount(0)).and(hasHitCount(expect.size()))); assertThat(context, both(hasLoadSuccessCount(0)).and(hasLoadFailureCount(0))); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(refreshAfterWrite = Expire.ONE_MINUTE, loader = Loader.IDENTITY, population = { Population.PARTIAL, Population.FULL }) public void getAll(LoadingCache<Integer, Integer> cache, CacheContext context) { List<Integer> keys = ImmutableList.of(context.firstKey(), context.absentKey()); context.ticker().advance(30, TimeUnit.SECONDS); assertThat(cache.getAll(keys), is(ImmutableMap.of(context.firstKey(), -context.firstKey(), context.absentKey(), context.absentKey()))); // Trigger a refresh, may return old values context.ticker().advance(45, TimeUnit.SECONDS); cache.getAll(keys); // Ensure new values are present assertThat(cache.getAll(keys), is(ImmutableMap.of(context.firstKey(), context.firstKey(), context.absentKey(), context.absentKey()))); assertThat(cache, hasRemovalNotifications(context, 1, RemovalCause.REPLACED)); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_duplicates(LoadingCache<Integer, Integer> cache, CacheContext context) { Set<Integer> absentKeys = ImmutableSet.copyOf(Iterables.limit(context.absentKeys(), Ints.saturatedCast(context.maximum().max() - context.initialSize()))); Iterable<Integer> keys = Iterables.concat(absentKeys, absentKeys, context.original().keySet(), context.original().keySet()); Map<Integer, Integer> result = cache.getAll(keys); assertThat(context, hasMissCount(absentKeys.size())); assertThat(context, hasHitCount(context.initialSize())); assertThat(result.keySet(), is(equalTo(ImmutableSet.copyOf(keys)))); int loads = context.loader().isBulk() ? 1 : absentKeys.size(); assertThat(context, both(hasLoadSuccessCount(loads)).and(hasLoadFailureCount(0))); }
@Test(dataProvider = "caches") @CacheSpec(requiresWeakOrSoft = true, expireAfterAccess = Expire.DISABLED, expireAfterWrite = Expire.DISABLED, maximumSize = Maximum.DISABLED, weigher = CacheWeigher.DEFAULT, population = Population.FULL, stats = Stats.ENABLED, loader = {Loader.NEGATIVE, Loader.BULK_NEGATIVE}, removalListener = Listener.CONSUMING) public void getAll(LoadingCache<Integer, Integer> cache, CacheContext context) { Set<Integer> keys = context.firstMiddleLastKeys(); context.clear(); GcFinalization.awaitFullGc(); awaitFullCleanup(cache); assertThat(cache.getAll(keys), is(Maps.toMap(keys, key -> -key))); long count = context.initialSize() - (context.isStrongValues() ? keys.size() : 0); assertThat(cache.estimatedSize(), is((long) keys.size())); assertThat(cache, hasRemovalNotifications(context, count, RemovalCause.COLLECTED)); verifyWriter(context, (verifier, writer) -> verifier.deletions(count, RemovalCause.COLLECTED)); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_absent(LoadingCache<Integer, Integer> cache, CacheContext context) { Map<Integer, Integer> result = cache.getAll(context.absentKeys()); int count = context.absentKeys().size(); int loads = context.loader().isBulk() ? 1 : count; assertThat(result.size(), is(count)); assertThat(context, both(hasMissCount(count)).and(hasHitCount(0))); assertThat(context, both(hasLoadSuccessCount(loads)).and(hasLoadFailureCount(0))); }
@Test(dataProvider = "caches") @CacheSpec(population = { Population.PARTIAL, Population.FULL }, mustExpireWithAnyOf = { AFTER_WRITE, VARIABLE }, expireAfterWrite = Expire.ONE_MINUTE, expiry = { CacheExpiry.DISABLED, CacheExpiry.WRITE }, expiryTime = Expire.ONE_MINUTE, loader = {Loader.IDENTITY, Loader.BULK_IDENTITY}) public void getAll(LoadingCache<Integer, Integer> cache, CacheContext context) { context.ticker().advance(30, TimeUnit.SECONDS); assertThat(cache.getAll(ImmutableList.of(context.firstKey(), context.absentKey())), is(ImmutableMap.of(context.firstKey(), -context.firstKey(), context.absentKey(), context.absentKey()))); context.ticker().advance(45, TimeUnit.SECONDS); cache.cleanUp(); assertThat(cache.getAll(ImmutableList.of(context.firstKey(), context.absentKey())), is(ImmutableMap.of(context.firstKey(), context.firstKey(), context.absentKey(), context.absentKey()))); assertThat(cache.estimatedSize(), is(2L)); long count = context.initialSize(); assertThat(cache, hasRemovalNotifications(context, count, RemovalCause.EXPIRED)); verifyWriter(context, (verifier, writer) -> verifier.deletions(count, RemovalCause.EXPIRED)); }
@Test(dataProvider = "caches", expectedExceptions = DeleteException.class) @CacheSpec(implementation = Implementation.Caffeine, keys = ReferenceType.STRONG, population = Population.FULL, expiryTime = Expire.ONE_MINUTE, mustExpireWithAnyOf = { AFTER_ACCESS, AFTER_WRITE, VARIABLE }, expiry = { CacheExpiry.DISABLED, CacheExpiry.CREATE, CacheExpiry.WRITE, CacheExpiry.ACCESS }, expireAfterAccess = {Expire.DISABLED, Expire.ONE_MINUTE}, expireAfterWrite = {Expire.DISABLED, Expire.ONE_MINUTE}, compute = Compute.SYNC, writer = Writer.EXCEPTIONAL, removalListener = Listener.REJECTING) public void getAll_writerFails(LoadingCache<Integer, Integer> cache, CacheContext context) { try { context.ticker().advance(1, TimeUnit.HOURS); cache.getAll(context.firstMiddleLastKeys()); } finally { context.disableRejectingCacheWriter(); context.ticker().advance(-1, TimeUnit.HOURS); assertThat(cache.asMap(), equalTo(context.original())); } }
@CheckNoWriter @CacheSpec(loader = { Loader.EXCEPTIONAL, Loader.BULK_EXCEPTIONAL }) @Test(dataProvider = "caches", expectedExceptions = IllegalStateException.class) public void getAll_absent_failure_iterable( LoadingCache<Integer, Integer> cache, CacheContext context) { try { cache.getAll(() -> context.absentKeys().iterator()); } finally { int misses = context.absentKeys().size(); int loadFailures = context.loader().isBulk() ? 1 : (context.isAsync() ? misses : 1); assertThat(context, both(hasMissCount(misses)).and(hasHitCount(0))); assertThat(context, both(hasLoadSuccessCount(0)).and(hasLoadFailureCount(loadFailures))); } }
@CheckNoWriter @CacheSpec(loader = { Loader.EXCEPTIONAL, Loader.BULK_EXCEPTIONAL }) @Test(dataProvider = "caches", expectedExceptions = IllegalStateException.class) public void getAll_absent_failure(LoadingCache<Integer, Integer> cache, CacheContext context) { try { cache.getAll(context.absentKeys()); } finally { int misses = context.absentKeys().size(); int loadFailures = context.loader().isBulk() ? 1 : (context.isAsync() ? misses : 1); assertThat(context, both(hasMissCount(misses)).and(hasHitCount(0))); assertThat(context, both(hasLoadSuccessCount(0)).and(hasLoadFailureCount(loadFailures))); } }