package com.atlassian.vcache.internal.test;
   
   import java.util.Arrays;
   import java.util.Map;
   import java.util.Optional;
   import java.util.Set;
   import java.util.function.Function;
   import java.util.stream.Collectors;
   
  import com.atlassian.vcache.LocalCacheOperations;
  
  import org.hamcrest.Matchers;
  import org.junit.Before;
  import org.junit.Rule;
  import org.junit.Test;
  import org.junit.rules.ExpectedException;
  
  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 LocalCacheOperations<String, String> 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 testGetBulkEmpty() throws Exception
     {
         final Map<String, Optional<String>> data = cache.getBulk();
 
         assertThat(data, notNullValue());
         assertThat(data.size(), is(0));
     }
 
     @Test
     public void testGetBulkSingleMiss() throws Exception
     {
         final Map<String, Optional<String>> data = cache.getBulk("k1");
 
         assertThat(data, notNullValue());
         assertThat(data.keySet(), Matchers.containsInAnyOrder("k1"));
         assertThat(data.values(), Matchers.containsInAnyOrder(Optional.empty()));
     }
 
     @Test
     public void testGetBulkOneMissOneKey() throws Exception
     {
         cache.put("hit", "boom");
         final Map<String, Optional<String>> data = cache.getBulk(Arrays.asList("hit", "miss"));
 
         assertThat(data, notNullValue());
         assertThat(data.keySet(), Matchers.containsInAnyOrder("hit", "miss"));
         assertThat(data.get("hit"), is(Optional.of("boom")));
         assertThat(data.get("miss"), is(Optional.empty()));
     }
 
     @Test
     public void testGetBulkWithFunction() throws Exception
     {
         cache.put("k2", "kayak");
         final Function<Set<String>, Map<String, String>> factory = keys ->
                 keys.stream().collect(Collectors.toMap(k -> k, k -> "val-" + k));
         final Map<String, String> data = cache.getBulk(factory, "k1", "k2", "k3");
 
         assertThat(data, notNullValue());
         assertThat(data.keySet(), Matchers.containsInAnyOrder("k1", "k2", "k3"));
         assertThat(data.get("k1"), is("val-k1"));
         assertThat(data.get("k2"), is("kayak"));
         assertThat(data.get("k3"), is("val-k3"));
 
         // Verify that the backing cache has the data as well
         assertThat(cache.get("k1"), is(Optional.of("val-k1")));
         assertThat(cache.get("k2"), is(Optional.of("kayak")));
         assertThat(cache.get("k3"), is(Optional.of("val-k3")));
     }
 
     @Test
     public void testInvalidName()
     {
         thrown.expect(IllegalArgumentException.class);
         thrown.expectMessage("Invalid cache name: illegal%name for !@#");
 
         cache = createCache("illegal%name for !@#");
     }
 
 }