package com.atlassian.cache;
   
   import com.atlassian.util.concurrent.Suppliers;
   
   import org.junit.Test;
   
   import static junit.framework.Assert.fail;
   import static org.hamcrest.core.IsEqual.equalTo;
   import static org.hamcrest.core.IsInstanceOf.instanceOf;
  import static org.junit.Assert.assertThat;
  
  /**
   * Test the Lazy Reference
   *
   * @since 2.0
   */
  public abstract class AbstractLazyReferenceTest
  {
  
      protected CacheFactory factory;
  
      @Test
      public void testGetName() throws Exception
      {
          CachedReference<Long> ref = makeReference();
  
          assertThat(((ManagedCache) ref).getName(), equalTo("mycache"));
      }
  
      @Test
      public void testFactoryGeneratedName() throws Exception
      {
          CachedReference<Long> ref = factory.getCachedReference(Object.class, "mycache", nullSupplier());
  
          assertThat(((ManagedCache) ref).getName(), equalTo("java.lang.Object.mycache"));
      }
  
      @Test
      public void testGet() throws Exception
      {
          CachedReference<Long> ref = makeReference();
  
          assertThat(ref.get(), equalTo(100L));
          assertThat(ref.get(), equalTo(100L));
          assertThat(ref.get(), equalTo(100L));
      }
  
  
      @Test
      public void testReset() throws Exception
      {
          CachedReference<Long> ref = makeReference();
  
          assertThat(ref.get(), equalTo(100L));
  
          ref.reset();
  
          // This should have been recalculated
          assertThat(ref.get(), equalTo(101L));
      }
  
      @Test
      public void testRemoveTwice() throws Exception
      {
          CachedReference<Long> ref = makeReference();
  
          assertThat(ref.get(), equalTo(100L));
          assertThat(ref.get(), equalTo(100L));
  
          ref.reset();
          ref.reset();
  
          // This should have been recalculated
          assertThat(ref.get(), equalTo(101L));
          assertThat(ref.get(), equalTo(101L));
  
          ref.reset();
  
          // This should have been recalculated
          assertThat(ref.get(), equalTo(102L));
          assertThat(ref.get(), equalTo(102L));
      }
  
      @Test
      public void testClear() throws Exception
      {
          CachedReference<Long> ref = makeReference();
  
          assertThat(ref.get(), equalTo(100L));
  
          ((ManagedCache) ref).clear();
  
          // This should have been recalculated
          assertThat(ref.get(), equalTo(101L));
      }
  
      @Test
      public void testNullHandling() throws Exception
      {
         CachedReference<Long> ref = makeNullReference();
 
         try {
             Long v = ref.get();
             fail("Should throw CacheException when the loader computes a null");
         }
         catch (CacheException ex)
         {
             assertThat("This exception should wrap the original Exception", ex.getCause(), instanceOf(NullPointerException.class));
         }
     }
 
     @Test
     public void testExceptionHandling() throws Exception
     {
         CachedReference<Long> ref = makeExceptionalReference();
         try {
             Long v = ref.get();
             fail("Should throw CacheException when the loader computes a null");
         }
         catch (CacheException ex)
         {
             assertThat("This exception should wrap the original Exception", ex.getCause(), instanceOf(IllegalArgumentException.class));
         }
     }
 
 
     private CachedReference<Long> makeReference()
     {
         // Build a Cache using the builder
         Supplier<Long> supplier = new Supplier<Long>()
         {
             private long l = 100;
             @Override
             public Long get()
             {
                 return l++;
             }
         };
         return factory.getCachedReference("mycache", supplier);
     }
 
     private CachedReference<Long> makeNullReference()
     {
         return factory.getCachedReference("mycache", nullSupplier());
     }
 
     private CachedReference<Long> makeExceptionalReference()
     {
         Supplier<Long> supplier = new Supplier<Long>()
         {
             @Override
             public Long get()
             {
                 throw new IllegalArgumentException();
             }
         };
         return factory.getCachedReference("mycache", supplier);
     }
 
     private static Supplier<Long> nullSupplier()
     {
         return new Supplier<Long>()
         {
             @Override
             public Long get()
             {
                 return null;
             }
         };
     }
 }