package com.atlassian.cache.hazelcast;
   
   import com.atlassian.cache.AbstractCacheEagerTest;
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheSettingsBuilder;
   
   import org.junit.After;
   import org.junit.Before;
   import org.junit.ClassRule;
  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 HazelcastRemoteCacheEagerTest extends AbstractCacheEagerTest
  {
      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,"HazelcastRemote.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);
              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 {0}", HAZELCAST_INSTANCES * maxSize),
                  cache.getKeys().size(), is(lessThan(HAZELCAST_INSTANCES * maxSize)));
      }
  
      @Override
      protected CacheSettingsBuilder settingsBuilder()
      {
          return new CacheSettingsBuilder().remote();
      }
  }