package com.atlassian.cache.hazelcast;
   
   import java.util.concurrent.atomic.AtomicInteger;
   
   import com.atlassian.cache.AbstractCacheLazyTest;
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.CacheSettingsBuilder;
   
  import org.junit.Before;
  import org.junit.ClassRule;
  import org.junit.Ignore;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import static org.hamcrest.Matchers.greaterThan;
  import static org.hamcrest.Matchers.lessThan;
  import static org.hamcrest.core.IsEqual.equalTo;
  import static org.junit.Assert.assertThat;
  
  @RunWith (MockitoJUnitRunner.class)
  public class HazelcastRemoteCacheLazyTest extends AbstractCacheLazyTest
  {
      @ClassRule
      public static InitOnceHazelcastCluster cluster = InitOnceHazelcastCluster.getInstance();
  
      @Before
      public void setUp() throws Exception
      {
          cluster.reset();
          factory = HazelcastTestSupport.createDistributedFactory(cluster.getNode(0));
      }
  
      @Override
      @Test (timeout = 10000L)
      public void testMaxEntries() throws Exception
      {
          // overridden because Hazelcast cache eviction is performed asynchronously and does evicts in bulk a percentage
          // of the cached value. Also note that MapEvictTask translates the cache maxSize to a per-partition max size.
          // Given that Hazelcast uses hundreds of partitions even when it is running on a small number of nodes, this leads
          // to very low per-partition maxes when configuring a low max value. (often rounded down to 0)
  
          int maxSize = 1000;
          AtomicInteger loadCounter = new AtomicInteger();
          Cache<String, Long> cache = makeSizeLimitedCache(maxSize, loadCounter);
  
          // Add some entries using the builder
          assertThat(cache.get("1"), equalTo(1L));
          assertThat(cache.get("1"), equalTo(1L));
          assertThat(cache.get("2"), equalTo(2L));
          assertThat(cache.get("3"), equalTo(3L));
          assertThat("loadCounter", loadCounter.get(), equalTo(3));
          assertSize(cache, 3);
          assertThat(cache.get("3"), equalTo(3L));
          assertThat(cache.get("3"), equalTo(3L));
          assertThat("loadCounter", loadCounter.get(), equalTo(3));
          assertSize(cache, 3);
  
          int actualMaxSize = maxSize * cluster.size();
          for (int i = 4; i <= actualMaxSize + 1; ++i)
          {
              assertThat(cache.get(Integer.toString(i)), equalTo((long) i));
              assertThat("loadCounter", loadCounter.get(), equalTo(i));
          }
  
          // allow the map eviction to happen - cache eviction happens every second (async)
          while (cache.getKeys().size() > actualMaxSize)
          {
              Thread.sleep(5L);
          }
  
          assertThat(cache.getKeys().size(), lessThan(actualMaxSize));
          assertThat(cache.getKeys().size(), greaterThan(maxSize));
      }
  
      @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
      @Override
      @Test
      public void testRemoveAllConcurrentWithLoadLocal()
      {
          super.testRemoveAllConcurrentWithLoadLocal();
      }
  
      @Test
      public void testRemoveConcurrentWithLoadClustered()
      {
          final CacheFactory factory2 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(1));
          removeConcurrentWithLoad(factory, factory2, REMOVE_0);
      }
  
      @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
      @Test
      public void testRemoveAllConcurrentWithLoadClustered()
      {
          final CacheFactory factory2 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(1));
          removeConcurrentWithLoad(factory, factory2, REMOVE_ALL);
      }
  
     @Override
     protected CacheSettingsBuilder settingsBuilder()
     {
         return new CacheSettingsBuilder().remote();
     }
 }