package com.atlassian.vcache.internal.test;
   
   import com.atlassian.utt.concurrency.Barrier;
   import com.atlassian.utt.concurrency.TestThread;
   import com.atlassian.vcache.JvmCache;
   import com.atlassian.vcache.JvmCacheSettings;
   import com.atlassian.vcache.JvmCacheSettingsBuilder;
   import com.atlassian.vcache.LocalCacheOperations;
   import com.atlassian.vcache.VCache;
  import org.junit.Test;
  
  import java.time.Duration;
  import java.util.Arrays;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.TimeUnit;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.function.Consumer;
  import java.util.function.Supplier;
  import java.util.stream.Collectors;
  
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.isOneOf;
  import static org.junit.Assert.assertThat;
  
  /**
   * Base test class for the {@link JvmCache}.
   */
  public abstract class AbstractJvmCacheTest extends AbstractLocalCacheOperationsTest {
  
      protected abstract <K, V> JvmCache<K, V> createCache(String name, JvmCacheSettings settings);
  
      @Override
      protected final <K, V> JvmCache<K, V> createCache(String name) {
          final JvmCacheSettings settings = new JvmCacheSettingsBuilder().maxEntries(3).defaultTtl(Duration.ofSeconds(10)).build();
          return createCache(name, settings);
      }
  
      @Test
      public void testGetName() throws Exception {
          final VCache namedCache = createCache("jvmcache");
          assertThat(namedCache.getName(), is("jvmcache"));
      }
  
      @SuppressWarnings("unchecked")
      @Test
      public void testKeys() {
          final JvmCache<String, String> mycache = createCache("ignored");
  
          assertThat(mycache.getKeys(), containsInAnyOrder());
  
          mycache.put("k1", "v1");
  
          assertThat(mycache.getKeys(), containsInAnyOrder("k1"));
  
          mycache.put("k2", "v2");
  
          assertThat(mycache.getKeys(), containsInAnyOrder("k1", "k2"));
      }
  
      @Test
      public void testSize() {
          final JvmCache<String, String> mycache = createCache("ignored");
  
          assertThat(mycache.getKeys().size(), is(0));
  
          mycache.put("k1", "v1");
  
          assertThat(mycache.getKeys().size(), is(1));
  
          mycache.put("k2", "v2");
  
          assertThat(mycache.getKeys().size(), is(2));
  
          mycache.put("k3", "v3");
  
          assertThat(mycache.getKeys().size(), is(3));
  
          mycache.put("k4", "v4");
  
          assertThat(mycache.getKeys().size(), is(3));
  
          Arrays.asList("k1", "k2", "k3", "k4").forEach(mycache::remove);
  
          assertThat(mycache.getKeys().size(), is(0));
      }
  
      @Test
      public void testRemoveConcurrentWithSupplier() {
          removeConcurrentWithSupplier(c -> c.remove(0));
      }
  
      @Test
      public void testRemoveAllConcurrentWithSupplier() {
          removeConcurrentWithSupplier(LocalCacheOperations::removeAll);
      }
  
      private void removeConcurrentWithSupplier(Consumer<JvmCache<Integer, Integer>> removeFn) {
          final Barrier doUpdate = new Barrier();
         final CountDownLatch removeCalled = new CountDownLatch(1);
         final Barrier afterGet = new Barrier();
         final AtomicInteger dbValue = new AtomicInteger(1);
 
         final Supplier<Integer> loader = () -> {
             final int value = dbValue.get();
             doUpdate.trySignal();
             try {
                 // Whether or not remove gets blocked by the load operation is implementation-dependent.
                 removeCalled.await(250L, TimeUnit.MILLISECONDS);
             } catch (InterruptedException ie) {
                 throw new AssertionError(ie);
             }
             afterGet.trySignal();
             return value;
         };
 
         final JvmCache<Integer, Integer> mycache = createCache("ignored");
 
         final TestThread blockingGet = new TestThread("blockingGet") {
             @Override
             protected void go() throws Exception {
                 assertThat(mycache.get(0, loader), isOneOf(1, 2));  // Either the stale or updated value is acceptable
                 removeCalled.await();
                 assertThat(mycache.get(0, loader), is(2));
             }
         };
 
         final TestThread modifyRemoveGet = new TestThread("modifyRemoveGet") {
             @Override
             protected void go() throws Exception {
                 doUpdate.await();
                 dbValue.set(2);
                 removeFn.accept(mycache);
                 removeCalled.countDown();
                 assertThat(mycache.get(0, loader), is(2));
             }
         };
 
         TestThread.runTest(blockingGet, modifyRemoveGet);
     }
 
     @Test
     public void detect_illegal_recursion_factory() {
         thrown.expect(IllegalStateException.class);
         thrown.expectMessage("Recursive call with key: first");
 
         final JvmCache<String, String> cache = createCache("abc");
 
         cache.getBulk(
                 strings1 -> {
                     return cache.getBulk(strings2 -> {
                         return strings2.stream().collect(Collectors.toMap(k -> k, k -> k + "-2"));
                     }, strings1);
                 },
                 "first");
     }
 }