package com.atlassian.vcache.internal.test;
   
   import com.atlassian.utt.concurrency.Barrier;
   import com.atlassian.vcache.JvmCache;
   import com.atlassian.vcache.JvmCacheSettings;
   import com.atlassian.vcache.JvmCacheSettingsBuilder;
   import com.atlassian.vcache.VCache;
   import org.junit.Test;
   
  import java.time.Duration;
  import java.util.Arrays;
  import java.util.concurrent.CompletableFuture;
  
  import static com.atlassian.vcache.internal.test.CompletionStageSuccessful.successfulWith;
  import static com.atlassian.vcache.internal.test.TestUtils.runAndWaitForStart;
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.hamcrest.Matchers.is;
  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, Duration lockTimeout);
  
      @Override
      protected final <K, V> JvmCache<K, V> createCache(String name, Duration lockTimeout) {
          return createCache(name, new JvmCacheSettingsBuilder().build(), lockTimeout);
      }
  
      @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, Duration.ofSeconds(10));
      }
  
      @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 get_remove_concurrently() {
          // T1: get with supplier and await signal
          // T2: remove()
          // T1: signalled, supplier returns "T1"
          // Confirm T1 return "T1"
  
          final Barrier blockedInSupplier = new Barrier();
          final Barrier resumeInSupplier = new Barrier();
          final JvmCache<String, String> cache = createCache("getremove");
  
  
          final CompletableFuture<String> t1Result =
                  runAndWaitForStart(() -> cache.get("alive", () -> {
                     blockedInSupplier.signal();
                     resumeInSupplier.await();
                     return "T1";
                 }));
 
         blockedInSupplier.await();
         final CompletableFuture<String> t2Result =
                 runAndWaitForStart(() -> {
                     cache.remove("alive");
                     return "" + cache.get("alive").isPresent();
                 });
 
         // Wait for the result from T2 to ensure it has run to completion.
         assertThat(t2Result, successfulWith(is("false")));
 
         resumeInSupplier.signal(); // Wait until T2 cache.get calls join
 
         assertThat(t1Result, successfulWith(is("T1")));
     }
 }