package com.atlassian.cache;
   
   import java.util.Objects;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.atomic.AtomicInteger;
   
   import javax.annotation.Nonnull;
   
   import org.hamcrest.Matcher;
  import org.hamcrest.Matchers;
  import org.junit.Test;
  
  import static org.hamcrest.Matchers.hasSize;
  import static org.hamcrest.Matchers.is;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.fail;
  
  public abstract class AbstractCacheTest
  {
      public enum CacheType {LOCAL, REMOTE, HYBRID, DEFAULT}
  
      private final CacheType cacheType;
  
      public AbstractCacheTest()
      {
          this.cacheType = CacheType.DEFAULT;
      }
  
      public AbstractCacheTest(CacheType cacheType)
      {
          this.cacheType = Objects.requireNonNull(cacheType);
      }
  
      @Test
      public void testWhenRemovingAKeyWhereTheLoaderReturnsNullTheExceptionIsSwallowed()
      {
          try
          {
              Cache<String, Long> cache = makeNullReturningCache();
              cache.remove("I don't exist key");
          }
          catch (Exception e)
          {
              fail("Exception should not be thrown when a loader return null during a remove: " + e.getMessage());
          }
      }
  
      @Test
      public void testWhenRemovingAKeyWithValueWhereTheLoaderReturnsNullTheExceptionIsSwallowed()
      {
          try
          {
              Cache<String, Long> cache = makeNullReturningCache();
              cache.remove("I don't exist key", 1L); //magic one null will always be returned
          }
          catch (Exception e)
          {
              fail("Exception should not be thrown when a loader return null during a remove: " + e.getMessage());
          }
      }
  
      @Test
      public void testWhenRemovingAllKeysWhereTheLoaderReturnsNullTheExceptionIsSwallowed()
      {
          try
          {
              Cache<String, Long> cache = makeNullReturningCache();
              cache.removeAll();
          }
          catch (Exception e)
          {
              fail("Exception should not be thrown when a loader return null during a remove: " + e.getMessage());
          }
      }
  
      /**
       * Version of {@link org.hamcrest.MatcherAssert#assertThat} that retries for a brief duration before giving up.
       * This allows reasonable testing of caches with relaxed consistency semantics.
       * @param actual a supplier that, when evaluated via {@link Supplier#get()}, returns the actual value to be checked.
       *               This supplier <strong>must</strong> be idempotent, as it will be called repeatedly until either
       *               the matcher matches or the timeout is exceeded.
       * @param matcher a matcher that checks the actual value
       */
      protected static <T> void assertEventuallyThat(Supplier<T> actual, Matcher<? super T> matcher)
      {
          final int TIMEOUT_MILLIS = 200;
          final int SLEEP_MILLIS = 5;
          try
          {
              for (int millis = 0; !matcher.matches(actual.get()) && millis < TIMEOUT_MILLIS; millis += SLEEP_MILLIS)
              {
                  Thread.sleep(SLEEP_MILLIS);
              }
          }
          catch (InterruptedException e)
          {
              Thread.currentThread().interrupt();
          }
          assertThat(actual.get(), matcher);
     }
 
     protected CacheFactory factory;
 
     protected Cache<String, Long> makeExceptionalCache()
     {
         // Build a Cache using the builder
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 return Long.valueOf(key);
             }
         };
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settingsBuilder().build());
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeExpiringCache()
     {
         // Build a Cache using the builder
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 try
                 {
                     return Long.valueOf(key);
                 }
                 catch (NumberFormatException e)
                 {
                     return -21L;
                 }
             }
         };
         CacheSettings settings = settingsBuilder().expireAfterAccess(10, TimeUnit.MILLISECONDS).build();
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settings);
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeNullReturningCache()
     {
         // Build a Cache using the builder
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 try
                 {
                     return Long.valueOf(key);
                 }
                 catch (NumberFormatException e)
                 {
                     return null;
                 }
             }
         };
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settingsBuilder().build());
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeSimpleCache()
     {
         return makeSimpleCache(false);
     }
 
     protected Cache<String, Long> makeSimpleCache(boolean statsEnabled)
     {
         // Build a Cache using the builder
         final Cache<String, Long> cache = factory.getCache("mycache", null, settingsBuilder(statsEnabled).build());
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeSizeLimitedCache(int maxEntries, String cacheName)
     {
         CacheSettings required = settingsBuilder().maxEntries(maxEntries).build();
         final Cache<String, Long> cache = factory.getCache(cacheName, null, required);
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeSizeLimitedCache(final int maxEntries, final AtomicInteger loadCounter)
     {
         // Build a Cache using the builder
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 loadCounter.incrementAndGet();
                 return Long.valueOf(key);
             }
         };
         CacheSettings settings = settingsBuilder().maxEntries(maxEntries).build();
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settings);
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeUnexpiringCache()
     {
         // Build a Cache using the builder
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 try
                 {
                     return Long.valueOf(key);
                 }
                 catch (NumberFormatException e)
                 {
                     return -21L;
                 }
             }
         };
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settingsBuilder().build());
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeSlowCache()
     {
         CacheLoader<String, Long> loader = new CacheLoader<String, Long>()
         {
             @Nonnull
             @Override
             public Long load(@Nonnull final String key)
             {
                 try
                 {
                     Thread.sleep(100);
                     return Long.valueOf(key);
                 }
                 catch (InterruptedException | NumberFormatException e)
                 {
                     return -21L;
                 }
             }
         };
         final Cache<String, Long> cache = factory.getCache("mycache", loader, settingsBuilder().build());
         assertEmpty(cache);
         return cache;
     }
 
     protected CacheSettingsBuilder settingsBuilder()
     {
         return settingsBuilder(false);
     }
 
     protected CacheSettingsBuilder settingsBuilder(boolean statsEnabled)
     {
         final CacheSettingsBuilder bob = new CacheSettingsBuilder();
 
         if (statsEnabled)
         {
             bob.statisticsEnabled();
         } else {
             bob.statisticsDisabled();
         }
 
         if (cacheType == CacheType.LOCAL)
         {
             bob.local();
         }
         else if (cacheType == CacheType.REMOTE)
         {
             bob.remote();
         }
         else if (cacheType == CacheType.HYBRID)
         {
             bob.remote().replicateViaInvalidation();
         }
 
         return bob;
     }
 
     // Hiding broken type inferences
 
     protected <K, V> void assertEmpty(Cache<K, V> cache)
     {
         assertThat(cache.getKeys(), Matchers.<K>empty());
     }
 
     protected <K, V> void assertSize(Cache<K, V> cache, final int expectedSize)
     {
         assertThat(cache.getKeys(), hasSize(expectedSize));
     }
 
     @SafeVarargs
     protected final <K, V> void assertContainsKeys(Cache<K, V> cache, K... keys)
     {
         for (K key : keys)
         {
             assertThat("Contains key: " + key, cache.containsKey(key), is(true));
         }
     }
 
     @SafeVarargs
     protected final <K, V> void assertMissingKeys(Cache<K, V> cache, K... keys)
     {
         for (K key : keys)
         {
             assertThat("Contains key: " + key, cache.containsKey(key), is(false));
         }
     }
 }