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

refactoring

Browse Source
pull/5361/head
Nikita Koksharov 1 year ago
parent d44d6775bf
commit 266ccd23ec
11 changed files with 182 additions and 202 deletions
Show Stats Download Patch File Download Diff File

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

@ -3,6 +3,7 @@ package org.redisson;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.redisson.api.*;
import org.redisson.api.map.MapLoader;
import org.redisson.api.map.MapLoaderAsync;
@ -615,23 +616,22 @@ public abstract class BaseMapTest extends BaseTest {
}
@Test
@Timeout(5)
public void testDeserializationErrorReturnsErrorImmediately() {
Assertions.assertTimeout(Duration.ofSeconds(5), () -> {
RMap<String, SimpleObjectWithoutDefaultConstructor> map = getMap("deserializationFailure", new JsonJacksonCodec());
Assumptions.assumeTrue(!(map instanceof RLocalCachedMap));
SimpleObjectWithoutDefaultConstructor object = new SimpleObjectWithoutDefaultConstructor("test-val");
assertThat(object.getTestField()).isEqualTo("test-val");
map.put("test-key", object);
try {
map.get("test-key");
Assertions.fail("Expected exception from map.get() call");
} catch (Exception e) {
e.printStackTrace();
}
destroy(map);
});
RMap<String, SimpleObjectWithoutDefaultConstructor> map = getMap("deserializationFailure", new JsonJacksonCodec());
Assumptions.assumeTrue(!(map instanceof RLocalCachedMap));
SimpleObjectWithoutDefaultConstructor object = new SimpleObjectWithoutDefaultConstructor("test-val");
assertThat(object.getTestField()).isEqualTo("test-val");
map.put("test-key", object);
try {
map.get("test-key");
Assertions.fail("Expected exception from map.get() call");
} catch (Exception e) {
e.printStackTrace();
}
destroy(map);
}
public static class SimpleObjectWithoutDefaultConstructor {

57
redisson/src/test/java/org/redisson/RedissonBatchTest.java
Unescape Escape View File

@ -5,13 +5,16 @@ import org.assertj.core.api.Assertions;
import org.awaitility.Awaitility;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.redisson.ClusterRunner.ClusterProcesses;
import org.redisson.RedisRunner.FailedToStartRedisException;
import org.redisson.api.*;
import org.redisson.api.BatchOptions.ExecutionMode;
import org.redisson.client.*;
import org.redisson.client.RedisClient;
import org.redisson.client.RedisClientConfig;
import org.redisson.client.RedisConnection;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.cluster.ClusterNodeInfo;
@ -237,26 +240,25 @@ public class RedissonBatchTest extends BaseTest {
@ParameterizedTest
@MethodSource("data")
@Timeout(20)
public void testPerformance() {
org.junit.jupiter.api.Assertions.assertTimeout(Duration.ofSeconds(20), () -> {
RMap<String, String> map = redisson.getMap("map");
Map<String, String> m = new HashMap<String, String>();
for (int j = 0; j < 1000; j++) {
m.put("" + j, "" + j);
}
map.putAll(m);
for (int i = 0; i < 10000; i++) {
RBatch rBatch = redisson.createBatch();
RMapAsync<String, String> m1 = rBatch.getMap("map");
m1.getAllAsync(m.keySet());
try {
rBatch.execute();
} catch (Exception e) {
e.printStackTrace();
}
RMap<String, String> map = redisson.getMap("map");
Map<String, String> m = new HashMap<String, String>();
for (int j = 0; j < 1000; j++) {
m.put("" + j, "" + j);
}
map.putAll(m);
for (int i = 0; i < 10000; i++) {
RBatch rBatch = redisson.createBatch();
RMapAsync<String, String> m1 = rBatch.getMap("map");
m1.getAllAsync(m.keySet());
try {
rBatch.execute();
} catch (Exception e) {
e.printStackTrace();
}
});
}
}
@Test
@ -670,17 +672,16 @@ public class RedissonBatchTest extends BaseTest {
@ParameterizedTest
@MethodSource("data")
@Timeout(1)
public void testShutdownTimeout(BatchOptions batchOptions) {
org.junit.jupiter.api.Assertions.assertTimeout(Duration.ofMillis(500), () -> {
RedissonClient redisson = createInstance();
RedissonClient redisson = createInstance();
RBatch batch = redisson.createBatch(batchOptions);
for (int i = 0; i < 10; i++) {
RFuture<Void> f = batch.getBucket("test").setAsync(123);
}
batch.execute();
redisson.shutdown();
});
RBatch batch = redisson.createBatch(batchOptions);
for (int i = 0; i < 10; i++) {
RFuture<Void> f = batch.getBucket("test").setAsync(123);
}
batch.execute();
redisson.shutdown();
}
@ParameterizedTest

11
redisson/src/test/java/org/redisson/RedissonBlockingDequeReactiveTest.java
Unescape Escape View File

@ -1,8 +1,8 @@
package org.redisson;
import org.awaitility.Awaitility;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import org.redisson.api.RBlockingDequeReactive;
@ -59,12 +59,11 @@ public class RedissonBlockingDequeReactiveTest extends BaseReactiveTest {
}
@Test
@Timeout(3)
public void testShortPoll() {
Assertions.assertTimeout(Duration.ofSeconds(3), () -> {
RBlockingDequeReactive<Integer> queue = redisson.getBlockingDeque("queue:pollany");
sync(queue.pollLast(500, TimeUnit.MILLISECONDS));
sync(queue.pollFirst(10, TimeUnit.MICROSECONDS));
});
RBlockingDequeReactive<Integer> queue = redisson.getBlockingDeque("queue:pollany");
sync(queue.pollLast(500, TimeUnit.MILLISECONDS));
sync(queue.pollFirst(10, TimeUnit.MICROSECONDS));
}
@Test

10
redisson/src/test/java/org/redisson/RedissonBlockingDequeTest.java
Unescape Escape View File

@ -4,6 +4,7 @@ import org.awaitility.Awaitility;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.queue.DequeMoveArgs;
@ -76,12 +77,11 @@ public class RedissonBlockingDequeTest extends BaseTest {
}
@Test
@Timeout(3)
public void testShortPoll() {
Assertions.assertTimeout(Duration.ofSeconds(3), () -> {
RBlockingDeque<Integer> queue = redisson.getBlockingDeque("queue:pollany");
queue.pollLastAsync(500, TimeUnit.MILLISECONDS);
queue.pollFirstAsync(10, TimeUnit.MICROSECONDS);
});
RBlockingDeque<Integer> queue = redisson.getBlockingDeque("queue:pollany");
queue.pollLastAsync(500, TimeUnit.MILLISECONDS);
queue.pollFirstAsync(10, TimeUnit.MICROSECONDS);
}
@Test

13
redisson/src/test/java/org/redisson/RedissonBlockingQueueTest.java
Unescape Escape View File

@ -4,6 +4,7 @@ import org.awaitility.Awaitility;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.redisson.ClusterRunner.ClusterProcesses;
import org.redisson.RedisRunner.RedisProcess;
import org.redisson.api.Entry;
@ -24,7 +25,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await;
import static org.redisson.RedisRunner.KEYSPACE_EVENTS_OPTIONS.l;
public class RedissonBlockingQueueTest extends RedissonQueueTest {
@ -71,12 +71,11 @@ public class RedissonBlockingQueueTest extends RedissonQueueTest {
}
@Test
public void testShortPoll() {
Assertions.assertTimeout(Duration.ofSeconds(3), () -> {
RBlockingQueue<Integer> queue = getQueue();
queue.poll(500, TimeUnit.MILLISECONDS);
queue.poll(10, TimeUnit.MICROSECONDS);
});
@Timeout(3)
public void testShortPoll() throws InterruptedException {
RBlockingQueue<Integer> queue = getQueue();
queue.poll(500, TimeUnit.MILLISECONDS);
queue.poll(10, TimeUnit.MICROSECONDS);
}
@Test

79
redisson/src/test/java/org/redisson/RedissonLiveObjectServiceTest.java
Unescape Escape View File

@ -2,6 +2,7 @@ package org.redisson;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.redisson.api.*;
import org.redisson.api.annotation.*;
import org.redisson.api.condition.Conditions;
@ -2371,53 +2372,51 @@ public class RedissonLiveObjectServiceTest extends BaseTest {
}
@Test
@Timeout(10)
public void testBatchedMerge() {
Assertions.assertTimeout(Duration.ofSeconds(10), () -> {
RLiveObjectService s = redisson.getLiveObjectService();
List<TestREntity> objects = new ArrayList<>();
int objectsAmount = 100000;
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = new TestREntity();
e.setName("" + i);
e.setValue("value" + i);
objects.add(e);
}
List<Object> attachedObjects = s.merge(objects.toArray());
assertThat(attachedObjects).hasSize(objectsAmount);
objects.clear();
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = (TestREntity) attachedObjects.get(i);
e.setName("" + i);
e.setValue("value" + i*1000);
objects.add(e);
}
List<Object> attachedObjects2 = s.merge(objects.toArray());
assertThat(attachedObjects2).hasSize(objectsAmount);
RLiveObjectService s = redisson.getLiveObjectService();
assertThat(redisson.getKeys().count()).isEqualTo(objectsAmount);
});
List<TestREntity> objects = new ArrayList<>();
int objectsAmount = 100000;
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = new TestREntity();
e.setName("" + i);
e.setValue("value" + i);
objects.add(e);
}
List<Object> attachedObjects = s.merge(objects.toArray());
assertThat(attachedObjects).hasSize(objectsAmount);
objects.clear();
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = (TestREntity) attachedObjects.get(i);
e.setName("" + i);
e.setValue("value" + i*1000);
objects.add(e);
}
List<Object> attachedObjects2 = s.merge(objects.toArray());
assertThat(attachedObjects2).hasSize(objectsAmount);
assertThat(redisson.getKeys().count()).isEqualTo(objectsAmount);
}
@Test
@Timeout(40)
public void testBatchedPersist() {
Assertions.assertTimeout(Duration.ofSeconds(40), () -> {
RLiveObjectService s = redisson.getLiveObjectService();
List<TestREntity> objects = new ArrayList<>();
int objectsAmount = 1000000;
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = new TestREntity();
e.setName("" + i);
e.setValue("value" + i);
objects.add(e);
}
List<Object> attachedObjects = s.persist(objects.toArray());
assertThat(attachedObjects).hasSize(objectsAmount);
RLiveObjectService s = redisson.getLiveObjectService();
assertThat(redisson.getKeys().count()).isEqualTo(objectsAmount);
});
List<TestREntity> objects = new ArrayList<>();
int objectsAmount = 1000000;
for (int i = 0; i < objectsAmount; i++) {
TestREntity e = new TestREntity();
e.setName("" + i);
e.setValue("value" + i);
objects.add(e);
}
List<Object> attachedObjects = s.persist(objects.toArray());
assertThat(attachedObjects).hasSize(objectsAmount);
assertThat(redisson.getKeys().count()).isEqualTo(objectsAmount);
}
@Test

18
redisson/src/test/java/org/redisson/RedissonPriorityBlockingDequeTest.java
Unescape Escape View File

@ -1,24 +1,22 @@
package org.redisson;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.redisson.api.RBlockingDeque;
import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.redisson.api.RBlockingDeque;
import static org.assertj.core.api.Assertions.assertThat;
public class RedissonPriorityBlockingDequeTest extends BaseTest {
@Test
@Timeout(3)
public void testShortPoll() {
Assertions.assertTimeout(Duration.ofSeconds(3), () -> {
RBlockingDeque<Integer> queue = redisson.getPriorityBlockingDeque("queue:pollany");
queue.pollLastAsync(500, TimeUnit.MILLISECONDS);
queue.pollFirstAsync(10, TimeUnit.MICROSECONDS);
});
RBlockingDeque<Integer> queue = redisson.getPriorityBlockingDeque("queue:pollany");
queue.pollLastAsync(500, TimeUnit.MILLISECONDS);
queue.pollFirstAsync(10, TimeUnit.MICROSECONDS);
}
@Test

22
redisson/src/test/java/org/redisson/RedissonRateLimiterTest.java
Unescape Escape View File

@ -1,8 +1,11 @@
package org.redisson;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.redisson.api.*;
import org.junit.jupiter.api.Timeout;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RScoredSortedSet;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import java.time.Duration;
import java.util.ArrayList;
@ -162,15 +165,14 @@ public class RedissonRateLimiterTest extends BaseTest {
@Test
@Timeout(2)
public void testTryAcquire() {
Assertions.assertTimeout(Duration.ofMillis(1500), () -> {
RRateLimiter rr = redisson.getRateLimiter("acquire");
assertThat(rr.trySetRate(RateType.OVERALL, 1, 5, RateIntervalUnit.SECONDS)).isTrue();
assertThat(rr.tryAcquire(1, 1, TimeUnit.SECONDS)).isTrue();
assertThat(rr.tryAcquire(1, 1, TimeUnit.SECONDS)).isFalse();
assertThat(rr.tryAcquire()).isFalse();
});
RRateLimiter rr = redisson.getRateLimiter("acquire");
assertThat(rr.trySetRate(RateType.OVERALL, 1, 5, RateIntervalUnit.SECONDS)).isTrue();
assertThat(rr.tryAcquire(1, 1, TimeUnit.SECONDS)).isTrue();
assertThat(rr.tryAcquire(1, 1, TimeUnit.SECONDS)).isFalse();
assertThat(rr.tryAcquire()).isFalse();
}
@Test

51
redisson/src/test/java/org/redisson/executor/RedissonScheduledExecutorServiceTest.java
Unescape Escape View File

@ -4,10 +4,7 @@ import mockit.Invocation;
import mockit.Mock;
import mockit.MockUp;
import org.joor.Reflect;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.*;
import org.redisson.BaseTest;
import org.redisson.Redisson;
import org.redisson.RedissonExecutorService;
@ -258,24 +255,23 @@ public class RedissonScheduledExecutorServiceTest extends BaseTest {
}
@Test
public void testTaskResume() {
Assertions.assertTimeout(Duration.ofSeconds(7), () -> {
RScheduledExecutorService executor = redisson.getExecutorService("test");
ScheduledFuture<Long> future1 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
ScheduledFuture<Long> future2 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
ScheduledFuture<Long> future3 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
@Timeout(7)
public void testTaskResume() throws ExecutionException, InterruptedException {
RScheduledExecutorService executor = redisson.getExecutorService("test");
ScheduledFuture<Long> future1 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
ScheduledFuture<Long> future2 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
ScheduledFuture<Long> future3 = executor.schedule(new ScheduledCallableTask(), 5, TimeUnit.SECONDS);
node.shutdown();
node.shutdown();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(redisson.getConfig());
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(redisson.getConfig());
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
assertThat(future1.get()).isEqualTo(100);
assertThat(future2.get()).isEqualTo(100);
assertThat(future3.get()).isEqualTo(100);
});
assertThat(future1.get()).isEqualTo(100);
assertThat(future2.get()).isEqualTo(100);
assertThat(future3.get()).isEqualTo(100);
}
@Test
@ -442,15 +438,14 @@ public class RedissonScheduledExecutorServiceTest extends BaseTest {
}
@Test
public void testCancel2() {
Assertions.assertTimeout(Duration.ofSeconds(15), () -> {
RScheduledExecutorService e = redisson.getExecutorService("myExecutor");
e.registerWorkers(WorkerOptions.defaults());
String taskId = redisson.getExecutorService("myExecutor").schedule(new RunnableTask2(), 2000, TimeUnit.MILLISECONDS).getTaskId();
Thread.sleep(5500);
assertThat(e.cancelTask(taskId)).isFalse();
});
@Timeout(15)
public void testCancel2() throws InterruptedException {
RScheduledExecutorService e = redisson.getExecutorService("myExecutor");
e.registerWorkers(WorkerOptions.defaults());
String taskId = redisson.getExecutorService("myExecutor").schedule(new RunnableTask2(), 2000, TimeUnit.MILLISECONDS).getTaskId();
Thread.sleep(5500);
assertThat(e.cancelTask(taskId)).isFalse();
}
@Test

79
redisson/src/test/java/org/redisson/rx/RedissonBatchRxTest.java
Unescape Escape View File

@ -1,23 +1,12 @@
package org.redisson.rx;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Maybe;
import io.reactivex.rxjava3.core.Single;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.redisson.BaseTest;
@ -26,25 +15,25 @@ import org.redisson.ClusterRunner.ClusterProcesses;
import org.redisson.RedisRunner;
import org.redisson.RedisRunner.FailedToStartRedisException;
import org.redisson.Redisson;
import org.redisson.api.BatchOptions;
import org.redisson.api.*;
import org.redisson.api.BatchOptions.ExecutionMode;
import org.redisson.api.BatchResult;
import org.redisson.api.RBatchRx;
import org.redisson.api.RBucketRx;
import org.redisson.api.RListRx;
import org.redisson.api.RMapCacheRx;
import org.redisson.api.RMapRx;
import org.redisson.api.RScoredSortedSetRx;
import org.redisson.api.RScript;
import org.redisson.api.RScript.Mode;
import org.redisson.api.RedissonRxClient;
import org.redisson.client.RedisException;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Maybe;
import io.reactivex.rxjava3.core.Single;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import static org.assertj.core.api.Assertions.assertThat;
public class RedissonBatchRxTest extends BaseRxTest {
@ -98,26 +87,26 @@ public class RedissonBatchRxTest extends BaseRxTest {
@ParameterizedTest
@MethodSource("data")
@Timeout(21)
public void testPerformance(BatchOptions batchOptions) {
Assertions.assertTimeout(Duration.ofSeconds(21), () -> {
RMapRx<String, String> map = redisson.getMap("map");
Map<String, String> m = new HashMap<String, String>();
for (int j = 0; j < 1000; j++) {
m.put("" + j, "" + j);
}
sync(map.putAll(m));
for (int i = 0; i < 10000; i++) {
RBatchRx batch = redisson.createBatch(batchOptions);
RMapRx<String, String> m1 = batch.getMap("map");
Single<Map<String, String>> f = m1.getAll(m.keySet());
sync(batch.execute());
assertThat(sync(f)).hasSize(1000);
}
});
RMapRx<String, String> map = redisson.getMap("map");
Map<String, String> m = new HashMap<String, String>();
for (int j = 0; j < 1000; j++) {
m.put("" + j, "" + j);
}
sync(map.putAll(m));
for (int i = 0; i < 10000; i++) {
RBatchRx batch = redisson.createBatch(batchOptions);
RMapRx<String, String> m1 = batch.getMap("map");
Single<Map<String, String>> f = m1.getAll(m.keySet());
sync(batch.execute());
assertThat(sync(f)).hasSize(1000);
}
}
@Test
@Timeout(20)
public void testConnectionLeakAfterError() {
Config config = BaseTest.createConfig();
config.useSingleServer()
@ -129,7 +118,7 @@ public class RedissonBatchRxTest extends BaseRxTest {
BatchOptions batchOptions = BatchOptions.defaults().executionMode(ExecutionMode.REDIS_WRITE_ATOMIC);
RBatchRx batch = redisson.createBatch(batchOptions);
for (int i = 0; i < 100000; i++) {
for (int i = 0; i < 130000; i++) {
batch.getBucket("test").set(123);
}

12
redisson/src/test/java/org/redisson/rx/RedissonBlockingDequeRxTest.java
Unescape Escape View File

@ -1,12 +1,11 @@
package org.redisson.rx;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import org.redisson.api.RBlockingDequeRx;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
@ -58,12 +57,11 @@ public class RedissonBlockingDequeRxTest extends BaseRxTest {
}
@Test
@Timeout(3)
public void testShortPoll() {
Assertions.assertTimeout(Duration.ofSeconds(3), () -> {
RBlockingDequeRx<Integer> queue = redisson.getBlockingDeque("queue:pollany");
sync(queue.pollLast(500, TimeUnit.MILLISECONDS));
sync(queue.pollFirst(10, TimeUnit.MICROSECONDS));
});
RBlockingDequeRx<Integer> queue = redisson.getBlockingDeque("queue:pollany");
sync(queue.pollLast(500, TimeUnit.MILLISECONDS));
sync(queue.pollFirst(10, TimeUnit.MICROSECONDS));
}
@Test

Write Preview
Loading…
Cancel
Save