package com.atlassian.cache;
   
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.atomic.AtomicInteger;
   
   import javax.annotation.Nonnull;
   
   import org.hamcrest.Matchers;
   import org.junit.Test;
  
  import static org.hamcrest.Matchers.hasSize;
  import static org.junit.Assert.assertThat;
  import static org.junit.Assert.fail;
  
  public abstract class AbstractCacheTest
  {
      @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());
          }
      }
  
      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()
     {
         // Build a Cache using the builder
         final Cache<String, Long> cache = factory.getCache("mycache", null, settingsBuilder().build());
         assertEmpty(cache);
         return cache;
     }
 
     protected Cache<String, Long> makeSizeLimitedCache(int maxEntries)
     {
         CacheSettings required = settingsBuilder().maxEntries(maxEntries).build();
         final Cache<String, Long> cache = factory.getCache("mycache", 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 CacheSettingsBuilder settingsBuilder()
     {
         return new CacheSettingsBuilder();
     }
 
     // Hiding broken type inferences
 
     protected static <K,V> void assertEmpty(Cache<K,V> cache)
     {
         assertThat(cache.getKeys(), Matchers.<K>empty());
     }
 
     protected static <K,V> void assertSize(Cache<K,V> cache, final int expectedSize)
     {
         assertThat(cache.getKeys(), hasSize(expectedSize));
     }
 }