From ca61cdfa37a8d32e17badc9247c98e6dd5b29444 Mon Sep 17 00:00:00 2001
From: Nikita <abracham.mitchell@gmail.com>
Date: Mon, 26 Sep 2016 15:53:17 +0300
Subject: [PATCH] hamcrest lib removed
---
redisson/pom.xml | 6 ---
.../ConcurrentRedissonSortedSetTest.java | 5 +-
.../redisson/RedissonDequeReactiveTest.java | 19 ++++---
.../redisson/RedissonKeysReactiveTest.java | 7 ++-
.../RedissonLexSortedSetReactiveTest.java | 23 +++++----
.../redisson/RedissonLexSortedSetTest.java | 6 +--
.../redisson/RedissonListReactiveTest.java | 41 ++++++++--------
.../RedissonScoredSortedSetReactiveTest.java | 28 +++++------
.../org/redisson/RedissonSetReactiveTest.java | 34 ++++++-------
.../org/redisson/RedissonSortedSetTest.java | 49 +++++++++----------
10 files changed, 102 insertions(+), 116 deletions(-)
diff --git a/redisson/pom.xml b/redisson/pom.xml
index ca9da989f..be43b6c36 100644
--- a/redisson/pom.xml
+++ b/redisson/pom.xml
@@ -94,12 +94,6 @@
<version>4.12</version>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-library</artifactId>
- <version>1.3</version>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
diff --git a/redisson/src/test/java/org/redisson/ConcurrentRedissonSortedSetTest.java b/redisson/src/test/java/org/redisson/ConcurrentRedissonSortedSetTest.java
index 815f378bf..df9b620a6 100644
--- a/redisson/src/test/java/org/redisson/ConcurrentRedissonSortedSetTest.java
+++ b/redisson/src/test/java/org/redisson/ConcurrentRedissonSortedSetTest.java
@@ -1,5 +1,6 @@
package org.redisson;
+import static org.assertj.core.api.Assertions.*;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.ArrayList;
@@ -8,8 +9,6 @@ import java.util.List;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RSortedSet;
@@ -41,7 +40,7 @@ public class ConcurrentRedissonSortedSetTest extends BaseConcurrentTest {
Collections.sort(elements);
Integer[] p = elements.toArray(new Integer[elements.size()]);
- MatcherAssert.assertThat(map, Matchers.contains(p));
+ assertThat(map).contains(p);
map.clear();
r.shutdown();
diff --git a/redisson/src/test/java/org/redisson/RedissonDequeReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonDequeReactiveTest.java
index 3dc303310..6e6e895a9 100644
--- a/redisson/src/test/java/org/redisson/RedissonDequeReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonDequeReactiveTest.java
@@ -2,9 +2,8 @@ package org.redisson;
import java.util.Arrays;
import java.util.Iterator;
+import static org.assertj.core.api.Assertions.*;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RDequeReactive;
@@ -21,7 +20,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue1.removeLastOccurrence(3));
- MatcherAssert.assertThat(sync(queue1), Matchers.containsInAnyOrder(3, 2, 1));
+ assertThat(sync(queue1)).containsExactly(3, 2, 1);
}
@Test
@@ -34,7 +33,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue1.removeFirstOccurrence(3));
- MatcherAssert.assertThat(sync(queue1), Matchers.containsInAnyOrder(2, 1, 3));
+ assertThat(sync(queue1)).containsExactly(2, 1, 3);
}
@Test
@@ -84,7 +83,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue2.addFirst(4));
sync(queue1.pollLastAndOfferFirstTo(queue2.getName()));
- MatcherAssert.assertThat(sync(queue2), Matchers.contains(3, 4, 5, 6));
+ assertThat(sync(queue2)).containsExactly(3, 4, 5, 6);
}
@Test
@@ -94,7 +93,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue.addFirst(2));
sync(queue.addFirst(3));
- MatcherAssert.assertThat(sync(queue), Matchers.contains(3, 2, 1));
+ assertThat(sync(queue)).containsExactly(3, 2, 1);
}
@Test
@@ -104,7 +103,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue.addLast(2));
sync(queue.addLast(3));
- MatcherAssert.assertThat(sync(queue), Matchers.contains(1, 2, 3));
+ assertThat(sync(queue)).containsExactly(1, 2, 3);
}
@Test
@@ -114,7 +113,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
sync(queue.offerFirst(2));
sync(queue.offerFirst(3));
- MatcherAssert.assertThat(sync(queue), Matchers.contains(3, 2, 1));
+ assertThat(sync(queue)).containsExactly(3, 2, 1);
}
@Test
@@ -122,7 +121,7 @@ public class RedissonDequeReactiveTest extends BaseReactiveTest {
final RDequeReactive<Integer> queue = redisson.getDeque("deque");
sync(queue.addAll(Arrays.asList(1, 2, 3)));
- MatcherAssert.assertThat(() -> toIterator(queue.descendingIterator()), Matchers.contains(3, 2, 1));
-}
+ assertThat(toIterator(queue.descendingIterator())).containsExactly(3, 2, 1);
+ }
}
diff --git a/redisson/src/test/java/org/redisson/RedissonKeysReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonKeysReactiveTest.java
index 9864e8586..87ad95235 100644
--- a/redisson/src/test/java/org/redisson/RedissonKeysReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonKeysReactiveTest.java
@@ -2,8 +2,7 @@ package org.redisson;
import java.util.Iterator;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import static org.assertj.core.api.Assertions.*;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RBucketReactive;
@@ -21,7 +20,7 @@ public class RedissonKeysReactiveTest extends BaseReactiveTest {
Iterator<String> iterator = toIterator(redisson.getKeys().getKeysByPattern("test?"));
for (; iterator.hasNext();) {
String key = iterator.next();
- MatcherAssert.assertThat(key, Matchers.isOneOf("test1", "test2"));
+ assertThat(key).isIn("test1", "test2");
}
}
@@ -33,7 +32,7 @@ public class RedissonKeysReactiveTest extends BaseReactiveTest {
RBucketReactive<String> bucket2 = redisson.getBucket("test2");
sync(bucket2.set("someValue2"));
- MatcherAssert.assertThat(sync(redisson.getKeys().randomKey()), Matchers.isOneOf("test1", "test2"));
+ assertThat(sync(redisson.getKeys().randomKey())).isIn("test1", "test2");
sync(redisson.getKeys().delete("test1"));
Assert.assertEquals("test2", sync(redisson.getKeys().randomKey()));
sync(redisson.getKeys().flushdb());
diff --git a/redisson/src/test/java/org/redisson/RedissonLexSortedSetReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonLexSortedSetReactiveTest.java
index 4355745b7..20255ebe1 100644
--- a/redisson/src/test/java/org/redisson/RedissonLexSortedSetReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonLexSortedSetReactiveTest.java
@@ -1,7 +1,6 @@
package org.redisson;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import static org.assertj.core.api.Assertions.*;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RLexSortedSetReactive;
@@ -37,9 +36,9 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
Assert.assertEquals(0, sync(set.removeRangeTailByLex("z", false)).intValue());
Assert.assertEquals(4, sync(set.removeRangeTailByLex("c", false)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("a", "b", "c"));
+ assertThat(sync(set)).containsExactly("a", "b", "c");
Assert.assertEquals(1, sync(set.removeRangeTailByLex("c", true)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("a", "b"));
+ assertThat(sync(set)).containsExactly("a", "b");
}
@@ -55,9 +54,9 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add("g"));
Assert.assertEquals(2, sync(set.removeRangeHeadByLex("c", false)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("c", "d", "e", "f", "g"));
+ assertThat(sync(set)).containsExactly("c", "d", "e", "f", "g");
Assert.assertEquals(1, (int)sync(set.removeRangeHeadByLex("c", true)));
- MatcherAssert.assertThat(sync(set), Matchers.contains("d", "e", "f", "g"));
+ assertThat(sync(set)).containsExactly("d", "e", "f", "g");
}
@Test
@@ -72,7 +71,7 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add("g"));
Assert.assertEquals(5, sync(set.removeRangeByLex("aaa", true, "g", false)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("a", "g"));
+ assertThat(sync(set)).containsExactly("a", "g");
}
@@ -88,8 +87,8 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(set.add("f")) == 1);
Assert.assertTrue(sync(set.add("g")) == 1);
- MatcherAssert.assertThat(sync(set.lexRangeTail("c", false)), Matchers.contains("d", "e", "f", "g"));
- MatcherAssert.assertThat(sync(set.lexRangeTail("c", true)), Matchers.contains("c", "d", "e", "f", "g"));
+ assertThat(sync(set.lexRangeTail("c", false))).containsExactly("d", "e", "f", "g");
+ assertThat(sync(set.lexRangeTail("c", true))).containsExactly("c", "d", "e", "f", "g");
}
@@ -104,8 +103,8 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add("f"));
sync(set.add("g"));
- MatcherAssert.assertThat(sync(set.lexRangeHead("c", false)), Matchers.contains("a", "b"));
- MatcherAssert.assertThat(sync(set.lexRangeHead("c", true)), Matchers.contains("a", "b", "c"));
+ assertThat(sync(set.lexRangeHead("c", false))).containsExactly("a", "b");
+ assertThat(sync(set.lexRangeHead("c", true))).containsExactly("a", "b", "c");
}
@@ -120,7 +119,7 @@ public class RedissonLexSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add("f"));
sync(set.add("g"));
- MatcherAssert.assertThat(sync(set.lexRange("aaa", true, "g", false)), Matchers.contains("b", "c", "d", "e", "f"));
+ assertThat(sync(set.lexRange("aaa", true, "g", false))).contains("b", "c", "d", "e", "f");
}
@Test
diff --git a/redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java b/redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java
index 020c16155..5ca2feb5d 100644
--- a/redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java
@@ -2,8 +2,6 @@ package org.redisson;
import static org.assertj.core.api.Assertions.assertThat;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RLexSortedSet;
@@ -20,7 +18,7 @@ public class RedissonLexSortedSetTest extends BaseTest {
set.add("c");
Assert.assertEquals("c", set.pollLast());
- MatcherAssert.assertThat(set, Matchers.contains("a", "b"));
+ assertThat(set).containsExactly("a", "b");
}
@Test
@@ -33,7 +31,7 @@ public class RedissonLexSortedSetTest extends BaseTest {
set.add("c");
Assert.assertEquals("a", set.pollFirst());
- MatcherAssert.assertThat(set, Matchers.contains("b", "c"));
+ assertThat(set).containsExactly("b", "c");
}
@Test
diff --git a/redisson/src/test/java/org/redisson/RedissonListReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonListReactiveTest.java
index 0b5edaec3..3277e4357 100644
--- a/redisson/src/test/java/org/redisson/RedissonListReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonListReactiveTest.java
@@ -5,8 +5,7 @@ import java.util.Collections;
import java.util.Iterator;
import java.util.concurrent.CountDownLatch;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import static org.assertj.core.api.Assertions.*;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RListReactive;
@@ -53,7 +52,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(test2.add("foo"));
sync(test2.add(0, "bar"));
- MatcherAssert.assertThat(sync(test2), Matchers.contains("bar", "foo"));
+ assertThat(sync(test2)).containsExactly("bar", "foo");
}
@Test
@@ -99,7 +98,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
latch.await();
- Assert.assertThat(sync(list), Matchers.contains(1L, 2L, 3L, 1L, 24L, 3L));
+ assertThat(sync(list)).containsExactly(1L, 2L, 3L, 1L, 24L, 3L);
}
@Test
@@ -130,7 +129,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
latch.await();
- Assert.assertThat(sync(list), Matchers.contains(1L, 2L));
+ assertThat(sync(list)).containsExactly(1L, 2L);
}
@Test
@@ -139,7 +138,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(list.add(1L));
sync(list.add(2L));
- Assert.assertThat(sync(list), Matchers.contains(1L, 2L));
+ assertThat(sync(list)).containsExactly(1L, 2L);
}
@Test
@@ -291,7 +290,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
Integer val = sync(list.remove(0));
Assert.assertTrue(1 == val);
- Assert.assertThat(sync(list), Matchers.contains(2, 3, 4, 5));
+ assertThat(sync(list)).containsExactly(2, 3, 4, 5);
}
@Test
@@ -305,7 +304,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(list.set(4, 6));
- Assert.assertThat(sync(list), Matchers.contains(1, 2, 3, 4, 6));
+ assertThat(sync(list)).containsExactly(1, 2, 3, 4, 6);
}
@Test(expected = RedisException.class)
@@ -345,11 +344,11 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
Assert.assertFalse(sync(list.removeAll(Collections.emptyList())));
Assert.assertTrue(sync(list.removeAll(Arrays.asList(3, 2, 10, 6))));
- Assert.assertThat(sync(list), Matchers.contains(1, 4, 5));
+ assertThat(sync(list)).containsExactly(1, 4, 5);
Assert.assertTrue(sync(list.removeAll(Arrays.asList(4))));
- Assert.assertThat(sync(list), Matchers.contains(1, 5));
+ assertThat(sync(list)).containsExactly(1, 5);
Assert.assertTrue(sync(list.removeAll(Arrays.asList(1, 5, 1, 5))));
@@ -367,7 +366,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(list.retainAll(Arrays.asList(3, 2, 10, 6))));
- Assert.assertThat(sync(list), Matchers.contains(2, 3));
+ assertThat(sync(list)).containsExactly(2, 3);
Assert.assertEquals(2, sync(list.size()).longValue());
}
@@ -401,7 +400,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(list.add(2));
Assert.assertFalse(sync(list.retainAll(Arrays.asList(1, 2)))); // nothing changed
- Assert.assertThat(sync(list), Matchers.contains(1, 2));
+ assertThat(sync(list)).containsExactly(1, 2);
}
@Test(expected = RedisException.class)
@@ -421,19 +420,19 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
Assert.assertEquals(8, sync(list.addAll(2, Arrays.asList(7, 8, 9))).longValue());
- Assert.assertThat(sync(list), Matchers.contains(1, 2, 7, 8, 9, 3, 4, 5));
+ assertThat(sync(list)).containsExactly(1, 2, 7, 8, 9, 3, 4, 5);
sync(list.addAll(sync(list.size())-1, Arrays.asList(9, 1, 9)));
- Assert.assertThat(sync(list), Matchers.contains(1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5));
+ assertThat(sync(list)).containsExactly(1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5);
sync(list.addAll(sync(list.size()), Arrays.asList(0, 5)));
- Assert.assertThat(sync(list), Matchers.contains(1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5, 0, 5));
+ assertThat(sync(list)).containsExactly(1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5, 0, 5);
Assert.assertEquals(15, sync(list.addAll(0, Arrays.asList(6, 7))).intValue());
- Assert.assertThat(sync(list), Matchers.contains(6,7,1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5, 0, 5));
+ assertThat(sync(list)).containsExactly(6,7,1, 2, 7, 8, 9, 3, 4, 9, 1, 9, 5, 0, 5);
}
@Test
@@ -449,7 +448,7 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
Assert.assertEquals(11, sync(list.addAll(Arrays.asList(9, 1, 9))).intValue());
- Assert.assertThat(sync(list), Matchers.contains(1, 2, 3, 4, 5, 7, 8, 9, 9, 1, 9));
+ assertThat(sync(list)).containsExactly(1, 2, 3, 4, 5, 7, 8, 9, 9, 1, 9);
}
@Test
@@ -569,13 +568,13 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(list.add("4"));
sync(list.add("5"));
sync(list.add("6"));
- Assert.assertThat(sync(list), Matchers.contains("1", "2", "3", "4", "5", "6"));
+ assertThat(sync(list)).containsExactly("1", "2", "3", "4", "5", "6");
sync(list.remove("2"));
- Assert.assertThat(sync(list), Matchers.contains("1", "3", "4", "5", "6"));
+ assertThat(sync(list)).containsExactly("1", "3", "4", "5", "6");
sync(list.remove("4"));
- Assert.assertThat(sync(list), Matchers.contains("1", "3", "5", "6"));
+ assertThat(sync(list)).containsExactly("1", "3", "5", "6");
}
@Test
@@ -586,6 +585,6 @@ public class RedissonListReactiveTest extends BaseReactiveTest {
sync(list.add("3"));
sync(list.add("e"));
- Assert.assertThat(sync(list), Matchers.<Object>contains(1, 2L, "3", "e"));
+ assertThat(sync(list)).containsExactly(1, 2L, "3", "e");
}
}
diff --git a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetReactiveTest.java
index ebe1af78b..cc9c6605a 100644
--- a/redisson/src/test/java/org/redisson/RedissonScoredSortedSetReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonScoredSortedSetReactiveTest.java
@@ -1,5 +1,7 @@
package org.redisson;
+import static org.assertj.core.api.Assertions.assertThat;
+
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
@@ -7,8 +9,6 @@ import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RScoredSortedSetReactive;
@@ -42,7 +42,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add(0.7, "g"));
Assert.assertEquals(2, sync(set.removeRangeByScore(0.1, false, 0.3, true)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("a", "d", "e", "f", "g"));
+ assertThat(sync(set)).containsOnly("a", "d", "e", "f", "g");
}
@Test
@@ -57,7 +57,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add(0.7, "g"));
Assert.assertEquals(2, sync(set.removeRangeByRank(0, 1)).intValue());
- MatcherAssert.assertThat(sync(set), Matchers.contains("c", "d", "e", "f", "g"));
+ assertThat(sync(set)).containsOnly("c", "d", "e", "f", "g");
}
@Test
@@ -92,14 +92,14 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(set.remove(1)));
Assert.assertFalse(sync(set.contains(1)));
- Assert.assertThat(sync(set), Matchers.contains(3, 7));
+ assertThat(sync(set)).containsExactly(3, 7);
Assert.assertFalse(sync(set.remove(1)));
- Assert.assertThat(sync(set), Matchers.contains(3, 7));
+ assertThat(sync(set)).containsExactly(3, 7);
sync(set.remove(3));
Assert.assertFalse(sync(set.contains(3)));
- Assert.assertThat(sync(set), Matchers.contains(7));
+ assertThat(sync(set)).containsExactly(7);
}
@Test
@@ -148,7 +148,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
}
Assert.assertTrue(sync(set.retainAll(Arrays.asList(1, 2))));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(1, 2));
+ assertThat(sync(set)).contains(1, 2);
Assert.assertEquals(2, sync(set.size()).intValue());
}
@@ -160,7 +160,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add(0.3, 3));
Assert.assertTrue(sync(set.removeAll(Arrays.asList(1, 2))));
- Assert.assertThat(sync(set), Matchers.contains(3));
+ assertThat(sync(set)).contains(3);
Assert.assertEquals(1, sync(set.size()).intValue());
}
@@ -176,7 +176,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(set.add(1, -1)));
Assert.assertTrue(sync(set.add(2, 0)));
- MatcherAssert.assertThat(sync(set), Matchers.contains(-1, 0, 1, 2, 3, 4, 10));
+ assertThat(sync(set)).containsExactly(-1, 0, 1, 2, 3, 4, 10);
Assert.assertEquals(-1, (int)sync(set.first()));
Assert.assertEquals(10, (int)sync(set.last()));
@@ -194,7 +194,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
Assert.assertFalse(sync(set.remove(0)));
Assert.assertTrue(sync(set.remove(3)));
- Assert.assertThat(sync(set), Matchers.contains(1, 2, 4, 5));
+ assertThat(sync(set)).containsExactly(1, 2, 4, 5);
}
@Test
@@ -261,7 +261,7 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add(4, 5));
Collection<Integer> vals = sync(set.valueRange(0, -1));
- MatcherAssert.assertThat(vals, Matchers.contains(1, 2, 3, 4, 5));
+ assertThat(sync(set)).containsExactly(1, 2, 3, 4, 5);
}
@Test
@@ -274,11 +274,11 @@ public class RedissonScoredSortedSetReactiveTest extends BaseReactiveTest {
sync(set.add(50, 5));
Collection<ScoredEntry<Integer>> vals = sync(set.entryRange(0, -1));
- MatcherAssert.assertThat(vals, Matchers.contains(new ScoredEntry<Integer>(10D, 1),
+ assertThat(vals).contains(new ScoredEntry<Integer>(10D, 1),
new ScoredEntry<Integer>(20D, 2),
new ScoredEntry<Integer>(30D, 3),
new ScoredEntry<Integer>(40D, 4),
- new ScoredEntry<Integer>(50D, 5)));
+ new ScoredEntry<Integer>(50D, 5));
}
@Test
diff --git a/redisson/src/test/java/org/redisson/RedissonSetReactiveTest.java b/redisson/src/test/java/org/redisson/RedissonSetReactiveTest.java
index 9e4fdc43e..0c41661f2 100644
--- a/redisson/src/test/java/org/redisson/RedissonSetReactiveTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonSetReactiveTest.java
@@ -7,9 +7,8 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutionException;
+import static org.assertj.core.api.Assertions.*;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RSetReactive;
@@ -51,9 +50,9 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
sync(set.add(2));
sync(set.add(3));
- MatcherAssert.assertThat(sync(set.removeRandom()), Matchers.isOneOf(1, 2, 3));
- MatcherAssert.assertThat(sync(set.removeRandom()), Matchers.isOneOf(1, 2, 3));
- MatcherAssert.assertThat(sync(set.removeRandom()), Matchers.isOneOf(1, 2, 3));
+ assertThat(sync(set.removeRandom())).isIn(1, 2, 3);
+ assertThat(sync(set.removeRandom())).isIn(1, 2, 3);
+ assertThat(sync(set.removeRandom())).isIn(1, 2, 3);
Assert.assertNull(sync(set.removeRandom()));
}
@@ -64,10 +63,11 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
sync(set.add(2));
sync(set.add(3));
- MatcherAssert.assertThat(sync(set.random()), Matchers.isOneOf(1, 2, 3));
- MatcherAssert.assertThat(sync(set.random()), Matchers.isOneOf(1, 2, 3));
- MatcherAssert.assertThat(sync(set.random()), Matchers.isOneOf(1, 2, 3));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(1, 2, 3));
+ assertThat(sync(set.random())).isIn(1, 2, 3);
+ assertThat(sync(set.random())).isIn(1, 2, 3);
+ assertThat(sync(set.random())).isIn(1, 2, 3);
+
+ assertThat(sync(set)).containsOnly(1, 2, 3);
}
@Test
@@ -100,14 +100,14 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(set.remove(1)));
Assert.assertFalse(sync(set.contains(1)));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(3, 7));
+ assertThat(sync(set)).containsExactly(3, 7);
Assert.assertFalse(sync(set.remove(1)));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(3, 7));
+ assertThat(sync(set)).containsExactly(3, 7);
sync(set.remove(3));
Assert.assertFalse(sync(set.contains(3)));
- Assert.assertThat(sync(set), Matchers.contains(7));
+ assertThat(sync(set)).containsExactly(7);
}
@Test
@@ -142,7 +142,7 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
sync(set.add(1L));
sync(set.add(2L));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(1L, 2L));
+ assertThat(sync(set)).containsOnly(1L, 2L);
}
@Test
@@ -153,7 +153,7 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
}
Assert.assertTrue(sync(set.retainAll(Arrays.asList(1, 2))));
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(1, 2));
+ assertThat(sync(set)).containsExactly(1, 2);
Assert.assertEquals(2, sync(set.size()).intValue());
}
@@ -232,7 +232,7 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
sync(set.add(2));
Assert.assertFalse(sync(set.retainAll(Arrays.asList(1, 2)))); // nothing changed
- Assert.assertThat(sync(set), Matchers.containsInAnyOrder(1, 2));
+ assertThat(sync(set)).containsExactly(1, 2);
}
@@ -247,10 +247,10 @@ public class RedissonSetReactiveTest extends BaseReactiveTest {
Assert.assertTrue(sync(set.move("otherSet", 1)));
Assert.assertEquals(1, sync(set.size()).intValue());
- Assert.assertThat(sync(set), Matchers.contains(2));
+ assertThat(sync(set)).containsExactly(2);
Assert.assertEquals(1, sync(otherSet.size()).intValue());
- Assert.assertThat(sync(otherSet), Matchers.contains(1));
+ assertThat(sync(otherSet)).containsExactly(1);
}
@Test
diff --git a/redisson/src/test/java/org/redisson/RedissonSortedSetTest.java b/redisson/src/test/java/org/redisson/RedissonSortedSetTest.java
index a4078b993..c601f055f 100644
--- a/redisson/src/test/java/org/redisson/RedissonSortedSetTest.java
+++ b/redisson/src/test/java/org/redisson/RedissonSortedSetTest.java
@@ -9,8 +9,7 @@ import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.ExecutionException;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import static org.assertj.core.api.Assertions.*;
import org.junit.Assert;
import org.junit.Test;
import org.redisson.api.RFuture;
@@ -36,14 +35,14 @@ public class RedissonSortedSetTest extends BaseTest {
Assert.assertTrue(set.removeAsync(1).get());
Assert.assertFalse(set.contains(1));
- Assert.assertThat(set, Matchers.contains(3, 7));
+ assertThat(set).containsExactly(3, 7);
Assert.assertFalse(set.removeAsync(1).get());
- Assert.assertThat(set, Matchers.contains(3, 7));
+ assertThat(set).containsExactly(3, 7);
set.removeAsync(3).get();
Assert.assertFalse(set.contains(3));
- Assert.assertThat(set, Matchers.contains(7));
+ assertThat(set).containsExactly(7);
}
@Test
@@ -74,7 +73,7 @@ public class RedissonSortedSetTest extends BaseTest {
}
}
- Assert.assertThat(list, Matchers.containsInAnyOrder("1", "4", "5", "3"));
+ assertThat(list).contains("1", "4", "5", "3");
int iteration = 0;
for (Iterator<String> iterator = list.iterator(); iterator.hasNext();) {
@@ -126,11 +125,11 @@ public class RedissonSortedSetTest extends BaseTest {
Assert.assertTrue(set.add(3));
Assert.assertTrue(set.add(4));
Assert.assertTrue(set.add(5));
- MatcherAssert.assertThat(set, Matchers.contains(5, 4, 3, 2, 1));
+ assertThat(set).containsExactly(5, 4, 3, 2, 1);
boolean setRes2 = set.trySetComparator(Collections.reverseOrder(Collections.reverseOrder()));
Assert.assertFalse(setRes2);
- MatcherAssert.assertThat(set, Matchers.contains(5, 4, 3, 2, 1));
+ assertThat(set).containsExactly(5, 4, 3, 2, 1);
set.clear();
boolean setRes3 = set.trySetComparator(Collections.reverseOrder(Collections.reverseOrder()));
@@ -138,7 +137,7 @@ public class RedissonSortedSetTest extends BaseTest {
set.add(3);
set.add(1);
set.add(2);
- MatcherAssert.assertThat(set, Matchers.contains(1, 2, 3));
+ assertThat(set).containsExactly(1, 2, 3);
}
@@ -168,15 +167,15 @@ public class RedissonSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.tailSet(3);
hs.add(10);
- MatcherAssert.assertThat(hs, Matchers.contains(3, 4, 5, 10));
+ assertThat(hs).containsExactly(3, 4, 5, 10);
set.remove(4);
- MatcherAssert.assertThat(hs, Matchers.contains(3, 5, 10));
+ assertThat(hs).containsExactly(3, 5, 10);
set.remove(3);
- MatcherAssert.assertThat(hs, Matchers.contains(5, 10));
+ assertThat(hs).containsExactly(5, 10);
hs.add(-1);
}
@@ -195,15 +194,15 @@ public class RedissonSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.headSet(3);
hs.add(0);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1, 2));
+ assertThat(hs).containsExactly(0, 1, 2);
set.remove(2);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1));
+ assertThat(hs).containsExactly(0, 1);
set.remove(3);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1));
+ assertThat(hs).containsExactly(0, 1);
hs.add(7);
}
@@ -221,15 +220,15 @@ public class RedissonSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.tailSet(3);
hs.add(10);
- MatcherAssert.assertThat(hs, Matchers.contains(3, 4, 5, 10));
+ assertThat(hs).containsExactly(3, 4, 5, 10);
set.remove(4);
- MatcherAssert.assertThat(hs, Matchers.contains(3, 5, 10));
+ assertThat(hs).containsExactly(3, 5, 10);
set.remove(3);
- MatcherAssert.assertThat(hs, Matchers.contains(5, 10));
+ assertThat(hs).containsExactly(5, 10);
hs.add(-1);
}
@@ -247,15 +246,15 @@ public class RedissonSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.headSet(3);
hs.add(0);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1, 2));
+ assertThat(hs).containsExactly(0, 1, 2);
set.remove(2);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1));
+ assertThat(hs).containsExactly(0, 1);
set.remove(3);
- MatcherAssert.assertThat(hs, Matchers.contains(0, 1));
+ assertThat(hs).containsExactly(0, 1);
hs.add(7);
}
@@ -271,7 +270,7 @@ public class RedissonSortedSetTest extends BaseTest {
Assert.assertTrue(set.add(-1));
Assert.assertTrue(set.add(0));
- MatcherAssert.assertThat(set, Matchers.contains(-1, 0, 1, 2, 3, 4, 10));
+ assertThat(set).containsExactly(-1, 0, 1, 2, 3, 4, 10);
Assert.assertEquals(-1, (int)set.first());
Assert.assertEquals(10, (int)set.last());
@@ -289,7 +288,7 @@ public class RedissonSortedSetTest extends BaseTest {
Assert.assertFalse(set.remove(0));
Assert.assertTrue(set.remove(3));
- Assert.assertThat(set, Matchers.contains(1, 2, 4, 5));
+ assertThat(set).containsExactly(1, 2, 4, 5);
}
@Test
@@ -323,10 +322,10 @@ public class RedissonSortedSetTest extends BaseTest {
set.add("5");
set.add("3");
- MatcherAssert.assertThat(Arrays.asList(set.toArray()), Matchers.<Object>containsInAnyOrder("1", "2", "4", "5", "3"));
+ assertThat(set.toArray()).contains("1", "4", "2", "5", "3");
String[] strs = set.toArray(new String[0]);
- MatcherAssert.assertThat(Arrays.asList(strs), Matchers.containsInAnyOrder("1", "4", "2", "5", "3"));
+ assertThat(strs).contains("1", "4", "2", "5", "3");
}
@Test