package com.atlassian.vcache.internal.test;
   
   import com.atlassian.vcache.LocalCacheOperations;
   import org.junit.Before;
   import org.junit.Rule;
   import org.junit.Test;
   import org.junit.rules.ExpectedException;
   
   import java.util.Map;
  import java.util.Optional;
  import java.util.stream.Collectors;
  
  import static org.hamcrest.Matchers.containsInAnyOrder;
  import static org.hamcrest.Matchers.empty;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.notNullValue;
  import static org.junit.Assert.assertThat;
  
  /**
   * Base test class for the {@link LocalCacheOperations}.
   */
  public abstract class AbstractLocalCacheOperationsTest {
      @Rule
      public ExpectedException thrown = ExpectedException.none();
  
      private LocalCacheOperations<String, String> cache;
  
      protected abstract <K, V> LocalCacheOperations<K, V> createCache(String name);
  
      @Before
      public void init() {
          cache = createCache("some.smart.name");
      }
  
      @Test
      public void testGet() throws Exception {
          final Optional<String> result1 = cache.get("Parlez-Vouis Francais");
  
          assertThat(result1, notNullValue());
          assertThat(result1, is(Optional.empty()));
  
          final String supplied = cache.get("Parlez-Vouis Francais", () -> "Magic Fountain");
  
          assertThat(supplied, is("Magic Fountain"));
  
          final Optional<String> result2 = cache.get("Parlez-Vouis Francais");
  
          assertThat(result2, notNullValue());
          assertThat(result2, is(Optional.of("Magic Fountain")));
      }
  
      @Test
      public void testPut() throws Exception {
          final Optional<String> get1 = cache.get("aqua");
  
          assertThat(get1, notNullValue());
          assertThat(get1, is(Optional.empty()));
  
          cache.put("aqua", "water");
          final Optional<String> put1 = cache.get("aqua");
  
          assertThat(put1, notNullValue());
          assertThat(put1, is(Optional.of("water")));
      }
  
      @Test
      public void testPutIfAbsent() throws Exception {
          final Optional<String> get1 = cache.get("aqua");
  
          assertThat(get1, notNullValue());
          assertThat(get1, is(Optional.empty()));
  
          final Optional<String> put1 = cache.putIfAbsent("aqua", "water");
  
          assertThat(put1, notNullValue());
          assertThat(put1, is(Optional.empty()));
  
          final Optional<String> put2 = cache.putIfAbsent("aqua", "water2");
  
          assertThat(put2, notNullValue());
          assertThat(put2, is(Optional.of("water")));
  
          final Optional<String> get2 = cache.get("aqua");
  
          assertThat(get2, notNullValue());
          assertThat(get2, is(Optional.of("water")));
      }
  
      @Test
      public void testReplaceIfOkay() throws Exception {
          cache.put("aqua", "water");
          final boolean replaced = cache.replaceIf("aqua", "water", "water2");
  
          assertThat(replaced, is(true));
          assertThat(cache.get("aqua"), is(Optional.of("water2")));
      }
  
      @Test
      public void testReplaceIfMismatch() throws Exception {
         cache.put("aqua", "water");
         final boolean replaced = cache.replaceIf("aqua", "tea", "water2");
 
         assertThat(replaced, is(false));
         assertThat(cache.get("aqua"), is(Optional.of("water")));
     }
 
     @Test
     public void testReplaceIfMissing() throws Exception {
         final boolean replaced = cache.replaceIf("aqua", "water", "water2");
 
         assertThat(replaced, is(false));
         assertThat(cache.get("aqua"), is(Optional.empty()));
     }
 
     @Test
     public void testRemoveIfOkay() throws Exception {
         cache.put("aqua", "water");
 
         final boolean removed = cache.removeIf("aqua", "water");
 
         assertThat(removed, is(true));
         assertThat(cache.get("aqua"), is(Optional.empty()));
     }
 
     @Test
     public void testRemoveIfMismatch() throws Exception {
         cache.put("aqua", "water");
 
         final boolean removed = cache.removeIf("aqua", "tea");
 
         assertThat(removed, is(false));
         assertThat(cache.get("aqua"), is(Optional.of("water")));
     }
 
     @Test
     public void testRemoveIfMissing() throws Exception {
         final boolean removed = cache.removeIf("aqua", "water");
 
         assertThat(removed, is(false));
         assertThat(cache.get("aqua"), is(Optional.empty()));
     }
 
 
     @Test
     public void testRemoveOkay() throws Exception {
         cache.put("aqua", "water");
 
         cache.remove("aqua");
 
         assertThat(cache.get("aqua"), is(Optional.empty()));
     }
 
     @Test
     public void testRemoveMissing() throws Exception {
         cache.remove("aqua");
 
         assertThat(cache.get("aqua"), is(Optional.empty()));
     }
 
     @Test
     public void testRemoveAll() throws Exception {
         cache.put("k1", "v1");
         cache.put("k2", "v2");
 
         assertThat(cache.get("k1"), is(Optional.of("v1")));
         assertThat(cache.get("k2"), is(Optional.of("v2")));
 
         cache.removeAll();
 
         assertThat(cache.get("k1"), is(Optional.empty()));
         assertThat(cache.get("k2"), is(Optional.empty()));
     }
 
     @Test
     public void testInvalidName() {
         thrown.expect(IllegalArgumentException.class);
         thrown.expectMessage("Invalid cache name: illegal%name for !@#");
 
         cache = createCache("illegal%name for !@#");
     }
 
     @Test
     public void getBulkFactory() {
         final Map<String, String> get1 = cache.getBulk(
                 strings -> strings.stream().collect(Collectors.toMap(k -> k, k -> k + "-1")));
 
         assertThat(get1.keySet(), empty());
         assertThat(get1.values(), empty());
 
         final Map<String, String> get2 = cache.getBulk(
                 strings -> strings.stream().collect(Collectors.toMap(k -> k, k -> k + "-1")),
                 "claira", "josie", "josie");
 
         assertThat(get2.keySet(), containsInAnyOrder("claira", "josie"));
         assertThat(get2.values(), containsInAnyOrder("claira-1", "josie-1"));
 
         final Map<String, String> get3 = cache.getBulk(
                 strings -> strings.stream().collect(Collectors.toMap(k -> k, k -> k + "-2")),
                 "claira", "josie", "jasmin");
 
         assertThat(get3.keySet(), containsInAnyOrder("claira", "josie", "jasmin"));
         assertThat(get3.values(), containsInAnyOrder("claira-1", "josie-1", "jasmin-2"));
     }
 
     @Test
     public void handle_legal_recursion_supplier() {
         final String result = cache.get("first", () ->
                 cache.get("second", () -> "pass"));
 
         assertThat(result, is("pass"));
     }
 
     @Test
     public void handle_legal_recursion_factory() {
         final Map<String, String> result = cache.getBulk(
                 strings1 -> {
                     cache.getBulk(strings2 -> {
                         return strings2.stream().collect(Collectors.toMap(k -> k, k -> k + "-2"));
                     }, "second");
                     return strings1.stream().collect(Collectors.toMap(k -> k, k -> k + "-1"));
                 },
                 "first");
 
         assertThat(result.size(), is(1));
         assertThat(result.containsKey("first"), is(true));
         assertThat(result.get("first"), is("first-1"));
     }
 }