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

Matchers and MatcherAssert removed from few tests

Browse Source
pull/495/head
Nikita 9 years ago
parent 541b3e1eaf
commit 61d3293cb3
3 changed files with 43 additions and 57 deletions
Show Stats Download Patch File Download Diff File

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

@ -16,8 +16,6 @@ import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException; import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import org.hamcrest.MatcherAssert;
import org.hamcrest.Matchers;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.redisson.RedisRunner.RedisProcess; import org.redisson.RedisRunner.RedisProcess;
@ -221,7 +219,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
queue2.put(6); queue2.put(6);
queue1.pollLastAndOfferFirstTo(queue2.getName(), 10, TimeUnit.SECONDS); queue1.pollLastAndOfferFirstTo(queue2.getName(), 10, TimeUnit.SECONDS);
MatcherAssert.assertThat(queue2, Matchers.contains(3, 4, 5, 6)); assertThat(queue2).containsExactly(3, 4, 5, 6);
} }
@Test @Test
@ -232,9 +230,9 @@ public class RedissonBlockingQueueTest extends BaseTest {
queue.add(3); queue.add(3);
queue.offer(4); queue.offer(4);
MatcherAssert.assertThat(queue, Matchers.contains(1, 2, 3, 4)); assertThat(queue).containsExactly(1, 2, 3, 4);
Assert.assertEquals((Integer) 1, queue.poll()); Assert.assertEquals((Integer) 1, queue.poll());
MatcherAssert.assertThat(queue, Matchers.contains(2, 3, 4)); assertThat(queue).containsExactly(2, 3, 4);
Assert.assertEquals((Integer) 2, queue.element()); Assert.assertEquals((Integer) 2, queue.element());
} }
@ -246,9 +244,9 @@ public class RedissonBlockingQueueTest extends BaseTest {
queue.add(3); queue.add(3);
queue.offer(4); queue.offer(4);
MatcherAssert.assertThat(queue, Matchers.contains(1, 2, 3, 4)); assertThat(queue).containsExactly(1, 2, 3, 4);
Assert.assertEquals((Integer) 1, queue.poll()); Assert.assertEquals((Integer) 1, queue.poll());
MatcherAssert.assertThat(queue, Matchers.contains(2, 3, 4)); assertThat(queue).containsExactly(2, 3, 4);
Assert.assertEquals((Integer) 2, queue.element()); Assert.assertEquals((Integer) 2, queue.element());
} }
@ -263,7 +261,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
queue.remove(); queue.remove();
queue.remove(); queue.remove();
MatcherAssert.assertThat(queue, Matchers.contains(3, 4)); assertThat(queue).containsExactly(3, 4);
queue.remove(); queue.remove();
queue.remove(); queue.remove();
@ -281,7 +279,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
queue.remove(); queue.remove();
queue.remove(); queue.remove();
MatcherAssert.assertThat(queue, Matchers.contains(3, 4)); assertThat(queue).containsExactly(3, 4);
queue.remove(); queue.remove();
queue.remove(); queue.remove();
@ -355,7 +353,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
ArrayList<Object> dst = new ArrayList<Object>(); ArrayList<Object> dst = new ArrayList<Object>();
queue1.drainTo(dst); queue1.drainTo(dst);
MatcherAssert.assertThat(dst, Matchers.<Object>contains(1, 2L, "e")); assertThat(dst).containsExactly(1, 2L, "e");
Assert.assertEquals(0, queue1.size()); Assert.assertEquals(0, queue1.size());
} }
@ -368,14 +366,12 @@ public class RedissonBlockingQueueTest extends BaseTest {
ArrayList<Object> dst = new ArrayList<Object>(); ArrayList<Object> dst = new ArrayList<Object>();
queue1.drainTo(dst, 2); queue1.drainTo(dst, 2);
MatcherAssert.assertThat(dst, Matchers.<Object>contains(1, 2L)); assertThat(dst).containsExactly(1, 2L);
Assert.assertEquals(1, queue1.size()); Assert.assertEquals(1, queue1.size());
dst.clear(); dst.clear();
queue1.drainTo(dst, 2); queue1.drainTo(dst, 2);
MatcherAssert.assertThat(dst, Matchers.<Object>contains("e")); assertThat(dst).containsExactly("e");
} }
@Test @Test

9
src/test/java/org/redisson/RedissonMapTest.java
Unescape Escape View File

@ -11,20 +11,15 @@ import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutionException;
import org.assertj.core.data.MapEntry;
import org.hamcrest.MatcherAssert;
import org.hamcrest.Matchers;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.redisson.client.codec.StringCodec; import org.redisson.client.codec.StringCodec;
import org.redisson.codec.JsonJacksonCodec; import org.redisson.codec.JsonJacksonCodec;
import org.redisson.core.Predicate; import org.redisson.core.Predicate;
import org.redisson.core.RMap; import org.redisson.core.RMap;
import org.redisson.core.RSet;
import io.netty.util.concurrent.Future; import io.netty.util.concurrent.Future;
@ -667,7 +662,7 @@ public class RedissonMapTest extends BaseTest {
map.put(7, 8); map.put(7, 8);
Collection<Integer> keys = map.keySet(); Collection<Integer> keys = map.keySet();
MatcherAssert.assertThat(keys, Matchers.containsInAnyOrder(1, 3, 4, 7)); assertThat(keys).containsOnly(1, 3, 4, 7);
for (Iterator<Integer> iterator = map.keyIterator(); iterator.hasNext();) { for (Iterator<Integer> iterator = map.keyIterator(); iterator.hasNext();) {
Integer value = iterator.next(); Integer value = iterator.next();
if (!keys.remove(value)) { if (!keys.remove(value)) {
@ -687,7 +682,7 @@ public class RedissonMapTest extends BaseTest {
map.put(7, 8); map.put(7, 8);
Collection<Integer> values = map.values(); Collection<Integer> values = map.values();
MatcherAssert.assertThat(values, Matchers.containsInAnyOrder(0, 5, 6, 8)); assertThat(values).containsOnly(0, 5, 6, 8);
for (Iterator<Integer> iterator = map.valueIterator(); iterator.hasNext();) { for (Iterator<Integer> iterator = map.valueIterator(); iterator.hasNext();) {
Integer value = iterator.next(); Integer value = iterator.next();
if (!values.remove(value)) { if (!values.remove(value)) {

67
src/test/java/org/redisson/RedissonScoredSortedSetTest.java
Unescape Escape View File

@ -13,8 +13,6 @@ import java.util.SortedSet;
import java.util.TreeSet; import java.util.TreeSet;
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutionException;
import org.hamcrest.MatcherAssert;
import org.hamcrest.Matchers;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.redisson.client.codec.StringCodec; import org.redisson.client.codec.StringCodec;
@ -83,7 +81,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.3, "c"); set.add(0.3, "c");
Assert.assertEquals("c", set.pollLast()); Assert.assertEquals("c", set.pollLast());
MatcherAssert.assertThat(set, Matchers.contains("a", "b")); assertThat(set).containsExactly("a", "b");
} }
@Test @Test
@ -96,7 +94,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.3, "c"); set.add(0.3, "c");
Assert.assertEquals("a", set.pollFirst()); Assert.assertEquals("a", set.pollFirst());
MatcherAssert.assertThat(set, Matchers.contains("b", "c")); assertThat(set).containsExactly("b", "c");
} }
@Test @Test
@ -124,7 +122,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.7, "g"); set.add(0.7, "g");
Assert.assertEquals(2, set.removeRangeByScore(0.1, false, 0.3, true)); Assert.assertEquals(2, set.removeRangeByScore(0.1, false, 0.3, true));
MatcherAssert.assertThat(set, Matchers.contains("a", "d", "e", "f", "g")); assertThat(set).containsExactly("a", "d", "e", "f", "g");
} }
@Test @Test
@ -139,7 +137,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.7, "g"); set.add(0.7, "g");
Assert.assertEquals(3, set.removeRangeByScore(Double.NEGATIVE_INFINITY, false, 0.3, true)); Assert.assertEquals(3, set.removeRangeByScore(Double.NEGATIVE_INFINITY, false, 0.3, true));
MatcherAssert.assertThat(set, Matchers.contains("d", "e", "f", "g")); assertThat(set).containsExactly("d", "e", "f", "g");
} }
@Test @Test
@ -154,7 +152,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.7, "g"); set.add(0.7, "g");
Assert.assertEquals(3, set.removeRangeByScore(0.4, false, Double.POSITIVE_INFINITY, true)); Assert.assertEquals(3, set.removeRangeByScore(0.4, false, Double.POSITIVE_INFINITY, true));
MatcherAssert.assertThat(set, Matchers.contains("a", "b", "c", "d")); assertThat(set).containsExactly("a", "b", "c", "d");
} }
@Test @Test
@ -169,7 +167,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.7, "g"); set.add(0.7, "g");
Assert.assertEquals(2, set.removeRangeByRank(0, 1)); Assert.assertEquals(2, set.removeRangeByRank(0, 1));
MatcherAssert.assertThat(set, Matchers.contains("c", "d", "e", "f", "g")); assertThat(set).containsExactly("c", "d", "e", "f", "g");
} }
@Test @Test
@ -223,14 +221,14 @@ public class RedissonScoredSortedSetTest extends BaseTest {
Assert.assertTrue(set.removeAsync(1).get()); Assert.assertTrue(set.removeAsync(1).get());
Assert.assertFalse(set.contains(1)); Assert.assertFalse(set.contains(1));
Assert.assertThat(set, Matchers.contains(3, 7)); assertThat(set).containsExactly(3, 7);
Assert.assertFalse(set.removeAsync(1).get()); Assert.assertFalse(set.removeAsync(1).get());
Assert.assertThat(set, Matchers.contains(3, 7)); assertThat(set).containsExactly(3, 7);
set.removeAsync(3).get(); set.removeAsync(3).get();
Assert.assertFalse(set.contains(3)); Assert.assertFalse(set.contains(3));
Assert.assertThat(set, Matchers.contains(7)); assertThat(set).containsExactly(7);
} }
@Test @Test
@ -261,7 +259,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
} }
} }
Assert.assertThat(set, Matchers.contains("1", "4", "5", "3")); assertThat(set).containsExactly("1", "4", "5", "3");
int iteration = 0; int iteration = 0;
for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) { for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
@ -310,7 +308,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
} }
Assert.assertTrue(set.retainAll(Arrays.asList(1, 2))); Assert.assertTrue(set.retainAll(Arrays.asList(1, 2)));
Assert.assertThat(set, Matchers.containsInAnyOrder(1, 2)); assertThat(set).containsExactly(1, 2);
Assert.assertEquals(2, set.size()); Assert.assertEquals(2, set.size());
assertThat(set.getScore(1)).isEqualTo(10); assertThat(set.getScore(1)).isEqualTo(10);
assertThat(set.getScore(2)).isEqualTo(20); assertThat(set.getScore(2)).isEqualTo(20);
@ -324,7 +322,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(0.3, 3); set.add(0.3, 3);
Assert.assertTrue(set.removeAll(Arrays.asList(1, 2))); Assert.assertTrue(set.removeAll(Arrays.asList(1, 2)));
Assert.assertThat(set, Matchers.contains(3)); assertThat(set).containsOnly(3);
Assert.assertEquals(1, set.size()); Assert.assertEquals(1, set.size());
} }
@ -342,15 +340,15 @@ public class RedissonScoredSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.tailSet(3); SortedSet<Integer> hs = set.tailSet(3);
hs.add(10); hs.add(10);
MatcherAssert.assertThat(hs, Matchers.contains(3, 4, 5, 10)); assertThat(hs).containsExactly(3, 4, 5, 10);
set.remove(4); set.remove(4);
MatcherAssert.assertThat(hs, Matchers.contains(3, 5, 10)); assertThat(hs).containsExactly(3, 5, 10);
set.remove(3); set.remove(3);
MatcherAssert.assertThat(hs, Matchers.contains(5, 10)); assertThat(hs).containsExactly(5, 10);
hs.add(-1); hs.add(-1);
} }
@ -369,15 +367,15 @@ public class RedissonScoredSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.headSet(3); SortedSet<Integer> hs = set.headSet(3);
hs.add(0); hs.add(0);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1, 2)); assertThat(hs).containsExactly(0, 1, 2);
set.remove(2); set.remove(2);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1)); assertThat(hs).containsExactly(0, 1);
set.remove(3); set.remove(3);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1)); assertThat(hs).containsExactly(0, 1);
hs.add(7); hs.add(7);
} }
@ -395,15 +393,15 @@ public class RedissonScoredSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.tailSet(3); SortedSet<Integer> hs = set.tailSet(3);
hs.add(10); hs.add(10);
MatcherAssert.assertThat(hs, Matchers.contains(3, 4, 5, 10)); assertThat(hs).containsExactly(3, 4, 5, 10);
set.remove(4); set.remove(4);
MatcherAssert.assertThat(hs, Matchers.contains(3, 5, 10)); assertThat(hs).containsExactly(3, 5, 10);
set.remove(3); set.remove(3);
MatcherAssert.assertThat(hs, Matchers.contains(5, 10)); assertThat(hs).containsExactly(5, 10);
hs.add(-1); hs.add(-1);
} }
@ -421,15 +419,15 @@ public class RedissonScoredSortedSetTest extends BaseTest {
SortedSet<Integer> hs = set.headSet(3); SortedSet<Integer> hs = set.headSet(3);
hs.add(0); hs.add(0);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1, 2)); assertThat(hs).containsExactly(0, 1, 2);
set.remove(2); set.remove(2);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1)); assertThat(hs).containsExactly(0, 1);
set.remove(3); set.remove(3);
MatcherAssert.assertThat(hs, Matchers.contains(0, 1)); assertThat(hs).containsExactly(0, 1);
hs.add(7); hs.add(7);
} }
@ -445,10 +443,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
Assert.assertTrue(set.add(1, -1)); Assert.assertTrue(set.add(1, -1));
Assert.assertTrue(set.add(2, 0)); Assert.assertTrue(set.add(2, 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());
} }
@Test @Test
@ -463,7 +458,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
Assert.assertFalse(set.remove(0)); Assert.assertFalse(set.remove(0));
Assert.assertTrue(set.remove(3)); Assert.assertTrue(set.remove(3));
Assert.assertThat(set, Matchers.contains(1, 2, 4, 5)); assertThat(set).containsExactly(1, 2, 4, 5);
} }
@Test @Test
@ -486,10 +481,10 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(3, "5"); set.add(3, "5");
set.add(4, "3"); set.add(4, "3");
MatcherAssert.assertThat(Arrays.asList(set.toArray()), Matchers.<Object>containsInAnyOrder("1", "2", "4", "5", "3")); assertThat(Arrays.asList(set.toArray())).containsExactly("1", "4", "2", "5", "3");
String[] strs = set.toArray(new String[0]); String[] strs = set.toArray(new String[0]);
MatcherAssert.assertThat(Arrays.asList(strs), Matchers.containsInAnyOrder("1", "4", "2", "5", "3")); assertThat(Arrays.asList(strs)).containsExactly("1", "4", "2", "5", "3");
} }
@Test @Test
@ -545,7 +540,7 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(4, 5); set.add(4, 5);
Collection<Integer> vals = set.valueRange(0, -1); Collection<Integer> vals = set.valueRange(0, -1);
MatcherAssert.assertThat(vals, Matchers.contains(1, 2, 3, 4, 5)); assertThat(vals).containsExactly(1, 2, 3, 4, 5);
} }
@Test @Test
@ -558,11 +553,11 @@ public class RedissonScoredSortedSetTest extends BaseTest {
set.add(50, 5); set.add(50, 5);
Collection<ScoredEntry<Integer>> vals = set.entryRange(0, -1); Collection<ScoredEntry<Integer>> vals = set.entryRange(0, -1);
MatcherAssert.assertThat(vals, Matchers.contains(new ScoredEntry<Integer>(10D, 1), assertThat(vals).containsExactly(new ScoredEntry<Integer>(10D, 1),
new ScoredEntry<Integer>(20D, 2), new ScoredEntry<Integer>(20D, 2),
new ScoredEntry<Integer>(30D, 3), new ScoredEntry<Integer>(30D, 3),
new ScoredEntry<Integer>(40D, 4), new ScoredEntry<Integer>(40D, 4),
new ScoredEntry<Integer>(50D, 5))); new ScoredEntry<Integer>(50D, 5));
} }
@Test @Test

Write Preview
Loading…
Cancel
Save