misc cleanup

caffeine/src/jmh/java/com/github/benmanes/caffeine/cache/CacheType.java

@@ -57,14 +57,14 @@ public enum CacheType {
   },
   ConcurrentHashMap {
     @Override public <K, V> BasicCache<K, V> create(int maximumSize) {
-      return new ConcurrentMapCache<>(new ConcurrentHashMap<K, V>(maximumSize));
+      return new ConcurrentMapCache<>(new ConcurrentHashMap<>(maximumSize));
     }
   },
   NonBlockingHashMap {
     @Override public <K, V> BasicCache<K, V> create(int maximumSize) {
       // Note that writes that update an entry to the same reference are short circuited
       // and do not mutate the hash table. This makes those writes equal to a read.
-      return new ConcurrentMapCache<>(new NonBlockingHashMap<K, V>(maximumSize));
+      return new ConcurrentMapCache<>(new NonBlockingHashMap<>(maximumSize));
     }
   },
 
@@ -134,7 +134,7 @@ public enum CacheType {
   },
   LinkedHashMap_Lru {
     @Override public <K, V> BasicCache<K, V> create(int maximumSize) {
-      return new LinkedHashMapCache<K, V>(true, maximumSize);
+      return new LinkedHashMapCache<>(true, maximumSize);
     }
   },
   TCache_Lfu {

caffeine/src/main/java/com/github/benmanes/caffeine/cache/BoundedLocalCache.java

@@ -2651,7 +2651,7 @@ public BoundedLocalCache<K, V> cache() {
     @Override
     public Policy<K, V> policy() {
       return (policy == null)
-          ? (policy = new BoundedPolicy<K, V>(cache, Function.identity(), isWeighted))
+          ? (policy = new BoundedPolicy<>(cache, Function.identity(), isWeighted))
           : policy;
     }
 
@@ -2935,7 +2935,7 @@ protected Policy<K, V> policy() {
         Function<CompletableFuture<V>, V> transformer = Async::getIfReady;
         @SuppressWarnings("unchecked")
         Function<V, V> castedTransformer = (Function<V, V>) transformer;
-        policy = new BoundedPolicy<K, V>(castedCache, castedTransformer, isWeighted);
+        policy = new BoundedPolicy<>(castedCache, castedTransformer, isWeighted);
       }
       return policy;
     }

caffeine/src/main/java/com/github/benmanes/caffeine/cache/LocalAsyncLoadingCache.java

@@ -487,7 +487,7 @@ public Policy<K, V> policy() {
     @Override
     public ConcurrentMap<K, V> asMap() {
       if (asMapView == null) {
-        asMapView = new AsMapView<K, V>(cache);
+        asMapView = new AsMapView<>(cache);
       }
       return asMapView;
     }

caffeine/src/main/java/com/github/benmanes/caffeine/cache/UnboundedLocalCache.java

@@ -65,7 +65,7 @@ final class UnboundedLocalCache<K, V> implements LocalCache<K, V> {
   StatsCounter statsCounter;
 
   UnboundedLocalCache(Caffeine<? super K, ? super V> builder, boolean async) {
-    this.data = new ConcurrentHashMap<K, V>(builder.getInitialCapacity());
+    this.data = new ConcurrentHashMap<>(builder.getInitialCapacity());
     this.statsCounter = builder.getStatsCounterSupplier().get();
     this.removalListener = builder.getRemovalListener(async);
     this.isRecordingStats = builder.isRecordingStats();

caffeine/src/main/java/com/github/benmanes/caffeine/cache/WriteThroughEntry.java

@@ -42,6 +42,6 @@ public V setValue(V value) {
   }
 
   Object writeReplace() {
-    return new SimpleEntry<K, V>(this);
+    return new SimpleEntry<>(this);
   }
 }

caffeine/src/main/java/com/github/benmanes/caffeine/cache/stats/GuardedStatsCounter.java

@@ -90,4 +90,9 @@ public CacheStats snapshot() {
       return DisabledStatsCounter.EMPTY_STATS;
     }
   }
+
+  @Override
+  public String toString() {
+    return delegate.toString();
+  }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/AsyncLoadingCacheTest.java

@@ -70,32 +70,6 @@
 @Test(dataProviderClass = CacheProvider.class)
 public final class AsyncLoadingCacheTest {
 
-  /* ---------------- CacheLoader -------------- */
-
-  @Test
-  public void asyncLoad() throws Exception {
-    CacheLoader<Integer, ?> loader = key -> key;
-    CompletableFuture<?> future = loader.asyncLoad(1, MoreExecutors.directExecutor());
-    assertThat(future.get(), is(1));
-  }
-
-  @Test(expectedExceptions = UnsupportedOperationException.class)
-  public void asyncLoadAll() throws Throwable {
-    CacheLoader<Object, ?> loader = key -> key;
-    try {
-      loader.asyncLoadAll(Collections.<Object>emptyList(), MoreExecutors.directExecutor()).get();
-    } catch (ExecutionException e) {
-      throw e.getCause();
-    }
-  }
-
-  @Test
-  public void asyncReload() throws Exception {
-    CacheLoader<Integer, Integer> loader = key -> -key;
-    CompletableFuture<?> future = loader.asyncReload(1, 2, MoreExecutors.directExecutor());
-    assertThat(future.get(), is(-1));
-  }
-
   /* ---------------- getIfPresent -------------- */
 
   @CheckNoWriter
@@ -715,4 +689,21 @@ public void put_replace(AsyncLoadingCache<Integer, Integer> cache, CacheContext
   public void serialize(AsyncLoadingCache<Integer, Integer> cache, CacheContext context) {
     assertThat(cache, is(reserializable()));
   }
+
+  /* ---------------- AsyncCacheLoader -------------- */
+
+  @Test(expectedExceptions = UnsupportedOperationException.class)
+  public void asyncLoadAll() throws Throwable {
+    AsyncCacheLoader<Integer, Integer> loader =
+        (key, executor) -> CompletableFuture.completedFuture(-key);
+    loader.asyncLoadAll(Collections.emptyList(), Runnable::run).get();
+  }
+
+  @Test
+  public void asyncReload() throws Exception {
+    AsyncCacheLoader<Integer, Integer> loader =
+        (key, executor) -> CompletableFuture.completedFuture(-key);
+    CompletableFuture<?> future = loader.asyncReload(1, 2, Runnable::run);
+    assertThat(future.get(), is(-1));
+  }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidAsyncCache.java

@@ -59,6 +59,6 @@ protected boolean matchesSafely(AsyncLoadingCache<K, V> cache, Description descr
   }
 
   public static <K, V> IsValidAsyncCache<K, V> validAsyncCache() {
-    return new IsValidAsyncCache<K, V>();
+    return new IsValidAsyncCache<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidBoundedLocalCache.java

@@ -213,6 +213,6 @@ private void checkNode(BoundedLocalCache<K, V> cache, Node<K, V> node, Descripti
   }
 
   public static <K, V> IsValidBoundedLocalCache<K, V> valid() {
-    return new IsValidBoundedLocalCache<K, V>();
+    return new IsValidBoundedLocalCache<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidCache.java

@@ -80,6 +80,6 @@ protected boolean matchesSafely(Cache<K, V> cache, Description description) {
   }
 
   public static <K, V> IsValidCache<K, V> validCache() {
-    return new IsValidCache<K, V>();
+    return new IsValidCache<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidLinkedDeque.java

@@ -90,6 +90,6 @@ void checkElement(LinkedDeque<E> deque, E element, DescriptionBuilder desc) {
   }
 
   public static <E> IsValidLinkedDeque<E> validLinkedDeque() {
-    return new IsValidLinkedDeque<E>();
+    return new IsValidLinkedDeque<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidMapView.java

@@ -62,6 +62,6 @@ protected boolean matchesSafely(Map<K, V> map, Description description) {
   }
 
   public static <K, V> IsValidMapView<K, V> validAsMap() {
-    return new IsValidMapView<K, V>();
+    return new IsValidMapView<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/IsValidUnboundedLocalCache.java

@@ -70,6 +70,6 @@ private void checkMap(UnboundedLocalCache<K, V> map, DescriptionBuilder desc) {
   }
 
   public static <K, V> IsValidUnboundedLocalCache<K, V> valid() {
-    return new IsValidUnboundedLocalCache<K, V>();
+    return new IsValidUnboundedLocalCache<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/LoadingCacheTest.java

@@ -25,11 +25,17 @@
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.sameInstance;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
 
+import org.junit.Assert;
 import org.testng.annotations.Listeners;
 import org.testng.annotations.Test;
 
@@ -339,4 +345,71 @@ public void reload() throws Exception {
     CacheLoader<Integer, Integer> loader = key -> key;
     assertThat(loader.reload(1, 1), is(1));
   }
+
+  @Test
+  public void asyncLoad_exception() throws Exception {
+    Exception e = new Exception();
+    CacheLoader<Integer, Integer> loader = key -> { throw e; };
+    try {
+      loader.asyncLoad(1, Runnable::run).join();
+    } catch (CompletionException ex) {
+      assertThat(ex.getCause(), is(sameInstance(e)));
+    }
+  }
+
+  @Test
+  public void asyncLoad() throws Exception {
+    CacheLoader<Integer, ?> loader = key -> key;
+    CompletableFuture<?> future = loader.asyncLoad(1, Runnable::run);
+    assertThat(future.get(), is(1));
+  }
+
+  @Test
+  public void asyncLoadAll_exception() throws Exception {
+    Exception e = new Exception();
+    CacheLoader<Integer, Integer> loader = new CacheLoader<Integer, Integer>() {
+      @Override public Integer load(Integer key) throws Exception {
+        throw new AssertionError();
+      }
+      @Override public Map<Integer, Integer> loadAll(
+          Iterable<? extends Integer> keys) throws Exception {
+        throw e;
+      }
+    };
+    try {
+      loader.asyncLoadAll(Arrays.asList(1), Runnable::run).join();
+    } catch (CompletionException ex) {
+      assertThat(ex.getCause(), is(sameInstance(e)));
+    }
+  }
+
+  @Test(expectedExceptions = UnsupportedOperationException.class)
+  public void asyncLoadAll() throws Throwable {
+    CacheLoader<Object, ?> loader = key -> key;
+    try {
+      loader.asyncLoadAll(Collections.emptyList(), Runnable::run).get();
+    } catch (ExecutionException e) {
+      throw e.getCause();
+    }
+  }
+
+  @Test
+  public void asyncReload_exception() throws Exception {
+    for (Exception e : Arrays.asList(new Exception(), new RuntimeException())) {
+      CacheLoader<Integer, Integer> loader = key -> { throw e; };
+      try {
+        loader.asyncReload(1, 1, Runnable::run).join();
+        Assert.fail();
+      } catch (CompletionException ex) {
+        assertThat(ex.getCause(), is(sameInstance(e)));
+      }
+    }
+  }
+
+  @Test
+  public void asyncReload() throws Exception {
+    CacheLoader<Integer, Integer> loader = key -> -key;
+    CompletableFuture<?> future = loader.asyncReload(1, 2, Runnable::run);
+    assertThat(future.get(), is(-1));
+  }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/stats/StatsCounterTest.java

@@ -79,6 +79,19 @@ public void concurrent() {
 
   @Test
   public void guarded() {
+    StatsCounter counter = StatsCounter.guardedStatsCounter(new ConcurrentStatsCounter());
+    counter.recordHits(1);
+    counter.recordMisses(1);
+    counter.recordEviction();
+    counter.recordLoadSuccess(1);
+    counter.recordLoadFailure(1);
+    assertThat(counter.snapshot(), is(new CacheStats(1, 1, 1, 1, 2, 1)));
+    assertThat(counter.toString(), is(new CacheStats(1, 1, 1, 1, 2, 1).toString()));
+    assertThat(counter.snapshot().toString(), is(new CacheStats(1, 1, 1, 1, 2, 1).toString()));
+  }
+
+  @Test
+  public void guarded_exception() {
     StatsCounter statsCounter = Mockito.mock(StatsCounter.class);
     when(statsCounter.snapshot()).thenThrow(new NullPointerException());
     doThrow(NullPointerException.class).when(statsCounter).recordEviction();

caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/HasRemovalNotifications.java

@@ -102,11 +102,11 @@ private void checkNotification(RemovalNotification<?, ?> notification) {
 
   public static <K, V> HasRemovalNotifications<K, V> hasRemovalNotifications(
       CacheContext context, long count, RemovalCause cause) {
-    return new HasRemovalNotifications<K, V>(context, (int) count, cause);
+    return new HasRemovalNotifications<>(context, (int) count, cause);
   }
 
   public static <K, V> HasRemovalNotifications<K, V> hasRemovalNotifications(
       CacheContext context, int count, RemovalCause cause) {
-    return new HasRemovalNotifications<K, V>(context, count, cause);
+    return new HasRemovalNotifications<>(context, count, cause);
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/cache/testing/RemovalListeners.java

@@ -34,12 +34,12 @@ private RemovalListeners() {}
 
   /** A removal listener that stores the notifications for inspection. */
   public static <K, V> RemovalListener<K, V> consuming() {
-    return new ConsumingRemovalListener<K, V>();
+    return new ConsumingRemovalListener<>();
   }
 
   /** A removal listener that throws an exception if a notification arrives. */
   public static <K, V> RemovalListener<K, V> rejecting() {
-    return new RejectingRemovalListener<K, V>();
+    return new RejectingRemovalListener<>();
   }
 
   public static final class RejectingRemovalListener<K, V>

caffeine/src/test/java/com/github/benmanes/caffeine/testing/IsEmptyIterable.java

@@ -115,6 +115,6 @@ private void checkNoSuchElementException(String label,
   }
 
   public static <E> IsEmptyIterable<E> deeplyEmpty() {
-    return new IsEmptyIterable<E>();
+    return new IsEmptyIterable<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/testing/IsEmptyMap.java

@@ -56,6 +56,6 @@ protected boolean matchesSafely(Map<? extends K, ? extends V> map, Description d
   }
 
   public static <K, V> IsEmptyMap<K, V> emptyMap() {
-    return new IsEmptyMap<K, V>();
+    return new IsEmptyMap<>();
   }
 }

caffeine/src/test/java/com/github/benmanes/caffeine/testing/IsFutureValue.java

@@ -47,10 +47,10 @@ protected boolean matchesSafely(Future<V> future, Description description) {
   }
 
   public static <V> IsFutureValue<V> future(Matcher<V> matcher) {
-    return new IsFutureValue<V>(matcher);
+    return new IsFutureValue<>(matcher);
   }
 
   public static <V> IsFutureValue<V> futureOf(V value) {
-    return new IsFutureValue<V>(Is.is(value));
+    return new IsFutureValue<>(Is.is(value));
   }
 }

gradle/dependencies.gradle

@@ -35,9 +35,9 @@ ext {
     javapoet: '1.5.1',
     jcache: '1.0.0',
     jsr305: '3.0.1',
-    stream: '2.9.0',
+    stream: '2.9.1',
     univocity_parsers: '2.0.0',
-    ycsb: '0.7.0-RC1',
+    ycsb: '0.7.0-RC2',
   ]
   test_versions = [
     awaitility: '1.7.0',
@@ -46,7 +46,7 @@ ext {
     jcache_tck: '1.0.1',
     jctools: '1.1',
     junit: '4.12',
-    mockito: '2.0.42-beta',
+    mockito: '2.0.43-beta',
     pax_exam: '4.8.0',
     testng: '6.9.10',
     truth: '0.24',

jcache/src/main/java/com/github/benmanes/caffeine/jcache/CacheProxy.java

@@ -972,19 +972,19 @@ private <T> CacheWriterException writeAllToCacheWriter(Map<? extends K, ? extend
     }
     List<Cache.Entry<? extends K, ? extends V>> entries = map.entrySet().stream()
         .map(entry -> new EntryProxy<>(entry.getKey(), entry.getValue()))
-        .collect(Collectors.<Cache.Entry<? extends K, ? extends V>>toList());
+        .collect(Collectors.toList());
     try {
       writer.writeAll(entries);
       return null;
     } catch (CacheWriterException e) {
-      for (Cache.Entry<? extends K, ? extends V> entry : entries) {
+      entries.forEach(entry -> {
         map.remove(entry.getKey());
-      }
+      });
       throw e;
     } catch (RuntimeException e) {
-      for (Cache.Entry<? extends K, ? extends V> entry : entries) {
+      entries.forEach(entry -> {
         map.remove(entry.getKey());
-      }
+      });
       return new CacheWriterException("Exception in CacheWriter", e);
     }
   }