package com.atlassian.cache;
   
   import java.util.concurrent.CountDownLatch;
   import java.util.concurrent.TimeUnit;
   import java.util.concurrent.atomic.AtomicInteger;
   
   import javax.annotation.Nonnull;
   import javax.annotation.Nullable;
   
  import com.atlassian.utt.concurrency.Barrier;
  import com.atlassian.utt.concurrency.TestThread;
  
  import com.google.common.base.Throwables;
  import org.junit.Test;
  
  import static com.atlassian.utt.concurrency.TestThread.runTest;
  import static java.util.concurrent.TimeUnit.SECONDS;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.isOneOf;
  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
  {
      public AbstractLazyReferenceTest()
      {
      }
  
      public AbstractLazyReferenceTest(CacheType cacheType)
      {
          super(cacheType);
      }
  
      @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(), settingsBuilder().build());
  
          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();
  
          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(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",
                     Throwables.getRootCause(ex),
                     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);
 
     }
 
     @Test
     public void testWhenResettingAReferenceWhereTheSupplierReturnsNullNoExceptionIsThrown()
     {
         try
         {
             CachedReference<Long> reference = makeExceptionalReference();
             reference.reset();
         }
         catch (Exception e)
         {
             fail("Exception should not be thrown when a loader return null during a remove: " + e.getMessage());
         }
     }
 
     @Test
     public void testResetConcurrentWithLoadLocal()
     {
         resetConcurrentWithLoad(factory, null);
     }
 
     protected void resetConcurrentWithLoad(final CacheFactory factory1, @Nullable final CacheFactory factory2)
     {
         final Barrier doUpdate = new Barrier();
         final CountDownLatch resetDone = new CountDownLatch(1);
         final Barrier afterGet = new Barrier();
         final AtomicInteger dbValue = new AtomicInteger(1);
 
         final Supplier<Integer> supplier = new Supplier<Integer>()
         {
             @Nonnull
             @Override
             public Integer get()
             {
                 final int value = dbValue.get();
                 doUpdate.trySignal();
                 try
                 {
                     // Whether or not reset gets blocked by the load operation is implementation-dependent.
                     resetDone.await(100L, TimeUnit.MILLISECONDS);
                 }
                 catch (InterruptedException ie)
                 {
                     throw new AssertionError(ie);
                 }
                 afterGet.trySignal();
                 return value;
             }
         };
 
         final CachedReference<Integer> ref1 = factory1.getCachedReference("resetConcurrentWithLoad", supplier,
                 settingsBuilder().build());
         final CachedReference<Integer> ref2 = (factory2 != null)
                 ? factory2.getCachedReference("resetConcurrentWithLoad", supplier, settingsBuilder().build())
                 : ref1;
 
         // Make sure everything is live.  Hazelcast takes >5s to initialize sometimes.
         ref1.reset();
         ref2.reset();
 
         final TestThread blockingGet = new TestThread("blockingGet")
         {
             @Override
             protected void go() throws Exception
             {
                 Integer value = ref1.get();
                 assertThat("before reset", value, isOneOf(1, 2));  // Either the stale or updated value is acceptable
 
                 assertThat("resetDone", resetDone.await(5L, SECONDS), is(true));
 
                 value = ref1.get();
                 assertThat("after reset", value, is(2));
             }
         };
 
         final TestThread modifyResetGet = new TestThread("modifyResetGet")
         {
             @Override
             protected void go() throws Exception
             {
                 doUpdate.await();
 
                 dbValue.set(2);
                 ref2.reset();
                 resetDone.countDown();
 
                 Integer value = ref2.get();
                 assertThat("after reset", value, is(2));
             }
         };
 
         runTest(blockingGet, modifyResetGet);
     }
 
     protected CachedReference<Long> makeReference()
     {
         // Build a Cache using the builder
         Supplier<Long> supplier = new Supplier<Long>()
         {
             private long value = 100;
             @Override
             public Long get()
             {
                 return value++;
             }
         };
         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());
     }
 
     private static Supplier<Long> nullSupplier()
     {
         return new Supplier<Long>()
         {
             @Override
             public Long get()
             {
                 return null;
             }
         };
     }
 }