package com.atlassian.cache;
   
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.atomic.AtomicInteger;
   
   import javax.annotation.Nonnull;
   
   import org.hamcrest.Matchers;
   
  import static org.hamcrest.Matchers.hasSize;
  import static org.junit.Assert.assertThat;
  
  public class AbstractCacheTest
  {
      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));
     }
 }