add another jcstress test

Author: andimarek

build.gradle

@@ -263,5 +263,5 @@ tasks.named("dependencyUpdates").configure {
 }
 
 jcstress {
-    verbose = true
+//    verbose = true
 }

src/jcstress/java/org/dataloader/DataLoaderBatchingAndCachingDispatchJCStress.java renamed to src/jcstress/java/org/dataloader/DataLoader_Batching_Caching_JCStress.java

@@ -16,7 +16,7 @@
 @JCStressTest
 @State
 @Outcome(id = "2000, 2000", expect = ACCEPTABLE, desc = "accepted")
-public class DataLoaderBatchingAndCachingDispatchJCStress {
+public class DataLoader_Batching_Caching_JCStress {
 
 
     AtomicInteger counter = new AtomicInteger();
@@ -33,7 +33,7 @@ public class DataLoaderBatchingAndCachingDispatchJCStress {
     };
     DataLoader<String, String> dataLoader = DataLoaderFactory.newDataLoader(batchLoader);
 
-    public DataLoaderBatchingAndCachingDispatchJCStress() {
+    public DataLoader_Batching_Caching_JCStress() {
 
     }
 

src/jcstress/java/org/dataloader/DataLoader_NoBatching_Caching_JCStress.java

@@ -0,0 +1,66 @@
+package org.dataloader;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.II_Result;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
+import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE_INTERESTING;
+
+@JCStressTest
+@State
+@Outcome(id = "2000, 2000", expect = ACCEPTABLE, desc = "No keys loaded twice")
+@Outcome(id = "2.*, 2000", expect = ACCEPTABLE_INTERESTING, desc = "Some keys loaded twice")
+public class DataLoader_NoBatching_Caching_JCStress {
+
+
+    AtomicInteger batchLoaderCount = new AtomicInteger();
+    volatile boolean finished1;
+    volatile boolean finished2;
+
+
+    BatchLoader<String, String> batchLoader = keys -> {
+        batchLoaderCount.getAndAdd(keys.size());
+        return CompletableFuture.completedFuture(keys);
+    };
+    DataLoader<String, String> dataLoader = DataLoaderFactory.newDataLoader(batchLoader, DataLoaderOptions.newOptions().setBatchingEnabled(false).build());
+
+
+    @Actor
+    public void load1() {
+        for (int i = 0; i < 1000; i++) {
+            dataLoader.load("load-1-" + i);
+        }
+        // we load the same keys again
+        for (int i = 0; i < 1000; i++) {
+            dataLoader.load("load-1-" + i);
+        }
+        finished1 = true;
+    }
+
+    @Actor
+    public void load2() {
+        for (int i = 0; i < 1000; i++) {
+            dataLoader.load("load-2-" + i);
+        }
+        // we load the same keys again
+        for (int i = 0; i < 1000; i++) {
+            dataLoader.load("load-1-" + i);
+        }
+        finished2 = true;
+    }
+
+
+    @Arbiter
+    public void arbiter(II_Result r) {
+        r.r1 = batchLoaderCount.get();
+        r.r2 = dataLoader.getCacheMap().size();
+    }
+
+}

src/main/java/org/dataloader/CacheMap.java

@@ -74,10 +74,11 @@ static <K, V> CacheMap<K, V> simpleMap() {
      *
      * @return the cached value, or {@code null} if not found (depends on cache implementation)
      */
-    @Nullable  CompletableFuture<V> get(K key);
+    @Nullable CompletableFuture<V> get(K key);
 
     /**
      * Gets a collection of CompletableFutures from the cache map.
+     *
      * @return the collection of cached values
      */
     Collection<CompletableFuture<V>> getAll();
@@ -107,4 +108,13 @@ static <K, V> CacheMap<K, V> simpleMap() {
      * @return the cache map for fluent coding
      */
     CacheMap<K, V> clear();
+
+    /**
+     * Returns the current size of the cache. This is not used by DataLoader directly
+     * and intended for testing and debugging.
+     * If a cache doesn't support it, it can throw an Exception.
+     *
+     * @return
+     */
+    int size();
 }

src/main/java/org/dataloader/impl/DefaultCacheMap.java

@@ -93,4 +93,9 @@ public CacheMap<K, V> clear() {
         cache.clear();
         return this;
     }
+
+    @Override
+    public int size() {
+        return cache.size();
+    }
 }

src/test/java/ReadmeExamples.java

@@ -278,6 +278,11 @@ public CacheMap delete(Object key) {
         public CacheMap clear() {
             return null;
         }
+
+        @Override
+        public int size() {
+            return 0;
+        }
     }
 
     private void customCache() {

src/test/java/org/dataloader/fixtures/CustomCacheMap.java

@@ -45,4 +45,9 @@ public CacheMap<String, Object> clear() {
         stash.clear();
         return this;
     }
+
+    @Override
+    public int size() {
+        return stash.size();
+    }
 }