tests enhancements

pom.xml

@@ -134,11 +134,10 @@
       <scope>test</scope>
   </dependency>
   <dependency>
-      <groupId>net.jodah</groupId>
-      <artifactId>concurrentunit</artifactId>
-      <version>0.4.2</version>
-      <scope>test</scope>
-  </dependency>  
+      <groupId>com.jayway.awaitility</groupId>
+      <artifactId>awaitility</artifactId>
+      <version>1.7.0</version>
+  </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>

src/test/java/org/redisson/RedisClientTest.java

@@ -1,5 +1,7 @@
 package org.redisson;
 
+import static org.assertj.core.api.Assertions.*;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -10,7 +12,6 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
-import org.junit.Assert;
 import org.junit.Test;
 import org.redisson.client.RedisClient;
 import org.redisson.client.RedisConnection;
@@ -38,7 +39,7 @@ public class RedisClientTest {
             @Override
             public void operationComplete(Future<RedisConnection> future) throws Exception {
                 RedisConnection conn = future.get();
-                Assert.assertEquals("PONG", conn.sync(RedisCommands.PING));
+                assertThat(conn.sync(RedisCommands.PING)).isEqualTo("PONG");
                 l.countDown();
             }
         });
@@ -54,8 +55,8 @@ public class RedisClientTest {
 
             @Override
             public boolean onStatus(PubSubType type, String channel) {
-                Assert.assertEquals(PubSubType.SUBSCRIBE, type);
-                Assert.assertTrue(Arrays.asList("test1", "test2").contains(channel));
+                assertThat(type).isEqualTo(PubSubType.SUBSCRIBE);
+                assertThat(Arrays.asList("test1", "test2").contains(channel)).isTrue();
                 latch.countDown();
                 return true;
             }
@@ -90,9 +91,10 @@ public class RedisClientTest {
         }
 
         pool.shutdown();
-        Assert.assertTrue(pool.awaitTermination(1, TimeUnit.HOURS));
 
-        Assert.assertEquals(100000L, conn.sync(LongCodec.INSTANCE, RedisCommands.GET, "test"));
+        assertThat(pool.awaitTermination(1, TimeUnit.HOURS)).isTrue();
+
+        assertThat((Long)conn.sync(LongCodec.INSTANCE, RedisCommands.GET, "test")).isEqualTo(100000);
 
         conn.sync(RedisCommands.FLUSHDB);
     }
@@ -117,10 +119,10 @@ public class RedisClientTest {
         Promise<Void> p = c.getBootstrap().group().next().newPromise();
         conn.send(new CommandsData(p, commands));
 
-        Assert.assertEquals("PONG", cmd1.getPromise().get());
-        Assert.assertEquals(1, (long)cmd2.getPromise().get());
-        Assert.assertEquals(2, (long)cmd3.getPromise().get());
-        Assert.assertEquals("PONG", cmd4.getPromise().get());
+        assertThat(cmd1.getPromise().get()).isEqualTo("PONG");
+        assertThat(cmd2.getPromise().get()).isEqualTo(1);
+        assertThat(cmd3.getPromise().get()).isEqualTo(2);
+        assertThat(cmd4.getPromise().get()).isEqualTo("PONG");
 
         conn.sync(RedisCommands.FLUSHDB);
     }
@@ -135,7 +137,7 @@ public class RedisClientTest {
         }
 
         Map<Object, Object> res = conn.sync(StringCodec.INSTANCE, RedisCommands.HGETALL, "testmap");
-        Assert.assertEquals(50, res.size());
+        assertThat(res.size()).isEqualTo(50);
 
         conn.sync(RedisCommands.FLUSHDB);
     }

src/test/java/org/redisson/RedissonMultiLockTest.java

@@ -1,12 +1,15 @@
 package org.redisson;
 
+import static com.jayway.awaitility.Awaitility.await;
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
-import org.redisson.core.RedissonMultiLock;
 import org.redisson.core.RLock;
+import org.redisson.core.RedissonMultiLock;
 
 import io.netty.channel.nio.NioEventLoopGroup;
 
@@ -23,23 +26,43 @@ public class RedissonMultiLockTest {
         config1.useSingleServer().setAddress("127.0.0.1:6320");
         config1.setEventLoopGroup(group);
         RedissonClient client1 = Redisson.create(config1);
+        client1.getKeys().flushdb();
 
         Config config2 = new Config();
         config2.useSingleServer().setAddress("127.0.0.1:6321");
         config2.setEventLoopGroup(group);
         RedissonClient client2 = Redisson.create(config2);
+        client2.getKeys().flushdb();
 
         Config config3 = new Config();
         config3.useSingleServer().setAddress("127.0.0.1:6322");
         config3.setEventLoopGroup(group);
         RedissonClient client3 = Redisson.create(config3);
+        client3.getKeys().flushdb();
 
-        RLock lock1 = client1.getLock("lock1");
-        RLock lock2 = client2.getLock("lock2");
-        RLock lock3 = client3.getLock("lock3");
+        final RLock lock1 = client1.getLock("lock1");
+        final RLock lock2 = client2.getLock("lock2");
+        final RLock lock3 = client3.getLock("lock3");
 
         RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
         lock.lock();
+
+        final AtomicBoolean executed = new AtomicBoolean();
+
+        Thread t = new Thread() {
+            @Override
+            public void run() {
+                RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
+                assertThat(lock.tryLock()).isFalse();
+                assertThat(lock.tryLock()).isFalse();
+                executed.set(true);
+            }
+        };
+        t.start();
+        t.join();
+
+        await().atMost(5, TimeUnit.SECONDS).until(() -> assertThat(executed.get()).isTrue());
+
         lock.unlock();
 
         redis1.destroy();

src/test/java/org/redisson/RedissonTest.java

@@ -1,6 +1,6 @@
 package org.redisson;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.*;
 
 import java.io.IOException;
 import java.net.InetSocketAddress;
@@ -8,6 +8,7 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.Assert;
 import org.junit.Test;
@@ -17,8 +18,7 @@ import org.redisson.connection.ConnectionListener;
 import org.redisson.core.ClusterNode;
 import org.redisson.core.Node;
 import org.redisson.core.NodesGroup;
-
-import net.jodah.concurrentunit.Waiter;
+import static com.jayway.awaitility.Awaitility.*;
 
 public class RedissonTest {
 
@@ -42,8 +42,8 @@ public class RedissonTest {
 
         Process p = RedisRunner.runRedis("/redis_connectionListener_test.conf");
 
-        final Waiter onConnectWaiter = new Waiter();
-        final Waiter onDisconnectWaiter = new Waiter();
+        final AtomicInteger connectCounter = new AtomicInteger();
+        final AtomicInteger disconnectCounter = new AtomicInteger();
 
         Config config = new Config();
         config.useSingleServer().setAddress("127.0.0.1:6319").setFailedAttempts(1).setRetryAttempts(1)
@@ -55,14 +55,14 @@ public class RedissonTest {
 
             @Override
             public void onDisconnect(InetSocketAddress addr) {
-                onDisconnectWaiter.assertEquals(new InetSocketAddress("127.0.0.1", 6319), addr);
-                onDisconnectWaiter.resume();
+                assertThat(addr).isEqualTo(new InetSocketAddress("127.0.0.1", 6319));
+                disconnectCounter.incrementAndGet();
             }
 
             @Override
             public void onConnect(InetSocketAddress addr) {
-                onConnectWaiter.assertEquals(new InetSocketAddress("127.0.0.1", 6319), addr);
-                onConnectWaiter.resume();
+                assertThat(addr).isEqualTo(new InetSocketAddress("127.0.0.1", 6319));
+                connectCounter.incrementAndGet();
             }
         });
 
@@ -86,8 +86,8 @@ public class RedissonTest {
         p.destroy();
         Assert.assertEquals(1, p.waitFor());
 
-        onConnectWaiter.await(1, TimeUnit.SECONDS, 2);
-        onDisconnectWaiter.await();
+        await().atMost(1, TimeUnit.SECONDS).until(() -> assertThat(connectCounter.get()).isEqualTo(2));
+        await().until(() -> assertThat(disconnectCounter.get()).isEqualTo(1));
     }
 
     @Test