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

hamcrest lib removed

Browse Source
pull/653/head
Nikita 8 years ago
parent 45953245b9
commit ca61cdfa37
10 changed files with 102 additions and 116 deletions
Show Stats Download Patch File Download Diff File

6
redisson/pom.xml
Unescape Escape View File

@ -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>

5
redisson/src/test/java/org/redisson/ConcurrentRedissonSortedSetTest.java
Unescape Escape View File

@ -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();

19
redisson/src/test/java/org/redisson/RedissonDequeReactiveTest.java
Unescape Escape View File

@ -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);
}
}

7
redisson/src/test/java/org/redisson/RedissonKeysReactiveTest.java
Unescape Escape View File

@ -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());

23
redisson/src/test/java/org/redisson/RedissonLexSortedSetReactiveTest.java
Unescape Escape View File

@ -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

6
redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java
Unescape Escape View File

@ -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

41
redisson/src/test/java/org/redisson/RedissonListReactiveTest.java
Unescape Escape View File

@ -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");
}
}

28
redisson/src/test/java/org/redisson/RedissonScoredSortedSetReactiveTest.java
Unescape Escape View File

@ -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

34
redisson/src/test/java/org/redisson/RedissonSetReactiveTest.java
Unescape Escape View File

@ -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

49
redisson/src/test/java/org/redisson/RedissonSortedSetTest.java
Unescape Escape View File

@ -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

Write Preview
Loading…
Cancel
Save