package com.atlassian.cache;
   
   import org.junit.Test;
   
   import static org.hamcrest.core.IsEqual.equalTo;
   import static org.hamcrest.core.IsInstanceOf.instanceOf;
   import static org.junit.Assert.assertNotSame;
   import static org.junit.Assert.assertThat;
   import static org.junit.Assert.fail;
  
  /**
   * Test the Lazy Reference
   *
   * @since 2.0
   */
  public abstract class AbstractLazyReferenceTest extends AbstractCacheTest
  {
      @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 (twice as reset will get the value)
          assertThat(ref.get(), equalTo(102L));
          assertThat(ref.get(), equalTo(102L));
  
          ref.reset();
  
          // This should have been recalculated
          assertThat(ref.get(), equalTo(103L));
          assertThat(ref.get(), equalTo(103L));
      }
  
      @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(expected = CacheException.class)
      public void testNullHandling() throws Exception
      {
          makeNullReference().get();
      }
  
      @Test
     public void testExceptionHandling() throws Exception
     {
         final CachedReference<Long> ref = makeExceptionalReference();
         try
         {
             ref.get();
             fail("Should throw CacheException when the loader throws an IllegalArgumentException");
         }
         catch (CacheException ex)
         {
             assertThat("This exception should wrap the original Exception", ex.getCause(), instanceOf(IllegalArgumentException.class));
         }
         assertThat("The exception should not be sticky", ref.get(), equalTo(42L));
     }
 
     @Test
     public void testNewInstanceForEveryGet()
     {
         CachedReference<Long> ref1 = makeReference();
         CachedReference<Long> ref2 = makeReference();
 
         assertNotSame("The cache manager should not return the same cache twice", ref1, ref2);
 
     }
 
 
 
     protected 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, settingsBuilder().build());
     }
 
     private CachedReference<Long> makeNullReference()
     {
         return factory.getCachedReference("mycache", nullSupplier(), settingsBuilder().build());
     }
 
     private CachedReference<Long> makeExceptionalReference()
     {
         Supplier<Long> supplier = new Supplier<Long>()
         {
             private boolean called = false;
 
             @Override
             public Long get()
             {
                 if (called)
                 {
                     return 42L;
                 }
                 called = true;
                 throw new IllegalArgumentException();
             }
         };
         return factory.getCachedReference("mycache", supplier, settingsBuilder().build());
     }
 
     protected CacheSettingsBuilder settingsBuilder()
     {
         return new CacheSettingsBuilder();
     }
 
 
     private static Supplier<Long> nullSupplier()
     {
         return new Supplier<Long>()
         {
             @Override
             public Long get()
             {
                 return null;
             }
         };
     }
 }