rik/jlibredis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

getIntegerReply should return Integer and not int to support null replies

Browse Source
This commit is contained in:
Jonathan Leibiusky
2010-11-02 12:33:28 -03:00
parent d70c42edb9
commit 07f5820a32
2 changed files with 209 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/redis/clients/jedis/Connection.java
View File

@@ -126,9 +126,9 @@ public class Connection {
return (String) protocol.read(inputStream); return (String) protocol.read(inputStream);
} }
public int getIntegerReply() { public Integer getIntegerReply() {
pipelinedCommands--; pipelinedCommands--;
return ((Integer) protocol.read(inputStream)).intValue(); return (Integer) protocol.read(inputStream);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")

409
src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
View File

@@ -11,360 +11,363 @@ import redis.clients.jedis.ZParams;
public class SortedSetCommandsTest extends JedisCommandTestBase { public class SortedSetCommandsTest extends JedisCommandTestBase {
@Test @Test
public void zadd() { public void zadd() {
int status = jedis.zadd("foo", 1d, "a"); int status = jedis.zadd("foo", 1d, "a");
assertEquals(1, status); assertEquals(1, status);
status = jedis.zadd("foo", 10d, "b"); status = jedis.zadd("foo", 10d, "b");
assertEquals(1, status); assertEquals(1, status);
status = jedis.zadd("foo", 0.1d, "c"); status = jedis.zadd("foo", 0.1d, "c");
assertEquals(1, status); assertEquals(1, status);
status = jedis.zadd("foo", 2d, "a"); status = jedis.zadd("foo", 2d, "a");
assertEquals(0, status); assertEquals(0, status);
} }
@Test @Test
public void zrange() { public void zrange() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("c"); expected.add("c");
expected.add("a"); expected.add("a");
Set<String> range = jedis.zrange("foo", 0, 1); Set<String> range = jedis.zrange("foo", 0, 1);
assertEquals(expected, range); assertEquals(expected, range);
expected.add("b"); expected.add("b");
range = jedis.zrange("foo", 0, 100); range = jedis.zrange("foo", 0, 100);
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zrevrange() { public void zrevrange() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("b"); expected.add("b");
expected.add("a"); expected.add("a");
Set<String> range = jedis.zrevrange("foo", 0, 1); Set<String> range = jedis.zrevrange("foo", 0, 1);
assertEquals(expected, range); assertEquals(expected, range);
expected.add("c"); expected.add("c");
range = jedis.zrevrange("foo", 0, 100); range = jedis.zrevrange("foo", 0, 100);
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zrem() { public void zrem() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 2d, "b"); jedis.zadd("foo", 2d, "b");
int status = jedis.zrem("foo", "a"); int status = jedis.zrem("foo", "a");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("b"); expected.add("b");
assertEquals(1, status); assertEquals(1, status);
assertEquals(expected, jedis.zrange("foo", 0, 100)); assertEquals(expected, jedis.zrange("foo", 0, 100));
status = jedis.zrem("foo", "bar"); status = jedis.zrem("foo", "bar");
assertEquals(0, status); assertEquals(0, status);
} }
@Test @Test
public void zincrby() { public void zincrby() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 2d, "b"); jedis.zadd("foo", 2d, "b");
double score = jedis.zincrby("foo", 2d, "a"); double score = jedis.zincrby("foo", 2d, "a");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
assertEquals(3d, score); assertEquals(3d, score);
assertEquals(expected, jedis.zrange("foo", 0, 100)); assertEquals(expected, jedis.zrange("foo", 0, 100));
} }
@Test @Test
public void zrank() { public void zrank() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 2d, "b"); jedis.zadd("foo", 2d, "b");
int rank = jedis.zrank("foo", "a"); Integer rank = jedis.zrank("foo", "a");
assertEquals(0, rank); assertEquals(0, rank.intValue());
rank = jedis.zrank("foo", "b"); rank = jedis.zrank("foo", "b");
assertEquals(1, rank); assertEquals(1, rank.intValue());
rank = jedis.zrank("car", "b");
assertNull(rank);
} }
@Test @Test
public void zrevrank() { public void zrevrank() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 2d, "b"); jedis.zadd("foo", 2d, "b");
int rank = jedis.zrevrank("foo", "a"); int rank = jedis.zrevrank("foo", "a");
assertEquals(1, rank); assertEquals(1, rank);
rank = jedis.zrevrank("foo", "b"); rank = jedis.zrevrank("foo", "b");
assertEquals(0, rank); assertEquals(0, rank);
} }
@Test @Test
public void zrangeWithScores() { public void zrangeWithScores() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("c", 0.1d)); expected.add(new Tuple("c", 0.1d));
expected.add(new Tuple("a", 2d)); expected.add(new Tuple("a", 2d));
Set<Tuple> range = jedis.zrangeWithScores("foo", 0, 1); Set<Tuple> range = jedis.zrangeWithScores("foo", 0, 1);
assertEquals(expected, range); assertEquals(expected, range);
expected.add(new Tuple("b", 10d)); expected.add(new Tuple("b", 10d));
range = jedis.zrangeWithScores("foo", 0, 100); range = jedis.zrangeWithScores("foo", 0, 100);
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zrevrangeWithScores() { public void zrevrangeWithScores() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("b", 10d)); expected.add(new Tuple("b", 10d));
expected.add(new Tuple("a", 2d)); expected.add(new Tuple("a", 2d));
Set<Tuple> range = jedis.zrevrangeWithScores("foo", 0, 1); Set<Tuple> range = jedis.zrevrangeWithScores("foo", 0, 1);
assertEquals(expected, range); assertEquals(expected, range);
expected.add(new Tuple("c", 0.1d)); expected.add(new Tuple("c", 0.1d));
range = jedis.zrevrangeWithScores("foo", 0, 100); range = jedis.zrevrangeWithScores("foo", 0, 100);
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zcard() { public void zcard() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
int size = jedis.zcard("foo"); int size = jedis.zcard("foo");
assertEquals(3, size); assertEquals(3, size);
} }
@Test @Test
public void zscore() { public void zscore() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Double score = jedis.zscore("foo", "b"); Double score = jedis.zscore("foo", "b");
assertEquals(10d, score); assertEquals(10d, score);
score = jedis.zscore("foo", "c"); score = jedis.zscore("foo", "c");
assertEquals(0.1d, score); assertEquals(0.1d, score);
score = jedis.zscore("foo", "s"); score = jedis.zscore("foo", "s");
assertNull(score); assertNull(score);
} }
@Test @Test
public void zcount() { public void zcount() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
int result = jedis.zcount("foo", 0.01d, 2.1d); int result = jedis.zcount("foo", 0.01d, 2.1d);
assertEquals(2, result); assertEquals(2, result);
} }
@Test @Test
public void zrangebyscore() { public void zrangebyscore() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<String> range = jedis.zrangeByScore("foo", 0d, 2d); Set<String> range = jedis.zrangeByScore("foo", 0d, 2d);
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("c"); expected.add("c");
expected.add("a"); expected.add("a");
assertEquals(expected, range); assertEquals(expected, range);
range = jedis.zrangeByScore("foo", 0d, 2d, 0, 1); range = jedis.zrangeByScore("foo", 0d, 2d, 0, 1);
expected = new LinkedHashSet<String>(); expected = new LinkedHashSet<String>();
expected.add("c"); expected.add("c");
assertEquals(expected, range); assertEquals(expected, range);
range = jedis.zrangeByScore("foo", 0d, 2d, 1, 1); range = jedis.zrangeByScore("foo", 0d, 2d, 1, 1);
Set<String> range2 = jedis.zrangeByScore("foo", "-inf", "(2"); Set<String> range2 = jedis.zrangeByScore("foo", "-inf", "(2");
assertEquals(expected, range2); assertEquals(expected, range2);
expected = new LinkedHashSet<String>(); expected = new LinkedHashSet<String>();
expected.add("a"); expected.add("a");
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zrangebyscoreWithScores() { public void zrangebyscoreWithScores() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
Set<Tuple> range = jedis.zrangeByScoreWithScores("foo", 0d, 2d); Set<Tuple> range = jedis.zrangeByScoreWithScores("foo", 0d, 2d);
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("c", 0.1d)); expected.add(new Tuple("c", 0.1d));
expected.add(new Tuple("a", 2d)); expected.add(new Tuple("a", 2d));
assertEquals(expected, range); assertEquals(expected, range);
range = jedis.zrangeByScoreWithScores("foo", 0d, 2d, 0, 1); range = jedis.zrangeByScoreWithScores("foo", 0d, 2d, 0, 1);
expected = new LinkedHashSet<Tuple>(); expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("c", 0.1d)); expected.add(new Tuple("c", 0.1d));
assertEquals(expected, range); assertEquals(expected, range);
range = jedis.zrangeByScoreWithScores("foo", 0d, 2d, 1, 1); range = jedis.zrangeByScoreWithScores("foo", 0d, 2d, 1, 1);
expected = new LinkedHashSet<Tuple>(); expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("a", 2d)); expected.add(new Tuple("a", 2d));
assertEquals(expected, range); assertEquals(expected, range);
} }
@Test @Test
public void zremrangeByRank() { public void zremrangeByRank() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
int result = jedis.zremrangeByRank("foo", 0, 0); int result = jedis.zremrangeByRank("foo", 0, 0);
assertEquals(1, result); assertEquals(1, result);
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("a"); expected.add("a");
expected.add("b"); expected.add("b");
assertEquals(expected, jedis.zrange("foo", 0, 100)); assertEquals(expected, jedis.zrange("foo", 0, 100));
} }
@Test @Test
public void zremrangeByScore() { public void zremrangeByScore() {
jedis.zadd("foo", 1d, "a"); jedis.zadd("foo", 1d, "a");
jedis.zadd("foo", 10d, "b"); jedis.zadd("foo", 10d, "b");
jedis.zadd("foo", 0.1d, "c"); jedis.zadd("foo", 0.1d, "c");
jedis.zadd("foo", 2d, "a"); jedis.zadd("foo", 2d, "a");
int result = jedis.zremrangeByScore("foo", 0, 2); int result = jedis.zremrangeByScore("foo", 0, 2);
assertEquals(2, result); assertEquals(2, result);
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("b"); expected.add("b");
assertEquals(expected, jedis.zrange("foo", 0, 100)); assertEquals(expected, jedis.zrange("foo", 0, 100));
} }
@Test @Test
public void zunionstore() { public void zunionstore() {
jedis.zadd("foo", 1, "a"); jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 2, "b"); jedis.zadd("foo", 2, "b");
jedis.zadd("bar", 2, "a"); jedis.zadd("bar", 2, "a");
jedis.zadd("bar", 2, "b"); jedis.zadd("bar", 2, "b");
int result = jedis.zunionstore("dst", "foo", "bar"); int result = jedis.zunionstore("dst", "foo", "bar");
assertEquals(2, result); assertEquals(2, result);
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("b", new Double(4))); expected.add(new Tuple("b", new Double(4)));
expected.add(new Tuple("a", new Double(3))); expected.add(new Tuple("a", new Double(3)));
assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100)); assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
} }
@Test @Test
public void zunionstoreParams() { public void zunionstoreParams() {
jedis.zadd("foo", 1, "a"); jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 2, "b"); jedis.zadd("foo", 2, "b");
jedis.zadd("bar", 2, "a"); jedis.zadd("bar", 2, "a");
jedis.zadd("bar", 2, "b"); jedis.zadd("bar", 2, "b");
ZParams params = new ZParams(); ZParams params = new ZParams();
params.weights(2, 2); params.weights(2, 2);
params.aggregate(ZParams.Aggregate.SUM); params.aggregate(ZParams.Aggregate.SUM);
int result = jedis.zunionstore("dst", params, "foo", "bar"); int result = jedis.zunionstore("dst", params, "foo", "bar");
assertEquals(2, result); assertEquals(2, result);
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("b", new Double(8))); expected.add(new Tuple("b", new Double(8)));
expected.add(new Tuple("a", new Double(6))); expected.add(new Tuple("a", new Double(6)));
assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100)); assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
} }
@Test @Test
public void zinterstore() { public void zinterstore() {
jedis.zadd("foo", 1, "a"); jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 2, "b"); jedis.zadd("foo", 2, "b");
jedis.zadd("bar", 2, "a"); jedis.zadd("bar", 2, "a");
int result = jedis.zinterstore("dst", "foo", "bar"); int result = jedis.zinterstore("dst", "foo", "bar");
assertEquals(1, result); assertEquals(1, result);
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("a", new Double(3))); expected.add(new Tuple("a", new Double(3)));
assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100)); assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
} }
@Test @Test
public void zintertoreParams() { public void zintertoreParams() {
jedis.zadd("foo", 1, "a"); jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 2, "b"); jedis.zadd("foo", 2, "b");
jedis.zadd("bar", 2, "a"); jedis.zadd("bar", 2, "a");
ZParams params = new ZParams(); ZParams params = new ZParams();
params.weights(2, 2); params.weights(2, 2);
params.aggregate(ZParams.Aggregate.SUM); params.aggregate(ZParams.Aggregate.SUM);
int result = jedis.zinterstore("dst", params, "foo", "bar"); int result = jedis.zinterstore("dst", params, "foo", "bar");
assertEquals(1, result); assertEquals(1, result);
Set<Tuple> expected = new LinkedHashSet<Tuple>(); Set<Tuple> expected = new LinkedHashSet<Tuple>();
expected.add(new Tuple("a", new Double(6))); expected.add(new Tuple("a", new Double(6)));
assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100)); assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
} }
} }