@Test
public void testZeroResetsTTL() throws InterruptedException {
Config cfg = new Config();
MapConfig mc = cfg.getMapConfig("testZeroResetsTTL");
int ttl = 5;
mc.setTimeToLiveSeconds(ttl);
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(1);
HazelcastInstance instance = factory.newHazelcastInstance(cfg);
IMap<Object, Object> map = instance.getMap("testZeroResetsTTL");
final CountDownLatch latch = new CountDownLatch(1);
map.addEntryListener(
new EntryAdapter<Object, Object>() {
public void entryEvicted(EntryEvent event) {
latch.countDown();
}
},
false);
map.put(1, 1);
map.put(2, 2);
map.put(1, 2, 0, TimeUnit.SECONDS);
latch.await(10, TimeUnit.SECONDS);
assertNull(map.get(2));
assertEquals(2, map.get(1));
}
@Test
public void testEvictionLFU() {
try {
final int k = 1;
final int size = 10000;
final String mapName = "testEvictionLFU";
Config cfg = new Config();
MapConfig mc = cfg.getMapConfig(mapName);
mc.setEvictionPolicy(MapConfig.EvictionPolicy.LFU);
mc.setEvictionPercentage(20);
MaxSizeConfig msc = new MaxSizeConfig();
msc.setMaxSizePolicy(MaxSizeConfig.MaxSizePolicy.PER_NODE);
msc.setSize(size);
mc.setMaxSizeConfig(msc);
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(cfg);
IMap<Object, Object> map = instances[0].getMap(mapName);
for (int i = 0; i < size / 2; i++) {
map.put(i, i);
map.get(i);
}
Thread.sleep(1000);
for (int i = size / 2; i < size; i++) {
map.put(i, i);
}
Thread.sleep(3000);
Assert.assertFalse("No eviction!?!?!?", map.size() == size);
boolean isFrequentlyUsedEvicted = false;
for (int i = 0; i < size / 2; i++) {
if (map.get(i) == null) {
isFrequentlyUsedEvicted = true;
break;
}
}
Assert.assertFalse(isFrequentlyUsedEvicted);
instances[0].getLifecycleService().shutdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Test
public void testEvictionLFU2() {
try {
final int k = 2;
final int size = 10000;
final String mapName = "testEvictionLFU2";
Config cfg = new Config();
MapConfig mc = cfg.getMapConfig(mapName);
mc.setEvictionPolicy(MapConfig.EvictionPolicy.LFU);
mc.setEvictionPercentage(90);
MaxSizeConfig msc = new MaxSizeConfig();
msc.setMaxSizePolicy(MaxSizeConfig.MaxSizePolicy.PER_NODE);
msc.setSize(size);
mc.setMaxSizeConfig(msc);
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(cfg);
IMap<Object, Object> map = instances[0].getMap(mapName);
for (int i = 0; i < size; i++) {
map.put(i, i);
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 100; j++) {
assertNotNull(map.get(j));
}
for (int j = size - 100; j < size; j++) {
assertNotNull(map.get(j));
}
Thread.sleep(1000);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/*
github issue 585
*/
@Test
public void testIssue585ZeroTTLShouldPreventEvictionWithSet() throws InterruptedException {
Config config = new Config();
config.getGroupConfig().setName("testIssue585ZeroTTLShouldPreventEvictionWithSet");
NearCacheConfig nearCacheConfig = new NearCacheConfig();
config.getMapConfig("default").setNearCacheConfig(nearCacheConfig);
int n = 1;
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(n);
HazelcastInstance h = factory.newHazelcastInstance(config);
IMap<String, String> map = h.getMap("testIssue585ZeroTTLShouldPreventEvictionWithSet");
map.set("key", "value", 1, TimeUnit.SECONDS);
map.set("key", "value2", 0, TimeUnit.SECONDS);
Thread.sleep(2000);
assertEquals("value2", map.get("key"));
h.getLifecycleService().shutdown();
}
@Test
public void testEvictionLRU() {
final int k = 2;
final int size = 10000;
try {
final String mapName = "testEvictionLRU";
Config cfg = new Config();
MapConfig mc = cfg.getMapConfig(mapName);
mc.setEvictionPolicy(MapConfig.EvictionPolicy.LRU);
mc.setEvictionPercentage(10);
MaxSizeConfig msc = new MaxSizeConfig();
msc.setMaxSizePolicy(MaxSizeConfig.MaxSizePolicy.PER_NODE);
msc.setSize(size);
mc.setMaxSizeConfig(msc);
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(k);
final HazelcastInstance[] instances = factory.newInstances(cfg);
IMap<Object, Object> map = instances[0].getMap(mapName);
Thread.sleep(1000);
for (int i = size / 2; i < size; i++) {
map.put(i, i);
}
Thread.sleep(2000);
for (int i = 0; i < size / 2; i++) {
map.put(i, i);
}
Thread.sleep(1000);
int recentlyUsedEvicted = 0;
for (int i = 0; i < size / 2; i++) {
if (map.get(i) == null) {
recentlyUsedEvicted++;
}
}
Assert.assertTrue(recentlyUsedEvicted == 0);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/*
github issue 304
*/
@Test
public void testIssue304EvictionDespitePut() throws InterruptedException {
Config c = new Config();
c.getGroupConfig().setName("testIssue304EvictionDespitePut");
final HashMap<String, MapConfig> mapConfigs = new HashMap<String, MapConfig>();
final MapConfig value = new MapConfig();
value.setMaxIdleSeconds(3);
mapConfigs.put("default", value);
c.setMapConfigs(mapConfigs);
final Properties properties = new Properties();
properties.setProperty("hazelcast.map.cleanup.delay.seconds", "1"); // we need faster cleanups
c.setProperties(properties);
int n = 1;
TestHazelcastInstanceFactory factory = createHazelcastInstanceFactory(n);
final HazelcastInstance hazelcastInstance = factory.newHazelcastInstance(c);
IMap<String, Long> map = hazelcastInstance.getMap("testIssue304EvictionDespitePutMap");
final AtomicInteger evictCount = new AtomicInteger(0);
map.addEntryListener(
new EntryListener<String, Long>() {
public void entryAdded(EntryEvent<String, Long> event) {}
public void entryRemoved(EntryEvent<String, Long> event) {}
public void entryUpdated(EntryEvent<String, Long> event) {}
public void entryEvicted(EntryEvent<String, Long> event) {
evictCount.incrementAndGet();
}
},
true);
String key = "key";
for (int i = 0; i < 5; i++) {
map.put(key, System.currentTimeMillis());
Thread.sleep(1000);
}
assertEquals(evictCount.get(), 0);
assertNotNull(map.get(key));
hazelcastInstance.getLifecycleService().shutdown();
}
