package com.atlassian.cache.hazelcast;
   
   import com.atlassian.cache.AbstractCacheLazyTest;
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheFactory;
   import com.atlassian.cache.CacheSettingsBuilder;
   
   import org.hamcrest.MatcherAssert;
   import org.junit.After;
  import org.junit.Before;
  import org.junit.ClassRule;
  import org.junit.Ignore;
  import org.junit.Test;
  
  import static java.text.MessageFormat.format;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.lessThan;
  import static org.hamcrest.core.IsEqual.equalTo;
  
  public class HazelcastRemoteCacheLazyTest extends AbstractCacheLazyTest
  {
      private static final int HAZELCAST_INSTANCES = 2;
      @ClassRule
      public static InitOnceHazelcastCluster cluster = InitOnceHazelcastCluster.getInstance();
  
      private HazelcastCacheManager factory1;
      private HazelcastCacheManager factory2;
  
      @Before
      public void setUp()
      {
          cluster.reset();
          factory1 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(0));
          factory2 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(1));
  
          factory = factory1;
      }
  
      @After
      public void tearDown()
      {
          factory1.destroy();
          factory2.destroy();
      }
  
      @Override
      @Test
      public void testMaxEntries()
      {
          // new eviction process triggers data eviction right after a put operation.
          // http://docs.hazelcast.org/docs/latest-development/manual/html/Distributed_Data_Structures/Map/Map_Eviction.html
          int maxSize = 3000;
          Cache<String, Long> cache = makeSizeLimitedCache(maxSize, "HazelcastLazy.testMaxEntries");
  
          int earlyEvictionMark = (90 * HAZELCAST_INSTANCES * maxSize) / 100;
          for (int i = 0; i < earlyEvictionMark; ++i)
          {
              String key = cluster.generateKeyOwnedByNode(i % 2); // spread the data evenly distributed across the cluster
              long value = i;
              cache.put(key, value);
              MatcherAssert.assertThat(cache.get(key), equalTo(value));
          }
          // fill the map until we go over, but don't check the cache values - Hazelcast could evict the value that we're
          // adding.
          for (int i = earlyEvictionMark; i <= HAZELCAST_INSTANCES * maxSize + 1; ++i)  // maxSize per node, and we have 2 nodes
          {
              String key = cluster.generateKeyOwnedByNode(i % 2);
              long value = i;
              cache.put(key, value);
          }
  
          assertThat(format("Total number of the cached objects should be < than 6000", HAZELCAST_INSTANCES * maxSize),
                  cache.getKeys().size(), is(lessThan(HAZELCAST_INSTANCES * maxSize)));
      }
  
      @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
      @Override
      @Test
      public void testRemoveConcurrentWithLoaderLocal()
      {
          super.testRemoveConcurrentWithLoaderLocal();
      }
  
      @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
      @Test
      public void testRemoveConcurrentWithLoadClustered()
      {
          final CacheFactory factory2 = HazelcastTestSupport.createDistributedFactory(cluster.getNode(1));
          removeConcurrentWithLoader(factory, factory2, REMOVE_0);
      }
  
      @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
      @Override
      @Test
      public void testRemoveConcurrentWithSupplierLocal()
      {
          super.testRemoveConcurrentWithSupplierLocal();
      }
 
     @Ignore("CACHE-106/CACHE-108: Needs to be fixed (currently hard fails)")
     @Override
     @Test
     public void testRemoveAllConcurrentWithSupplierLocal()
     {
         super.testRemoveAllConcurrentWithSupplierLocal();
     }
 
     @Override
     protected CacheSettingsBuilder settingsBuilder()
     {
         return new CacheSettingsBuilder().remote();
     }
 }