github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed - RMapCache and RSetCache should implement RDestroyable #1601

Browse Source
pull/1614/head
Nikita 7 years ago
parent 2199a9c0dd
commit cb004ab8c6
8 changed files with 225 additions and 31 deletions
Show Stats Download Patch File Download Diff File

12
redisson/src/main/java/org/redisson/RedissonMapCache.java
Unescape Escape View File

@ -36,7 +36,6 @@ import org.redisson.api.map.event.EntryExpiredListener;
import org.redisson.api.map.event.EntryRemovedListener;
import org.redisson.api.map.event.EntryUpdatedListener;
import org.redisson.api.map.event.MapEntryListener;
import org.redisson.client.ChannelName;
import org.redisson.client.RedisClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.LongCodec;
@ -82,12 +81,15 @@ import io.netty.util.concurrent.FutureListener;
*/
public class RedissonMapCache<K, V> extends RedissonMap<K, V> implements RMapCache<K, V> {
private EvictionScheduler evictionScheduler;
public RedissonMapCache(EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
String name, RedissonClient redisson, MapOptions<K, V> options) {
super(commandExecutor, name, redisson, options);
if (evictionScheduler != null) {
evictionScheduler.schedule(getName(), getTimeoutSetName(), getIdleSetName(), getExpiredChannelName(), getLastAccessTimeSetName());
}
this.evictionScheduler = evictionScheduler;
}
public RedissonMapCache(Codec codec, EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor,
@ -96,6 +98,7 @@ public class RedissonMapCache<K, V> extends RedissonMap<K, V> implements RMapCac
if (evictionScheduler != null) {
evictionScheduler.schedule(getName(), getTimeoutSetName(), getIdleSetName(), getExpiredChannelName(), getLastAccessTimeSetName());
}
this.evictionScheduler = evictionScheduler;
}
@Override
@ -2027,4 +2030,11 @@ public class RedissonMapCache<K, V> extends RedissonMap<K, V> implements RMapCac
Arrays.<Object>asList(getName(), getTimeoutSetName(), getIdleSetName(), getLastAccessTimeSetName(), getOptionsName()),
System.currentTimeMillis());
}
@Override
public void destroy() {
if (evictionScheduler != null) {
evictionScheduler.remove(getName());
}
}
}

10
redisson/src/main/java/org/redisson/RedissonSetCache.java
Unescape Escape View File

@ -62,12 +62,14 @@ import io.netty.buffer.ByteBuf;
public class RedissonSetCache<V> extends RedissonExpirable implements RSetCache<V>, ScanIterator {
RedissonClient redisson;
EvictionScheduler evictionScheduler;
public RedissonSetCache(EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson) {
super(commandExecutor, name);
if (evictionScheduler != null) {
evictionScheduler.schedule(getName(), 0);
}
this.evictionScheduler = evictionScheduler;
this.redisson = redisson;
}
@ -76,6 +78,7 @@ public class RedissonSetCache<V> extends RedissonExpirable implements RSetCache<
if (evictionScheduler != null) {
evictionScheduler.schedule(getName(), 0);
}
this.evictionScheduler = evictionScheduler;
this.redisson = redisson;
}
@ -378,4 +381,11 @@ public class RedissonSetCache<V> extends RedissonExpirable implements RSetCache<
return new RedissonLock(commandExecutor, lockName);
}
@Override
public void destroy() {
if (evictionScheduler != null) {
evictionScheduler.remove(getName());
}
}
}

2
redisson/src/main/java/org/redisson/api/RMapCache.java
Unescape Escape View File

@ -37,7 +37,7 @@ import org.redisson.api.map.event.MapEntryListener;
* @param <K> key
* @param <V> value
*/
public interface RMapCache<K, V> extends RMap<K, V>, RMapCacheAsync<K, V> {
public interface RMapCache<K, V> extends RMap<K, V>, RMapCacheAsync<K, V>, RDestroyable {
/**
* Sets max size of the map.

2
redisson/src/main/java/org/redisson/api/RSetCache.java
Unescape Escape View File

@ -38,7 +38,7 @@ import org.redisson.api.mapreduce.RCollectionMapReduce;
*
* @param <V> value
*/
public interface RSetCache<V> extends Set<V>, RExpirable, RSetCacheAsync<V> {
public interface RSetCache<V> extends Set<V>, RExpirable, RSetCacheAsync<V>, RDestroyable {
/**
* Returns lock instance associated with <code>value</code>

4
redisson/src/main/java/org/redisson/eviction/EvictionScheduler.java
Unescape Escape View File

@ -71,4 +71,8 @@ public class EvictionScheduler {
}
}
public void remove(String name) {
tasks.remove(name);
}
}

105
redisson/src/test/java/org/redisson/BaseMapTest.java
Unescape Escape View File

@ -19,6 +19,7 @@ import java.util.concurrent.ThreadLocalRandom;
import org.junit.Assert;
import org.junit.Assume;
import org.junit.Test;
import org.redisson.api.RDestroyable;
import org.redisson.api.RLocalCachedMap;
import org.redisson.api.RMap;
import org.redisson.api.RMapCache;
@ -134,6 +135,12 @@ public abstract class BaseMapTest extends BaseTest {
}
private void destroy(RMap<?, ?> map) {
if (map instanceof RDestroyable) {
((RDestroyable) map).destroy();
}
}
@Test
public void testGetAllWithStringKeys() {
RMap<String, Integer> map = getMap("getAllStrings");
@ -148,6 +155,8 @@ public abstract class BaseMapTest extends BaseTest {
expectedMap.put("B", 200);
expectedMap.put("C", 300);
assertThat(filtered).isEqualTo(expectedMap);
destroy(map);
}
@Test
@ -166,12 +175,13 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(next).isIn(new AbstractMap.SimpleEntry("A", "1"), new AbstractMap.SimpleEntry("B", "2"));
}
destroy(rmap);
redisson.shutdown();
}
@Test
public void testInteger() {
Map<Integer, Integer> map = getMap("test_int");
RMap<Integer, Integer> map = getMap("test_int");
map.put(1, 2);
map.put(3, 4);
@ -182,11 +192,12 @@ public abstract class BaseMapTest extends BaseTest {
Integer val2 = map.get(3);
assertThat(val2).isEqualTo(4);
destroy(map);
}
@Test
public void testLong() {
Map<Long, Long> map = getMap("test_long");
RMap<Long, Long> map = getMap("test_long");
map.put(1L, 2L);
map.put(3L, 4L);
@ -197,6 +208,7 @@ public abstract class BaseMapTest extends BaseTest {
Long val2 = map.get(3L);
assertThat(val2).isEqualTo(4);
destroy(map);
}
@Test
@ -224,6 +236,7 @@ public abstract class BaseMapTest extends BaseTest {
counter++;
}
assertThat(counter).isEqualTo(size);
destroy(rMap);
}
@Test
@ -257,23 +270,26 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(rmap.entrySet()).containsExactlyElementsOf(map.entrySet());
assertThat(rmap.readAllEntrySet()).containsExactlyElementsOf(map.entrySet());
destroy(rmap);
}
@Test(expected = NullPointerException.class)
public void testNullValue() {
Map<Integer, String> map = getMap("simple12");
RMap<Integer, String> map = getMap("simple12");
destroy(map);
map.put(1, null);
}
@Test(expected = NullPointerException.class)
public void testNullKey() {
Map<Integer, String> map = getMap("simple12");
RMap<Integer, String> map = getMap("simple12");
destroy(map);
map.put(null, "1");
}
@Test
public void testSize() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("3"), new SimpleValue("4"));
@ -293,6 +309,7 @@ public abstract class BaseMapTest extends BaseTest {
map.remove(new SimpleKey("3"));
Assert.assertEquals(3, map.size());
destroy(map);
}
@Test
@ -301,8 +318,10 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertFalse(map.remove(1, 3));
map.put(4, 5);
Assert.assertTrue(map.remove(4, 5));
destroy(map);
}
@Test
public void testFastPutIfAbsent() throws Exception {
RMap<SimpleKey, SimpleValue> map = getMap("simple");
SimpleKey key = new SimpleKey("1");
@ -315,11 +334,12 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue value1 = new SimpleValue("4");
assertThat(map.fastPutIfAbsent(key1, value1)).isTrue();
assertThat(map.get(key1)).isEqualTo(value1);
destroy(map);
}
@Test
public void testPutAll() {
Map<Integer, String> map = getMap("simple");
RMap<Integer, String> map = getMap("simple");
map.put(1, "1");
map.put(2, "2");
map.put(3, "3");
@ -331,6 +351,7 @@ public abstract class BaseMapTest extends BaseTest {
map.putAll(joinMap);
assertThat(map.keySet()).containsOnly(1, 2, 3, 4, 5, 6);
destroy(map);
}
@Test
@ -340,15 +361,16 @@ public abstract class BaseMapTest extends BaseTest {
joinMap.put(i, "" + i);
}
Map<Integer, String> map = getMap("simple");
RMap<Integer, String> map = getMap("simple");
map.putAll(joinMap);
assertThat(map.size()).isEqualTo(joinMap.size());
destroy(map);
}
@Test
public void testPutGet() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("33"), new SimpleValue("44"));
map.put(new SimpleKey("5"), new SimpleValue("6"));
@ -358,11 +380,12 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue val2 = map.get(new SimpleKey("5"));
Assert.assertEquals("6", val2.getValue());
destroy(map);
}
@Test
public void testPutIfAbsent() throws Exception {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
SimpleKey key = new SimpleKey("1");
SimpleValue value = new SimpleValue("2");
map.put(key, value);
@ -373,6 +396,7 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue value1 = new SimpleValue("4");
Assert.assertNull(map.putIfAbsent(key1, value1));
Assert.assertEquals(value1, map.get(key1));
destroy(map);
}
@Test(timeout = 5000)
@ -392,6 +416,7 @@ public abstract class BaseMapTest extends BaseTest {
} catch (Exception e) {
e.printStackTrace();
}
destroy(map);
}
public static class SimpleObjectWithoutDefaultConstructor {
@ -413,7 +438,7 @@ public abstract class BaseMapTest extends BaseTest {
@Test
public void testReplaceOldValueFail() {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.replace(new SimpleKey("1"), new SimpleValue("43"), new SimpleValue("31"));
@ -421,11 +446,12 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("2", val1.getValue());
destroy(map);
}
@Test
public void testReplaceOldValueSuccess() {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.replace(new SimpleKey("1"), new SimpleValue("2"), new SimpleValue("3"));
@ -436,11 +462,12 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("3", val1.getValue());
destroy(map);
}
@Test
public void testReplaceValue() {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
SimpleValue res = map.replace(new SimpleKey("1"), new SimpleValue("3"));
@ -448,12 +475,13 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("3", val1.getValue());
destroy(map);
}
@Test
public void testReplace() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("33"), new SimpleValue("44"));
map.put(new SimpleKey("5"), new SimpleValue("6"));
@ -464,11 +492,12 @@ public abstract class BaseMapTest extends BaseTest {
map.put(new SimpleKey("33"), new SimpleValue("abc"));
SimpleValue val2 = map.get(new SimpleKey("33"));
Assert.assertEquals("abc", val2.getValue());
destroy(map);
}
@Test
public void testContainsValue() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("33"), new SimpleValue("44"));
map.put(new SimpleKey("5"), new SimpleValue("6"));
@ -476,22 +505,24 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertTrue(map.containsValue(new SimpleValue("2")));
Assert.assertFalse(map.containsValue(new SimpleValue("441")));
Assert.assertFalse(map.containsValue(new SimpleKey("5")));
destroy(map);
}
@Test
public void testContainsKey() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("33"), new SimpleValue("44"));
map.put(new SimpleKey("5"), new SimpleValue("6"));
Assert.assertTrue(map.containsKey(new SimpleKey("33")));
Assert.assertFalse(map.containsKey(new SimpleKey("34")));
destroy(map);
}
@Test
public void testRemoveValueFail() {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.remove(new SimpleKey("2"), new SimpleValue("1"));
@ -502,11 +533,12 @@ public abstract class BaseMapTest extends BaseTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("2", val1.getValue());
destroy(map);
}
@Test
public void testRemoveValue() {
ConcurrentMap<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.remove(new SimpleKey("1"), new SimpleValue("2"));
@ -516,11 +548,12 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertNull(val1);
Assert.assertEquals(0, map.size());
destroy(map);
}
@Test
public void testRemoveObject() {
Map<SimpleKey, SimpleValue> map = getMap("simple");
RMap<SimpleKey, SimpleValue> map = getMap("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
map.put(new SimpleKey("33"), new SimpleValue("44"));
map.put(new SimpleKey("5"), new SimpleValue("6"));
@ -530,6 +563,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.remove(new SimpleKey("11"))).isNull();
assertThat(map.size()).isEqualTo(1);
destroy(map);
}
@Test
@ -543,6 +577,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.remove(3)).isEqualTo(5);
assertThat(map.remove(10)).isNull();
assertThat(map.remove(7)).isEqualTo(8);
destroy(map);
}
@Test
@ -556,6 +591,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.fastRemove(1, 3, 7)).isEqualTo(3);
Thread.sleep(1);
assertThat(map.size()).isEqualTo(1);
destroy(map);
}
@Test
@ -576,6 +612,7 @@ public abstract class BaseMapTest extends BaseTest {
}
assertThat(values.size()).isEqualTo(0);
destroy(map);
}
@Test
@ -586,6 +623,7 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertFalse(map.fastPut(1, 3));
assertThat(map.get(1)).isEqualTo(3);
Assert.assertEquals(1, map.size());
destroy(map);
}
@Test
@ -598,6 +636,7 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertEquals(1, map.size());
assertThat(map.get(1)).isEqualTo(3);
destroy(map);
}
@Test
@ -614,6 +653,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map).isEqualTo(testMap);
assertThat(testMap.hashCode()).isEqualTo(map.hashCode());
destroy(map);
}
@Test
@ -623,6 +663,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.fastRemove()).isZero();
assertThat(map.size()).isEqualTo(1);
destroy(map);
}
@Test
@ -635,6 +676,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.keySet("?0")).containsExactly("10", "20", "30");
assertThat(map.keySet("1")).isEmpty();
assertThat(map.keySet("10")).containsExactly("10");
destroy(map);
}
@Test
@ -647,6 +689,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.values("?0")).containsExactly("100", "200", "300");
assertThat(map.values("1")).isEmpty();
assertThat(map.values("10")).containsExactly("100");
destroy(map);
}
@Test
@ -659,6 +702,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.entrySet("?0")).containsExactly(new AbstractMap.SimpleEntry("10", "100"), new AbstractMap.SimpleEntry("20", "200"), new AbstractMap.SimpleEntry("30", "300"));
assertThat(map.entrySet("1")).isEmpty();
assertThat(map.entrySet("10")).containsExactly(new AbstractMap.SimpleEntry("10", "100"));
destroy(map);
}
@Test
@ -671,6 +715,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.readAllKeySet().size()).isEqualTo(3);
Map<SimpleKey, SimpleValue> testMap = new HashMap<>(map);
assertThat(map.readAllKeySet()).containsOnlyElementsOf(testMap.keySet());
destroy(map);
}
@Test
@ -690,6 +735,7 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertEquals(10000, cnt);
assertThat(map).isEmpty();
Assert.assertEquals(0, map.size());
destroy(map);
}
@Test
@ -712,6 +758,7 @@ public abstract class BaseMapTest extends BaseTest {
}
Assert.assertEquals(10000, cnt);
assertThat(map.size()).isEqualTo(cnt - removed);
destroy(map);
}
@Test
@ -731,6 +778,7 @@ public abstract class BaseMapTest extends BaseTest {
Assert.assertEquals(10000, cnt);
assertThat(map).isEmpty();
Assert.assertEquals(0, map.size());
destroy(map);
}
@Test
@ -743,6 +791,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.readAllKeySet().size()).isEqualTo(1000);
Map<SimpleKey, SimpleValue> testMap = new HashMap<>(map);
assertThat(map.readAllKeySet()).containsOnlyElementsOf(testMap.keySet());
destroy(map);
}
@Test
@ -755,6 +804,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.readAllValues().size()).isEqualTo(3);
Map<SimpleKey, SimpleValue> testMap = new HashMap<>(map);
assertThat(map.readAllValues()).containsOnlyElementsOf(testMap.values());
destroy(map);
}
@Test
@ -771,6 +821,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(s).isEqualTo(joinMap);
assertThat(map.size()).isEqualTo(joinMap.size());
destroy(map);
}
@Test
@ -787,6 +838,7 @@ public abstract class BaseMapTest extends BaseTest {
expectedMap.put(2, 200);
expectedMap.put(3, 300);
assertThat(filtered).isEqualTo(expectedMap);
destroy(map);
}
@Test
@ -797,6 +849,7 @@ public abstract class BaseMapTest extends BaseTest {
map.put("1", "1234");
assertThat(map.valueSize("4")).isZero();
assertThat(map.valueSize("1")).isEqualTo(6);
destroy(map);
}
@Test
@ -822,6 +875,7 @@ public abstract class BaseMapTest extends BaseTest {
expectedMap.put(8, 800);
assertThat(filtered.entrySet()).containsExactlyElementsOf(expectedMap.entrySet());
destroy(map);
}
@Test
@ -848,6 +902,7 @@ public abstract class BaseMapTest extends BaseTest {
expectedMap.put(8, 800);
assertThat(filtered.entrySet()).containsExactlyElementsOf(expectedMap.entrySet());
destroy(map);
}
@ -874,6 +929,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(mapStr.addAndGet("1", 12)).isEqualTo(112);
assertThat(mapStr.get("1")).isEqualTo(112);
destroy(map);
}
protected abstract <K, V> RMap<K, V> getMap(String name);
@ -895,6 +951,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.get("0")).isNull();
assertThat(map.get("1")).isEqualTo("11");
assertThat(map.get("0")).isNull(); // This line will never return anything and the test will hang
destroy(map);
}
@Test
@ -908,6 +965,7 @@ public abstract class BaseMapTest extends BaseTest {
Map<String, Integer> expected = new HashMap<>();
expected.put("1", 18);
assertThat(store).isEqualTo(expected);
destroy(map);
}
@ -925,6 +983,7 @@ public abstract class BaseMapTest extends BaseTest {
Map<String, String> expected = new HashMap<>();
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -941,6 +1000,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("2", "22");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -986,6 +1046,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("1", "00");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -1009,6 +1070,7 @@ public abstract class BaseMapTest extends BaseTest {
expected2.put("2", "22");
expected2.put("3", "33");
assertThat(store).isEqualTo(expected2);
destroy(map);
}
@Test
@ -1024,6 +1086,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("1", "11");
expected.put("2", "22");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -1039,6 +1102,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("1", "11");
expected.put("2", "22");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -1057,6 +1121,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("2", "22");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@ -1074,6 +1139,7 @@ public abstract class BaseMapTest extends BaseTest {
expected.put("2", "22");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
destroy(map);
}
@Test
@ -1099,6 +1165,7 @@ public abstract class BaseMapTest extends BaseTest {
assertThat(map.size()).isEqualTo(10);
assertThat(map.get("0")).isEqualTo("00");
assertThat(map.get("5")).isEqualTo("55");
destroy(map);
}
@Test
@ -1117,6 +1184,7 @@ public abstract class BaseMapTest extends BaseTest {
for (int i = 0; i < 100; i++) {
assertThat(map.containsKey("" + i)).isTrue();
}
destroy(map);
}
protected <K, V> MapWriter<K, V> createMapWriter(Map<K, V> map) {
@ -1185,6 +1253,7 @@ public abstract class BaseMapTest extends BaseTest {
expectedMap.put("3", "33");
assertThat(s).isEqualTo(expectedMap);
assertThat(map.size()).isEqualTo(4);
destroy(map);
}
}

77
redisson/src/test/java/org/redisson/RedissonMapCacheTest.java
Unescape Escape View File

@ -10,7 +10,6 @@ import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
@ -32,9 +31,24 @@ import org.redisson.client.codec.Codec;
import org.redisson.client.codec.DoubleCodec;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.eviction.EvictionScheduler;
import mockit.Deencapsulation;
public class RedissonMapCacheTest extends BaseMapTest {
@Test
public void testDestroy() {
RMapCache<String, String> cache = redisson.getMapCache("test");
EvictionScheduler evictionScheduler = ((Redisson)redisson).getEvictionScheduler();
Map<?, ?> map = Deencapsulation.getField(evictionScheduler, "tasks");
assertThat(map.isEmpty()).isFalse();
cache.destroy();
System.out.println("keys: " + map.keySet());
assertThat(map.isEmpty()).isTrue();
}
@Override
protected <K, V> RMap<K, V> getMap(String name) {
return redisson.getMapCache(name);
@ -68,6 +82,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.put("5", "6", 20, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);
assertThat(map.remainTimeToLive("1")).isLessThan(9900);
map.destroy();
}
@Test
@ -83,6 +98,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
expected.put("1", "11");
expected.put("2", "22");
assertThat(store).isEqualTo(expected);
map.destroy();
}
@Test
@ -99,6 +115,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
expected.put("2", "22");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
map.destroy();
}
@Test
@ -114,6 +131,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
expected.put("1", "11");
expected.put("2", "22");
assertThat(store).isEqualTo(expected);
map.destroy();
}
@Test
@ -130,6 +148,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
expected.put("2", "22");
expected.put("3", "33");
assertThat(store).isEqualTo(expected);
map.destroy();
}
@Test
@ -277,6 +296,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.size()).isEqualTo(maxSize.get());
assertThat(map.keySet()).containsExactly("58", "59", "60", "61", "62", "63");
map.destroy();
}
@ -285,6 +305,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
final RMapCache<String, String> map = redisson.getMapCache("testRMapCacheValues");
map.put("1234", "5678", 0, TimeUnit.MINUTES, 60, TimeUnit.MINUTES);
assertThat(map.values()).containsOnly("5678");
map.destroy();
}
@Test
@ -306,6 +327,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Map<Integer, Integer> filteredAgain = map.getAll(new HashSet<Integer>(Arrays.asList(2, 3, 5)));
Assert.assertTrue(filteredAgain.isEmpty());
map.destroy();
}
@Test
@ -322,6 +344,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
expectedMap.put("B", 200);
expectedMap.put("C", 300);
Assert.assertEquals(expectedMap, filtered);
map.destroy();
}
@Test
@ -336,6 +359,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(1000);
assertThat(cache.keySet()).containsOnly("0", "2", "3");
cache.destroy();
}
@Test
@ -348,6 +372,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(500);
Assert.assertEquals(0, cache.size());
cache.destroy();
}
@Test
@ -360,6 +385,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(500);
Assert.assertEquals(0, cache.size());
cache.destroy();
}
@Test
@ -374,6 +400,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(500);
Assert.assertEquals(1, cache.size());
cache.destroy();
}
@Test
@ -389,6 +416,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.entrySet()).containsAll(expected.entrySet());
assertThat(map).hasSize(3);
map.destroy();
}
@Test
@ -406,6 +434,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Assert.assertFalse(map.keySet().contains(new SimpleKey("33")));
Assert.assertFalse(map.keySet().contains(new SimpleKey("44")));
Assert.assertTrue(map.keySet().contains(new SimpleKey("1")));
map.destroy();
}
@Test
@ -423,6 +452,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Assert.assertFalse(map.values().contains(new SimpleValue("44")));
Assert.assertFalse(map.values().contains(new SimpleValue("33")));
Assert.assertTrue(map.values().contains(new SimpleValue("2")));
map.destroy();
}
@Test
@ -435,6 +465,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.keySet("?0")).containsExactly("10", "20", "30");
assertThat(map.keySet("1")).isEmpty();
assertThat(map.keySet("10")).containsExactly("10");
map.destroy();
}
@Test
@ -447,6 +478,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.values("?0")).containsExactly("100", "200", "300");
assertThat(map.values("1")).isEmpty();
assertThat(map.values("10")).containsExactly("100");
map.destroy();
}
@Test
@ -459,6 +491,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.entrySet("?0")).containsExactly(new AbstractMap.SimpleEntry("10", "100"), new AbstractMap.SimpleEntry("20", "200"), new AbstractMap.SimpleEntry("30", "300"));
assertThat(map.entrySet("1")).isEmpty();
assertThat(map.entrySet("10")).containsExactly(new AbstractMap.SimpleEntry("10", "100"));
map.destroy();
}
@ -474,6 +507,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(1000);
Assert.assertFalse(map.containsValue(new SimpleValue("44")));
map.destroy();
}
@Test
@ -487,6 +521,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(1000);
Assert.assertFalse(map.containsKey(new SimpleKey("33")));
map.destroy();
}
@Test
@ -509,11 +544,12 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(map.remove(new SimpleKey("3"), new SimpleValue("4"))).isFalse();
assertThat(map.get(new SimpleKey("3"))).isNull();
map.destroy();
}
@Test
public void testRemoveValueFail() {
ConcurrentMap<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
RMapCache<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.remove(new SimpleKey("2"), new SimpleValue("1"));
@ -524,12 +560,13 @@ public class RedissonMapCacheTest extends BaseMapTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("2", val1.getValue());
map.destroy();
}
@Test
public void testReplaceOldValueFail() {
ConcurrentMap<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
RMapCache<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.replace(new SimpleKey("1"), new SimpleValue("43"), new SimpleValue("31"));
@ -537,11 +574,12 @@ public class RedissonMapCacheTest extends BaseMapTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("2", val1.getValue());
map.destroy();
}
@Test
public void testReplaceOldValueSuccess() {
ConcurrentMap<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
RMapCache<SimpleKey, SimpleValue> map = redisson.getMapCache("simple");
map.put(new SimpleKey("1"), new SimpleValue("2"));
boolean res = map.replace(new SimpleKey("1"), new SimpleValue("2"), new SimpleValue("3"));
@ -552,6 +590,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
Assert.assertEquals("3", val1.getValue());
map.destroy();
}
@Test
@ -566,6 +605,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
SimpleValue val1 = map.get(new SimpleKey("1"));
assertThat(val1).isNull();
map.destroy();
}
@Test
@ -582,6 +622,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(11000);
Assert.assertEquals(0, map.size());
map.destroy();
}
@ -605,6 +646,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(1000);
Assert.assertNull(map.get(new SimpleKey("33")));
map.destroy();
}
@Test
@ -632,6 +674,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
SimpleValue value1 = new SimpleValue("4");
Assert.assertNull(map.putIfAbsent(key1, value1, 2, TimeUnit.SECONDS));
Assert.assertEquals(value1, map.get(key1));
map.destroy();
}
@Test
@ -655,6 +698,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(500);
assertThat(map.fastPutIfAbsent(key2, new SimpleValue("32"))).isTrue();
assertThat(map.get(key2)).isEqualTo(new SimpleValue("32"));
map.destroy();
}
@ -671,6 +715,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
checkCreatedListener(map, 4, 1, () -> map.fastPutIfAbsent(4, 1));
checkCreatedListener(map, 15, 2, () -> map.fastPutIfAbsent(15, 2, 2, TimeUnit.SECONDS));
checkCreatedListener(map, 5, 0, () -> map.addAndGet(5, 0));
map.destroy();
}
private void checkCreatedListener(RMapCache<Integer, Integer> map, Integer key, Integer value, Runnable runnable) {
@ -692,6 +737,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
await().atMost(Duration.ONE_SECOND).untilTrue(ref);
map.removeListener(createListener1);
map.destroy();
}
@Test
@ -716,6 +762,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.put(5, 1);
checkUpdatedListener(map, 5, 4, 1, () -> map.addAndGet(5, 3));
map.destroy();
}
@ -727,6 +774,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
checkExpiredListener(map, 13, 2, () -> map.fastPut(13, 2, 2, TimeUnit.SECONDS));
checkExpiredListener(map, 14, 2, () -> map.putIfAbsent(14, 2, 2, TimeUnit.SECONDS));
checkExpiredListener(map, 15, 2, () -> map.fastPutIfAbsent(15, 2, 2, TimeUnit.SECONDS));
map.destroy();
}
private void checkExpiredListener(RMapCache<Integer, Integer> map, Integer key, Integer value, Runnable runnable) {
@ -785,6 +833,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.put(2, 1);
checkRemovedListener(map, 2, 1, () -> map.fastRemove(2));
map.destroy();
}
private void checkRemovedListener(RMapCache<Integer, Integer> map, Integer key, Integer value, Runnable runnable) {
@ -887,6 +936,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.clear();
map.destroy();
}
protected void testTTLExpiration(Consumer<RMapCache<String, Integer>> callback) throws InterruptedException {
@ -914,23 +964,25 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.clear();
map.destroy();
}
@Test
public void testExpireOverwrite() throws InterruptedException, ExecutionException {
RMapCache<String, Integer> set = redisson.getMapCache("simple");
set.put("123", 3, 1, TimeUnit.SECONDS);
RMapCache<String, Integer> map = redisson.getMapCache("simple");
map.put("123", 3, 1, TimeUnit.SECONDS);
Thread.sleep(800);
set.put("123", 3, 1, TimeUnit.SECONDS);
map.put("123", 3, 1, TimeUnit.SECONDS);
Thread.sleep(800);
Assert.assertEquals(3, (int)set.get("123"));
Assert.assertEquals(3, (int)map.get("123"));
Thread.sleep(200);
Assert.assertFalse(set.containsKey("123"));
Assert.assertFalse(map.containsKey("123"));
map.destroy();
}
@Test
@ -938,6 +990,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
final RMapCache<String, String> map = redisson.getMapCache("testRMapCacheValues");
map.put("1234", "5678", 1, TimeUnit.MINUTES, 60, TimeUnit.MINUTES);
assertThat(map.values()).containsOnly("5678");
map.destroy();
}
@Test
@ -948,6 +1001,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
map.put(3, "43");
assertThat(map.readAllEntrySet()).isEqualTo(map.entrySet());
map.destroy();
}
@Test
@ -955,6 +1009,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
final RMapCache<String, String> map = redisson.getMapCache("testRMapCacheAllValues");
map.put("1234", "5678", 1, TimeUnit.MINUTES, 60, TimeUnit.MINUTES);
assertThat(map.readAllValues()).containsOnly("5678");
map.destroy();
}
@Test
@ -964,6 +1019,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
assertThat(mapCache.addAndGet("4", 1L)).isEqualTo(1L);
assertThat(mapCache.putIfAbsent("4", 0L)).isEqualTo(1L);
Assert.assertEquals(1L, mapCache.get("4"));
mapCache.destroy();
mapCache = redisson.getMapCache("test_put_if_absent_1", LongCodec.INSTANCE);
mapCache.putIfAbsent("4", 0L);
mapCache.addAndGet("4", 1L);
@ -978,6 +1034,8 @@ public class RedissonMapCacheTest extends BaseMapTest {
mapCache1.putIfAbsent("4", 1.23, 10000L, TimeUnit.SECONDS);
mapCache1.addAndGet("4", 1D);
Assert.assertEquals(2.23, mapCache1.get("4"));
mapCache.destroy();
mapCache1.destroy();
}
@ -1003,6 +1061,7 @@ public class RedissonMapCacheTest extends BaseMapTest {
Thread.sleep(550);
assertThat(map.fastPutIfAbsent(key, new SimpleValue("5"), 1, TimeUnit.SECONDS, 500, TimeUnit.MILLISECONDS)).isTrue();
map.destroy();
}
}

44
redisson/src/test/java/org/redisson/RedissonSetCacheTest.java
Unescape Escape View File

@ -16,7 +16,9 @@ import java.util.concurrent.TimeUnit;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RSetCache;
import org.redisson.codec.MsgPackJacksonCodec;
import org.redisson.eviction.EvictionScheduler;
import mockit.Deencapsulation;
public class RedissonSetCacheTest extends BaseTest {
@ -34,6 +36,17 @@ public class RedissonSetCacheTest extends BaseTest {
}
@Test
public void testDestroy() {
RSetCache<String> cache = redisson.getSetCache("test");
EvictionScheduler evictionScheduler = ((Redisson)redisson).getEvictionScheduler();
Map<?, ?> map = Deencapsulation.getField(evictionScheduler, "tasks");
assertThat(map.isEmpty()).isFalse();
cache.destroy();
assertThat(map.isEmpty()).isTrue();
}
@Test
public void testRemoveAll() {
RSetCache<Integer> set = redisson.getSetCache("set");
@ -44,6 +57,7 @@ public class RedissonSetCacheTest extends BaseTest {
assertThat(set.removeAll(Arrays.asList(1, 3))).isTrue();
assertThat(set.removeAll(Arrays.asList(1, 3))).isFalse();
assertThat(set).containsOnly(2);
set.destroy();
}
@Test
@ -53,12 +67,14 @@ public class RedissonSetCacheTest extends BaseTest {
set.add(1, 1, TimeUnit.SECONDS);
assertThat(set.delete()).isTrue();
assertThat(set.delete()).isFalse();
set.destroy();
}
@Test
public void testEmptyReadAll() {
RSetCache<Integer> set = redisson.getSetCache("set");
assertThat(set.readAll()).isEmpty();
set.destroy();
}
@Test
@ -72,6 +88,7 @@ public class RedissonSetCacheTest extends BaseTest {
map.remove(0);
set.add(map);
set.iterator().next();
set.destroy();
}
@Test
@ -81,6 +98,7 @@ public class RedissonSetCacheTest extends BaseTest {
RSetCache<SimpleBean> set = redisson.getSetCache("simple");
assertThat(set.add(sb)).isTrue();
Assert.assertEquals(sb.getLng(), set.iterator().next().getLng());
set.destroy();
}
@Test
@ -95,6 +113,7 @@ public class RedissonSetCacheTest extends BaseTest {
assertThat(set).doesNotContain("123");
assertThat(set.add("123", 1, TimeUnit.SECONDS)).isTrue();
set.destroy();
}
@ -106,6 +125,7 @@ public class RedissonSetCacheTest extends BaseTest {
assertThat(set.add("123", 3, TimeUnit.SECONDS)).isFalse();
Thread.sleep(2000);
assertThat(set.contains("123")).isTrue();
set.destroy();
}
@Test
@ -120,6 +140,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(1000);
Assert.assertFalse(set.contains("4341"));
set.destroy();
}
@Test
@ -136,6 +157,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(1000);
assertThat(set.contains("123")).isTrue();
set.destroy();
}
@ -154,6 +176,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(300);
assertThat(set.contains("123")).isTrue();
set.destroy();
}
@Test
@ -174,6 +197,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertFalse(set.contains(3));
assertThat(set).containsOnly(7);
Assert.assertEquals(1, set.size());
set.destroy();
}
@Test
@ -207,6 +231,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertFalse(set.contains("4"));
Assert.assertFalse(set.contains("5"));
set.destroy();
}
@Test
@ -222,6 +247,7 @@ public class RedissonSetCacheTest extends BaseTest {
}
checkIterator(set, setCopy);
set.destroy();
}
private void checkIterator(Set<Long> set, Set<Long> setCopy) {
@ -247,6 +273,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(500);
assertThat(set).containsOnly(1, 2);
Assert.assertEquals(2, set.size());
set.destroy();
}
@Test
@ -266,6 +293,7 @@ public class RedissonSetCacheTest extends BaseTest {
}
Assert.assertEquals(10000, cnt);
Assert.assertEquals(0, set.size());
set.destroy();
}
@Test
@ -278,6 +306,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertTrue(set.containsAll(Collections.emptyList()));
Assert.assertTrue(set.containsAll(Arrays.asList(30, 11)));
Assert.assertFalse(set.containsAll(Arrays.asList(30, 711, 11)));
set.destroy();
}
@Test
@ -295,6 +324,7 @@ public class RedissonSetCacheTest extends BaseTest {
String[] strs = set.toArray(new String[0]);
assertThat(strs).containsOnly("1", "4", "5", "3");
set.destroy();
}
@Test
@ -312,6 +342,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertFalse(set.contains(new TestObject("2", "3")));
Assert.assertTrue(set.contains(new TestObject("1", "2")));
Assert.assertFalse(set.contains(new TestObject("1", "9")));
set.destroy();
}
@Test
@ -325,6 +356,7 @@ public class RedissonSetCacheTest extends BaseTest {
set.add(new TestObject("5", "6"));
Assert.assertEquals(4, set.size());
set.destroy();
}
@Test
@ -339,6 +371,7 @@ public class RedissonSetCacheTest extends BaseTest {
set.add(5);
Assert.assertEquals(5, set.size());
set.destroy();
}
@Test
@ -347,6 +380,7 @@ public class RedissonSetCacheTest extends BaseTest {
set.add(1, 1, TimeUnit.SECONDS);
Thread.sleep(1005);
assertThat(set.readAll()).isEmpty();
set.destroy();
}
@Test
@ -359,6 +393,7 @@ public class RedissonSetCacheTest extends BaseTest {
set.add(5);
assertThat(set.readAll()).containsOnly(1, 2, 3, 4, 5);
set.destroy();
}
@Test
@ -372,6 +407,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertTrue(set.retainAll(Collections.<Integer>emptyList()));
Assert.assertEquals(0, set.size());
set.destroy();
}
@Test
@ -382,6 +418,7 @@ public class RedissonSetCacheTest extends BaseTest {
Assert.assertFalse(set.retainAll(Arrays.asList(1, 2))); // nothing changed
assertThat(set).containsOnly(1, 2);
set.destroy();
}
@Test
@ -396,6 +433,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(1000);
assertThat(cache).contains("0", "2", "3");
cache.destroy();
}
@Test
@ -408,6 +446,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(500);
Assert.assertEquals(0, cache.size());
cache.destroy();
}
@Test
@ -420,6 +459,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(500);
Assert.assertEquals(0, cache.size());
cache.destroy();
}
@Test
@ -434,6 +474,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(500);
Assert.assertEquals(1, cache.size());
cache.destroy();
}
@Test
@ -446,6 +487,7 @@ public class RedissonSetCacheTest extends BaseTest {
Thread.sleep(11000);
Assert.assertEquals(0, cache.size());
cache.destroy();
}

Write Preview
Loading…
Cancel
Save