@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( AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { List<Integer> keys = new ArrayList<>(context.absentKeys()); Collections.shuffle(keys); List<Integer> result = new ArrayList<>(cache.getAll(keys).join().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_present( AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { List<Integer> keys = new ArrayList<>(context.original().keySet()); Collections.shuffle(keys); List<Integer> result = new ArrayList<>(cache.getAll(keys).join().keySet()); assertThat(result, is(equalTo(keys))); }
@CheckNoWriter @CheckNoStats @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_iterable_empty(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { CompletableFuture<Map<Integer, Integer>> result = cache.getAll(ImmutableList.of()); assertThat(result.get().size(), is(0)); }
@CacheSpec @CheckNoWriter @Test(dataProvider = "caches", expectedExceptions = UnsupportedOperationException.class) public void getAll_immutable(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { cache.getAll(context.absentKeys()).get().clear(); }
@CheckNoWriter @CheckNoStats @Test(dataProvider = "caches", expectedExceptions = NullPointerException.class) @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_iterable_nullKey(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(Collections.singletonList(null)); }
@CheckNoWriter @CheckNoStats @Test(dataProvider = "caches", expectedExceptions = NullPointerException.class) @CacheSpec(removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_iterable_null(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { cache.getAll(null); }
@Test(dataProvider = "caches") @CacheSpec(population = Population.SINGLETON, removalListener = Listener.CONSUMING, 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}, expiryTime = Expire.ONE_MINUTE, loader = {Loader.BULK_IDENTITY}) @SuppressWarnings("FutureReturnValueIgnored") public void getAll(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { Set<Integer> keys = context.firstMiddleLastKeys(); context.ticker().advance(1, TimeUnit.MINUTES); cache.getAll(context.firstMiddleLastKeys()); assertThat(cache.getAll(keys).join(), is(Maps.uniqueIndex(keys, Functions.identity()))); long count = context.initialSize(); assertThat(cache, hasRemovalNotifications(context, count, RemovalCause.EXPIRED)); }
@Test(dataProvider = "caches") @CacheSpec(keys = ReferenceType.WEAK, values = ReferenceType.STRONG, 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(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { Set<Integer> keys = ImmutableSet.of(context.firstKey(), context.lastKey(), context.absentKey()); context.clear(); GcFinalization.awaitFullGc(); assertThat(cache.getAll(keys).join(), is(keys.stream().collect(toMap(Function.identity(), key -> -key)))); long count = context.initialSize() - cache.synchronous().estimatedSize() + 1; assertThat(count, is(greaterThan((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.BULK_NEGATIVE_EXCEEDS }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_exceeds(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) { Map<Integer, Integer> result = cache.getAll(context.absentKeys()).join(); assertThat(result.keySet(), equalTo(context.absentKeys())); assertThat(cache.synchronous().estimatedSize(), is(greaterThan(context.initialSize() + context.absentKeys().size()))); assertThat(context, both(hasMissCount(result.size())).and(hasHitCount(0))); assertThat(context, both(hasLoadSuccessCount(1)).and(hasLoadFailureCount(0))); }
@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(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { 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()).get(); 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(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, population = { Population.SINGLETON, Population.PARTIAL, Population.FULL }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_duplicates(AsyncLoadingCache<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).join(); 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))); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(implementation = Implementation.Caffeine, compute = Compute.ASYNC, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_badLoader(CacheContext context) { @SuppressWarnings("serial") final class LoadAllException extends RuntimeException {}; AsyncCacheLoader<Integer, Integer> loader = new AsyncCacheLoader<Integer, Integer>() { @Override public CompletableFuture<Integer> asyncLoad(Integer key, Executor executor) { throw new IllegalStateException(); } @Override public CompletableFuture<Map<Integer, Integer>> asyncLoadAll( Iterable<? extends Integer> keys, Executor executor) { throw new LoadAllException(); } }; AsyncLoadingCache<Integer, Integer> cache = context.buildAsync(loader); try { cache.getAll(context.absentKeys()); Assert.fail(); } catch (LoadAllException e) { assertThat(cache.synchronous().estimatedSize(), is(0L)); } }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(loader = { Loader.NEGATIVE, Loader.BULK_NEGATIVE }, removalListener = { Listener.DEFAULT, Listener.REJECTING }) public void getAll_absent(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { Map<Integer, Integer> result = cache.getAll(context.absentKeys()).get(); 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))); }
@CheckNoWriter @Test(dataProvider = "caches") @CacheSpec(refreshAfterWrite = Expire.ONE_MINUTE, loader = Loader.IDENTITY, population = { Population.PARTIAL, Population.FULL }) @SuppressWarnings("FutureReturnValueIgnored") public void getAll(AsyncLoadingCache<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(futureOf(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(futureOf(ImmutableMap.of(context.firstKey(), context.firstKey(), context.absentKey(), context.absentKey())))); assertThat(cache, hasRemovalNotifications(context, 1, RemovalCause.REPLACED)); }
@CheckNoWriter @CacheSpec(loader = Loader.BULK_NULL) @Test(dataProvider = "caches", expectedExceptions = ExecutionException.class) public void getAll_absent_bulkNull(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { try { cache.getAll(context.absentKeys()).get(); } 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 = ExecutionException.class) public void getAll_absent_failure(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) throws Exception { try { cache.getAll(context.absentKeys()).get(); } 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))); } }