package com.atlassian.cache.ehcache;
   
   import java.util.concurrent.CountDownLatch;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   import java.util.concurrent.atomic.AtomicBoolean;
   
   import com.atlassian.cache.AbstractCacheLazyTest;
   import com.atlassian.cache.Cache;
  import com.atlassian.cache.CacheLoader;
  import com.atlassian.cache.ehcache.cluster.EhCacheCluster;
  
  import org.junit.Before;
  import org.junit.Ignore;
  import org.junit.Test;
  
  import junit.framework.AssertionFailedError;
  
  import static com.atlassian.cache.ehcache.cluster.EhCacheCluster.clusteredTest;
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  import static org.hamcrest.CoreMatchers.is;
  import static org.junit.Assert.assertSame;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.verifyNoMoreInteractions;
  import static org.mockito.Mockito.when;
  
  /**
   * Test the Delegated Lazy Cache
   *
   * @since 2.0
   */
  public class DelegatingCacheLazyTest extends AbstractCacheLazyTest
  {
      @Before
      public void setUp() throws Exception
      {
          factory = new EhCacheManager();
          // Make sure we are not getting old caches for our test.
          ((EhCacheManager) factory).getEh().removeAllCaches();
      }
  
      @Test
      @Override
      public void testNullValue() throws Exception
      {
          // Override and ignore this test because EHCache handles null values
      }
  
      @Test
      public void shouldBlockOnConcurrentGet() throws Exception
      {
          // Set up
          final AtomicBoolean weFailed = new AtomicBoolean();
          final CacheLoader<String, Long> mockLoader = mock(CacheLoader.class);
          final int threads = 20;
          final String key = "anything";
          // Create a specific Long object so we can test we always get the same.
          final Long result = 123456L;
          when(mockLoader.load(key)).thenReturn(result);
          final ExecutorService executor = Executors.newFixedThreadPool(threads);
          final Cache<String, Long> cache = factory.getCache("mycache", mockLoader);
          final CountDownLatch startLatch = new CountDownLatch(1);
          for (int i = 0; i < threads; i++)
          {
              executor.execute(new Runnable()
              {
                  @Override
                  public void run()
                  {
                      try
                      {
                          startLatch.await();
                          assertSame(result, cache.get(key));
                      }
                      catch (InterruptedException e)
                      {
                          weFailed.set(true);
                      }
                      catch (AssertionFailedError e)
                      {
                          weFailed.set(true);
                      }
                  }
              });
          }
  
          // Invoke
          startLatch.countDown();
          executor.shutdown();
          executor.awaitTermination(500L, MILLISECONDS);
  
          // Check
          verify(mockLoader, times(1)).load(key);
          verifyNoMoreInteractions(mockLoader);
  
          assertThat(weFailed.get(), is(false));
     }
 
     @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
     @Test
     public void testRemoveConcurrentWithLoadClustered() throws Exception
     {
         clusteredTest(2, new EhCacheCluster.ClusteredTest()
         {
             @Override
             public void runTest(EhCacheCluster cluster) throws Exception
             {
                 removeConcurrentWithLoader(cluster.getNode(0), cluster.getNode(1), REMOVE_0);
             }
         });
     }
 
     @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
     @Test
     public void testRemoveAllConcurrentWithLoadClustered() throws Exception
     {
         clusteredTest(2, new EhCacheCluster.ClusteredTest()
         {
             @Override
             public void runTest(EhCacheCluster cluster) throws Exception
             {
                 removeConcurrentWithLoader(cluster.getNode(0), cluster.getNode(1), REMOVE_ALL);
             }
         });
     }
 
     @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
     @Test
     @Override
     public void testRemoveAllConcurrentWithSupplierLocal()
     {
         super.testRemoveAllConcurrentWithSupplierLocal();
     }
 
     @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
     @Test
     @Override
     public void testRemoveConcurrentWithSupplierLocal()
     {
         super.testRemoveConcurrentWithSupplierLocal();
     }
 }