package com.atlassian.cache.hazelcast;
   
   import com.atlassian.cache.AbstractCacheEagerTest;
   import com.atlassian.cache.Cache;
   import com.atlassian.cache.CacheSettingsBuilder;
   
   import org.junit.Before;
   import org.junit.ClassRule;
   import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.greaterThan;
  import static org.hamcrest.Matchers.lessThan;
  import static org.hamcrest.core.IsEqual.equalTo;
  
  @RunWith (MockitoJUnitRunner.class)
  public class HazelcastRemoteCacheEagerTest extends AbstractCacheEagerTest
  {
      @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;
          Cache<String, Long> cache = makeSizeLimitedCache(maxSize);
  
          int actualMaxSize = maxSize * cluster.size();
          for (int i = 0; i <= actualMaxSize + 1; ++i)
          {
              String key = Integer.toString(i);
              long value = 10L + i;
              cache.put(key, value);
              assertThat(cache.get(key), equalTo(value));
          }
  
          // 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));
      }
  
      @Override
      protected CacheSettingsBuilder settingsBuilder()
      {
          return new CacheSettingsBuilder().remote();
      }
  }