add SCAN, HSCAN, SSCAN and ZSCAN
This commit is contained in:
Jonathan Leibiusky
@@ -6,6 +6,8 @@ import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import redis.clients.jedis.ScanParams;
|
||||
import redis.clients.jedis.ScanResult;
|
||||
import redis.clients.jedis.exceptions.JedisDataException;
|
||||
import redis.clients.util.SafeEncoder;
|
||||
|
||||
@@ -25,482 +27,520 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
|
||||
|
||||
@Test
|
||||
public void ping() {
|
||||
String status = jedis.ping();
|
||||
assertEquals("PONG", status);
|
||||
String status = jedis.ping();
|
||||
assertEquals("PONG", status);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void exists() {
|
||||
String status = jedis.set("foo", "bar");
|
||||
assertEquals("OK", status);
|
||||
String status = jedis.set("foo", "bar");
|
||||
assertEquals("OK", status);
|
||||
|
||||
status = jedis.set(bfoo, bbar);
|
||||
assertEquals("OK", status);
|
||||
status = jedis.set(bfoo, bbar);
|
||||
assertEquals("OK", status);
|
||||
|
||||
boolean reply = jedis.exists("foo");
|
||||
assertTrue(reply);
|
||||
boolean reply = jedis.exists("foo");
|
||||
assertTrue(reply);
|
||||
|
||||
reply = jedis.exists(bfoo);
|
||||
assertTrue(reply);
|
||||
reply = jedis.exists(bfoo);
|
||||
assertTrue(reply);
|
||||
|
||||
long lreply = jedis.del("foo");
|
||||
assertEquals(1, lreply);
|
||||
long lreply = jedis.del("foo");
|
||||
assertEquals(1, lreply);
|
||||
|
||||
lreply = jedis.del(bfoo);
|
||||
assertEquals(1, lreply);
|
||||
lreply = jedis.del(bfoo);
|
||||
assertEquals(1, lreply);
|
||||
|
||||
reply = jedis.exists("foo");
|
||||
assertFalse(reply);
|
||||
reply = jedis.exists("foo");
|
||||
assertFalse(reply);
|
||||
|
||||
reply = jedis.exists(bfoo);
|
||||
assertFalse(reply);
|
||||
reply = jedis.exists(bfoo);
|
||||
assertFalse(reply);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void del() {
|
||||
jedis.set("foo1", "bar1");
|
||||
jedis.set("foo2", "bar2");
|
||||
jedis.set("foo3", "bar3");
|
||||
jedis.set("foo1", "bar1");
|
||||
jedis.set("foo2", "bar2");
|
||||
jedis.set("foo3", "bar3");
|
||||
|
||||
long reply = jedis.del("foo1", "foo2", "foo3");
|
||||
assertEquals(3, reply);
|
||||
long reply = jedis.del("foo1", "foo2", "foo3");
|
||||
assertEquals(3, reply);
|
||||
|
||||
Boolean breply = jedis.exists("foo1");
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists("foo2");
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists("foo3");
|
||||
assertFalse(breply);
|
||||
Boolean breply = jedis.exists("foo1");
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists("foo2");
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists("foo3");
|
||||
assertFalse(breply);
|
||||
|
||||
jedis.set("foo1", "bar1");
|
||||
jedis.set("foo1", "bar1");
|
||||
|
||||
reply = jedis.del("foo1", "foo2");
|
||||
assertEquals(1, reply);
|
||||
reply = jedis.del("foo1", "foo2");
|
||||
assertEquals(1, reply);
|
||||
|
||||
reply = jedis.del("foo1", "foo2");
|
||||
assertEquals(0, reply);
|
||||
reply = jedis.del("foo1", "foo2");
|
||||
assertEquals(0, reply);
|
||||
|
||||
// Binary ...
|
||||
jedis.set(bfoo1, bbar1);
|
||||
jedis.set(bfoo2, bbar2);
|
||||
jedis.set(bfoo3, bbar3);
|
||||
// Binary ...
|
||||
jedis.set(bfoo1, bbar1);
|
||||
jedis.set(bfoo2, bbar2);
|
||||
jedis.set(bfoo3, bbar3);
|
||||
|
||||
reply = jedis.del(bfoo1, bfoo2, bfoo3);
|
||||
assertEquals(3, reply);
|
||||
reply = jedis.del(bfoo1, bfoo2, bfoo3);
|
||||
assertEquals(3, reply);
|
||||
|
||||
breply = jedis.exists(bfoo1);
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists(bfoo2);
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists(bfoo3);
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists(bfoo1);
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists(bfoo2);
|
||||
assertFalse(breply);
|
||||
breply = jedis.exists(bfoo3);
|
||||
assertFalse(breply);
|
||||
|
||||
jedis.set(bfoo1, bbar1);
|
||||
jedis.set(bfoo1, bbar1);
|
||||
|
||||
reply = jedis.del(bfoo1, bfoo2);
|
||||
assertEquals(1, reply);
|
||||
reply = jedis.del(bfoo1, bfoo2);
|
||||
assertEquals(1, reply);
|
||||
|
||||
reply = jedis.del(bfoo1, bfoo2);
|
||||
assertEquals(0, reply);
|
||||
reply = jedis.del(bfoo1, bfoo2);
|
||||
assertEquals(0, reply);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void type() {
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.type("foo");
|
||||
assertEquals("string", status);
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.type("foo");
|
||||
assertEquals("string", status);
|
||||
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
status = jedis.type(bfoo);
|
||||
assertEquals("string", status);
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
status = jedis.type(bfoo);
|
||||
assertEquals("string", status);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void keys() {
|
||||
jedis.set("foo", "bar");
|
||||
jedis.set("foobar", "bar");
|
||||
jedis.set("foo", "bar");
|
||||
jedis.set("foobar", "bar");
|
||||
|
||||
Set<String> keys = jedis.keys("foo*");
|
||||
Set<String> expected = new HashSet<String>();
|
||||
expected.add("foo");
|
||||
expected.add("foobar");
|
||||
assertEquals(expected, keys);
|
||||
Set<String> keys = jedis.keys("foo*");
|
||||
Set<String> expected = new HashSet<String>();
|
||||
expected.add("foo");
|
||||
expected.add("foobar");
|
||||
assertEquals(expected, keys);
|
||||
|
||||
expected = new HashSet<String>();
|
||||
keys = jedis.keys("bar*");
|
||||
expected = new HashSet<String>();
|
||||
keys = jedis.keys("bar*");
|
||||
|
||||
assertEquals(expected, keys);
|
||||
assertEquals(expected, keys);
|
||||
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
jedis.set(bfoobar, bbar);
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
jedis.set(bfoobar, bbar);
|
||||
|
||||
Set<byte[]> bkeys = jedis.keys(bfoostar);
|
||||
assertEquals(2, bkeys.size());
|
||||
assertTrue(setContains(bkeys, bfoo));
|
||||
assertTrue(setContains(bkeys, bfoobar));
|
||||
Set<byte[]> bkeys = jedis.keys(bfoostar);
|
||||
assertEquals(2, bkeys.size());
|
||||
assertTrue(setContains(bkeys, bfoo));
|
||||
assertTrue(setContains(bkeys, bfoobar));
|
||||
|
||||
bkeys = jedis.keys(bbarstar);
|
||||
bkeys = jedis.keys(bbarstar);
|
||||
|
||||
assertEquals(0, bkeys.size());
|
||||
assertEquals(0, bkeys.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void randomKey() {
|
||||
assertEquals(null, jedis.randomKey());
|
||||
assertEquals(null, jedis.randomKey());
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
jedis.set("foo", "bar");
|
||||
|
||||
assertEquals("foo", jedis.randomKey());
|
||||
assertEquals("foo", jedis.randomKey());
|
||||
|
||||
jedis.set("bar", "foo");
|
||||
jedis.set("bar", "foo");
|
||||
|
||||
String randomkey = jedis.randomKey();
|
||||
assertTrue(randomkey.equals("foo") || randomkey.equals("bar"));
|
||||
String randomkey = jedis.randomKey();
|
||||
assertTrue(randomkey.equals("foo") || randomkey.equals("bar"));
|
||||
|
||||
// Binary
|
||||
jedis.del("foo");
|
||||
jedis.del("bar");
|
||||
assertEquals(null, jedis.randomKey());
|
||||
// Binary
|
||||
jedis.del("foo");
|
||||
jedis.del("bar");
|
||||
assertEquals(null, jedis.randomKey());
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
jedis.set(bfoo, bbar);
|
||||
|
||||
assertArrayEquals(bfoo, jedis.randomBinaryKey());
|
||||
assertArrayEquals(bfoo, jedis.randomBinaryKey());
|
||||
|
||||
jedis.set(bbar, bfoo);
|
||||
jedis.set(bbar, bfoo);
|
||||
|
||||
byte[] randomBkey = jedis.randomBinaryKey();
|
||||
assertTrue(Arrays.equals(randomBkey, bfoo)
|
||||
|| Arrays.equals(randomBkey, bbar));
|
||||
byte[] randomBkey = jedis.randomBinaryKey();
|
||||
assertTrue(Arrays.equals(randomBkey, bfoo)
|
||||
|| Arrays.equals(randomBkey, bbar));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void rename() {
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.rename("foo", "bar");
|
||||
assertEquals("OK", status);
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.rename("foo", "bar");
|
||||
assertEquals("OK", status);
|
||||
|
||||
String value = jedis.get("foo");
|
||||
assertEquals(null, value);
|
||||
String value = jedis.get("foo");
|
||||
assertEquals(null, value);
|
||||
|
||||
value = jedis.get("bar");
|
||||
assertEquals("bar", value);
|
||||
value = jedis.get("bar");
|
||||
assertEquals("bar", value);
|
||||
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
String bstatus = jedis.rename(bfoo, bbar);
|
||||
assertEquals("OK", bstatus);
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
String bstatus = jedis.rename(bfoo, bbar);
|
||||
assertEquals("OK", bstatus);
|
||||
|
||||
byte[] bvalue = jedis.get(bfoo);
|
||||
assertEquals(null, bvalue);
|
||||
byte[] bvalue = jedis.get(bfoo);
|
||||
assertEquals(null, bvalue);
|
||||
|
||||
bvalue = jedis.get(bbar);
|
||||
assertArrayEquals(bbar, bvalue);
|
||||
bvalue = jedis.get(bbar);
|
||||
assertArrayEquals(bbar, bvalue);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void renameOldAndNewAreTheSame() {
|
||||
try {
|
||||
jedis.set("foo", "bar");
|
||||
jedis.rename("foo", "foo");
|
||||
fail("JedisDataException expected");
|
||||
} catch (final JedisDataException e) {
|
||||
}
|
||||
try {
|
||||
jedis.set("foo", "bar");
|
||||
jedis.rename("foo", "foo");
|
||||
fail("JedisDataException expected");
|
||||
} catch (final JedisDataException e) {
|
||||
}
|
||||
|
||||
// Binary
|
||||
try {
|
||||
jedis.set(bfoo, bbar);
|
||||
jedis.rename(bfoo, bfoo);
|
||||
fail("JedisDataException expected");
|
||||
} catch (final JedisDataException e) {
|
||||
}
|
||||
// Binary
|
||||
try {
|
||||
jedis.set(bfoo, bbar);
|
||||
jedis.rename(bfoo, bfoo);
|
||||
fail("JedisDataException expected");
|
||||
} catch (final JedisDataException e) {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void renamenx() {
|
||||
jedis.set("foo", "bar");
|
||||
long status = jedis.renamenx("foo", "bar");
|
||||
assertEquals(1, status);
|
||||
jedis.set("foo", "bar");
|
||||
long status = jedis.renamenx("foo", "bar");
|
||||
assertEquals(1, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.renamenx("foo", "bar");
|
||||
assertEquals(0, status);
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.renamenx("foo", "bar");
|
||||
assertEquals(0, status);
|
||||
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
long bstatus = jedis.renamenx(bfoo, bbar);
|
||||
assertEquals(1, bstatus);
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
long bstatus = jedis.renamenx(bfoo, bbar);
|
||||
assertEquals(1, bstatus);
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.renamenx(bfoo, bbar);
|
||||
assertEquals(0, bstatus);
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.renamenx(bfoo, bbar);
|
||||
assertEquals(0, bstatus);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dbSize() {
|
||||
long size = jedis.dbSize();
|
||||
assertEquals(0, size);
|
||||
long size = jedis.dbSize();
|
||||
assertEquals(0, size);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
size = jedis.dbSize();
|
||||
assertEquals(1, size);
|
||||
jedis.set("foo", "bar");
|
||||
size = jedis.dbSize();
|
||||
assertEquals(1, size);
|
||||
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
size = jedis.dbSize();
|
||||
assertEquals(2, size);
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
size = jedis.dbSize();
|
||||
assertEquals(2, size);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void expire() {
|
||||
long status = jedis.expire("foo", 20);
|
||||
assertEquals(0, status);
|
||||
long status = jedis.expire("foo", 20);
|
||||
assertEquals(0, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.expire("foo", 20);
|
||||
assertEquals(1, status);
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.expire("foo", 20);
|
||||
assertEquals(1, status);
|
||||
|
||||
// Binary
|
||||
long bstatus = jedis.expire(bfoo, 20);
|
||||
assertEquals(0, bstatus);
|
||||
// Binary
|
||||
long bstatus = jedis.expire(bfoo, 20);
|
||||
assertEquals(0, bstatus);
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.expire(bfoo, 20);
|
||||
assertEquals(1, bstatus);
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.expire(bfoo, 20);
|
||||
assertEquals(1, bstatus);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void expireAt() {
|
||||
long unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
long unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
|
||||
long status = jedis.expireAt("foo", unixTime);
|
||||
assertEquals(0, status);
|
||||
long status = jedis.expireAt("foo", unixTime);
|
||||
assertEquals(0, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
status = jedis.expireAt("foo", unixTime);
|
||||
assertEquals(1, status);
|
||||
jedis.set("foo", "bar");
|
||||
unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
status = jedis.expireAt("foo", unixTime);
|
||||
assertEquals(1, status);
|
||||
|
||||
// Binary
|
||||
long bstatus = jedis.expireAt(bfoo, unixTime);
|
||||
assertEquals(0, bstatus);
|
||||
// Binary
|
||||
long bstatus = jedis.expireAt(bfoo, unixTime);
|
||||
assertEquals(0, bstatus);
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
bstatus = jedis.expireAt(bfoo, unixTime);
|
||||
assertEquals(1, bstatus);
|
||||
jedis.set(bfoo, bbar);
|
||||
unixTime = (System.currentTimeMillis() / 1000L) + 20;
|
||||
bstatus = jedis.expireAt(bfoo, unixTime);
|
||||
assertEquals(1, bstatus);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void ttl() {
|
||||
long ttl = jedis.ttl("foo");
|
||||
assertEquals(-2, ttl);
|
||||
long ttl = jedis.ttl("foo");
|
||||
assertEquals(-2, ttl);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
ttl = jedis.ttl("foo");
|
||||
assertEquals(-1, ttl);
|
||||
jedis.set("foo", "bar");
|
||||
ttl = jedis.ttl("foo");
|
||||
assertEquals(-1, ttl);
|
||||
|
||||
jedis.expire("foo", 20);
|
||||
ttl = jedis.ttl("foo");
|
||||
assertTrue(ttl >= 0 && ttl <= 20);
|
||||
jedis.expire("foo", 20);
|
||||
ttl = jedis.ttl("foo");
|
||||
assertTrue(ttl >= 0 && ttl <= 20);
|
||||
|
||||
// Binary
|
||||
long bttl = jedis.ttl(bfoo);
|
||||
assertEquals(-2, bttl);
|
||||
// Binary
|
||||
long bttl = jedis.ttl(bfoo);
|
||||
assertEquals(-2, bttl);
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
bttl = jedis.ttl(bfoo);
|
||||
assertEquals(-1, bttl);
|
||||
jedis.set(bfoo, bbar);
|
||||
bttl = jedis.ttl(bfoo);
|
||||
assertEquals(-1, bttl);
|
||||
|
||||
jedis.expire(bfoo, 20);
|
||||
bttl = jedis.ttl(bfoo);
|
||||
assertTrue(bttl >= 0 && bttl <= 20);
|
||||
jedis.expire(bfoo, 20);
|
||||
bttl = jedis.ttl(bfoo);
|
||||
assertTrue(bttl >= 0 && bttl <= 20);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void select() {
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.select(1);
|
||||
assertEquals("OK", status);
|
||||
assertEquals(null, jedis.get("foo"));
|
||||
status = jedis.select(0);
|
||||
assertEquals("OK", status);
|
||||
assertEquals("bar", jedis.get("foo"));
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
String bstatus = jedis.select(1);
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(null, jedis.get(bfoo));
|
||||
bstatus = jedis.select(0);
|
||||
assertEquals("OK", bstatus);
|
||||
assertArrayEquals(bbar, jedis.get(bfoo));
|
||||
jedis.set("foo", "bar");
|
||||
String status = jedis.select(1);
|
||||
assertEquals("OK", status);
|
||||
assertEquals(null, jedis.get("foo"));
|
||||
status = jedis.select(0);
|
||||
assertEquals("OK", status);
|
||||
assertEquals("bar", jedis.get("foo"));
|
||||
// Binary
|
||||
jedis.set(bfoo, bbar);
|
||||
String bstatus = jedis.select(1);
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(null, jedis.get(bfoo));
|
||||
bstatus = jedis.select(0);
|
||||
assertEquals("OK", bstatus);
|
||||
assertArrayEquals(bbar, jedis.get(bfoo));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getDB() {
|
||||
assertEquals(0, jedis.getDB().longValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.getDB().longValue());
|
||||
assertEquals(0, jedis.getDB().longValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.getDB().longValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void move() {
|
||||
long status = jedis.move("foo", 1);
|
||||
assertEquals(0, status);
|
||||
long status = jedis.move("foo", 1);
|
||||
assertEquals(0, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.move("foo", 1);
|
||||
assertEquals(1, status);
|
||||
assertEquals(null, jedis.get("foo"));
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.move("foo", 1);
|
||||
assertEquals(1, status);
|
||||
assertEquals(null, jedis.get("foo"));
|
||||
|
||||
jedis.select(1);
|
||||
assertEquals("bar", jedis.get("foo"));
|
||||
jedis.select(1);
|
||||
assertEquals("bar", jedis.get("foo"));
|
||||
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
long bstatus = jedis.move(bfoo, 1);
|
||||
assertEquals(0, bstatus);
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
long bstatus = jedis.move(bfoo, 1);
|
||||
assertEquals(0, bstatus);
|
||||
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.move(bfoo, 1);
|
||||
assertEquals(1, bstatus);
|
||||
assertEquals(null, jedis.get(bfoo));
|
||||
jedis.set(bfoo, bbar);
|
||||
bstatus = jedis.move(bfoo, 1);
|
||||
assertEquals(1, bstatus);
|
||||
assertEquals(null, jedis.get(bfoo));
|
||||
|
||||
jedis.select(1);
|
||||
assertArrayEquals(bbar, jedis.get(bfoo));
|
||||
jedis.select(1);
|
||||
assertArrayEquals(bbar, jedis.get(bfoo));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void flushDB() {
|
||||
jedis.set("foo", "bar");
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set("bar", "foo");
|
||||
jedis.move("bar", 1);
|
||||
String status = jedis.flushDB();
|
||||
assertEquals("OK", status);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.del("bar");
|
||||
jedis.set("foo", "bar");
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set("bar", "foo");
|
||||
jedis.move("bar", 1);
|
||||
String status = jedis.flushDB();
|
||||
assertEquals("OK", status);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.del("bar");
|
||||
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
jedis.set(bfoo, bbar);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set(bbar, bfoo);
|
||||
jedis.move(bbar, 1);
|
||||
String bstatus = jedis.flushDB();
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
jedis.set(bfoo, bbar);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set(bbar, bfoo);
|
||||
jedis.move(bbar, 1);
|
||||
String bstatus = jedis.flushDB();
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void flushAll() {
|
||||
jedis.set("foo", "bar");
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set("bar", "foo");
|
||||
jedis.move("bar", 1);
|
||||
String status = jedis.flushAll();
|
||||
assertEquals("OK", status);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.set("foo", "bar");
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set("bar", "foo");
|
||||
jedis.move("bar", 1);
|
||||
String status = jedis.flushAll();
|
||||
assertEquals("OK", status);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
jedis.set(bfoo, bbar);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set(bbar, bfoo);
|
||||
jedis.move(bbar, 1);
|
||||
String bstatus = jedis.flushAll();
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
// Binary
|
||||
jedis.select(0);
|
||||
jedis.set(bfoo, bbar);
|
||||
assertEquals(1, jedis.dbSize().intValue());
|
||||
jedis.set(bbar, bfoo);
|
||||
jedis.move(bbar, 1);
|
||||
String bstatus = jedis.flushAll();
|
||||
assertEquals("OK", bstatus);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
jedis.select(1);
|
||||
assertEquals(0, jedis.dbSize().intValue());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void persist() {
|
||||
jedis.setex("foo", 60 * 60, "bar");
|
||||
assertTrue(jedis.ttl("foo") > 0);
|
||||
long status = jedis.persist("foo");
|
||||
assertEquals(1, status);
|
||||
assertEquals(-1, jedis.ttl("foo").intValue());
|
||||
jedis.setex("foo", 60 * 60, "bar");
|
||||
assertTrue(jedis.ttl("foo") > 0);
|
||||
long status = jedis.persist("foo");
|
||||
assertEquals(1, status);
|
||||
assertEquals(-1, jedis.ttl("foo").intValue());
|
||||
|
||||
// Binary
|
||||
jedis.setex(bfoo, 60 * 60, bbar);
|
||||
assertTrue(jedis.ttl(bfoo) > 0);
|
||||
long bstatus = jedis.persist(bfoo);
|
||||
assertEquals(1, bstatus);
|
||||
assertEquals(-1, jedis.ttl(bfoo).intValue());
|
||||
// Binary
|
||||
jedis.setex(bfoo, 60 * 60, bbar);
|
||||
assertTrue(jedis.ttl(bfoo) > 0);
|
||||
long bstatus = jedis.persist(bfoo);
|
||||
assertEquals(1, bstatus);
|
||||
assertEquals(-1, jedis.ttl(bfoo).intValue());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void echo() {
|
||||
String result = jedis.echo("hello world");
|
||||
assertEquals("hello world", result);
|
||||
String result = jedis.echo("hello world");
|
||||
assertEquals("hello world", result);
|
||||
|
||||
// Binary
|
||||
byte[] bresult = jedis.echo(SafeEncoder.encode("hello world"));
|
||||
assertArrayEquals(SafeEncoder.encode("hello world"), bresult);
|
||||
// Binary
|
||||
byte[] bresult = jedis.echo(SafeEncoder.encode("hello world"));
|
||||
assertArrayEquals(SafeEncoder.encode("hello world"), bresult);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void dumpAndRestore() {
|
||||
jedis.set("foo1", "bar1");
|
||||
byte[] sv = jedis.dump("foo1");
|
||||
jedis.restore("foo2", 0, sv);
|
||||
assertTrue(jedis.exists("foo2"));
|
||||
jedis.set("foo1", "bar1");
|
||||
byte[] sv = jedis.dump("foo1");
|
||||
jedis.restore("foo2", 0, sv);
|
||||
assertTrue(jedis.exists("foo2"));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void pexpire() {
|
||||
long status = jedis.pexpire("foo", 10000);
|
||||
assertEquals(0, status);
|
||||
long status = jedis.pexpire("foo", 10000);
|
||||
assertEquals(0, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.pexpire("foo", 10000);
|
||||
assertEquals(1, status);
|
||||
jedis.set("foo", "bar");
|
||||
status = jedis.pexpire("foo", 10000);
|
||||
assertEquals(1, status);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void pexpireAt() {
|
||||
long unixTime = (System.currentTimeMillis()) + 10000;
|
||||
long unixTime = (System.currentTimeMillis()) + 10000;
|
||||
|
||||
long status = jedis.pexpireAt("foo", unixTime);
|
||||
assertEquals(0, status);
|
||||
long status = jedis.pexpireAt("foo", unixTime);
|
||||
assertEquals(0, status);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
unixTime = (System.currentTimeMillis()) + 10000;
|
||||
status = jedis.pexpireAt("foo", unixTime);
|
||||
assertEquals(1, status);
|
||||
jedis.set("foo", "bar");
|
||||
unixTime = (System.currentTimeMillis()) + 10000;
|
||||
status = jedis.pexpireAt("foo", unixTime);
|
||||
assertEquals(1, status);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void pttl() {
|
||||
long pttl = jedis.pttl("foo");
|
||||
assertEquals(-2, pttl);
|
||||
long pttl = jedis.pttl("foo");
|
||||
assertEquals(-2, pttl);
|
||||
|
||||
jedis.set("foo", "bar");
|
||||
pttl = jedis.pttl("foo");
|
||||
assertEquals(-1, pttl);
|
||||
jedis.set("foo", "bar");
|
||||
pttl = jedis.pttl("foo");
|
||||
assertEquals(-1, pttl);
|
||||
|
||||
jedis.pexpire("foo", 20000);
|
||||
pttl = jedis.pttl("foo");
|
||||
assertTrue(pttl >= 0 && pttl <= 20000);
|
||||
jedis.pexpire("foo", 20000);
|
||||
pttl = jedis.pttl("foo");
|
||||
assertTrue(pttl >= 0 && pttl <= 20000);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scan() {
|
||||
jedis.set("b", "b");
|
||||
jedis.set("a", "a");
|
||||
|
||||
ScanResult<String> result = jedis.scan(0);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scanMatch() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.match("a*");
|
||||
|
||||
jedis.set("b", "b");
|
||||
jedis.set("a", "a");
|
||||
jedis.set("aa", "aa");
|
||||
ScanResult<String> result = jedis.scan(0, params);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scanCount() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.count(2);
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
jedis.set("a" + i, "a" + i);
|
||||
}
|
||||
|
||||
ScanResult<String> result = jedis.scan(0, params);
|
||||
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -10,6 +10,9 @@ import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import redis.clients.jedis.ScanParams;
|
||||
import redis.clients.jedis.ScanResult;
|
||||
|
||||
public class HashesCommandsTest extends JedisCommandTestBase {
|
||||
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
|
||||
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
|
||||
@@ -17,273 +20,312 @@ public class HashesCommandsTest extends JedisCommandTestBase {
|
||||
|
||||
@Test
|
||||
public void hset() {
|
||||
long status = jedis.hset("foo", "bar", "car");
|
||||
assertEquals(1, status);
|
||||
status = jedis.hset("foo", "bar", "foo");
|
||||
assertEquals(0, status);
|
||||
long status = jedis.hset("foo", "bar", "car");
|
||||
assertEquals(1, status);
|
||||
status = jedis.hset("foo", "bar", "foo");
|
||||
assertEquals(0, status);
|
||||
|
||||
// Binary
|
||||
long bstatus = jedis.hset(bfoo, bbar, bcar);
|
||||
assertEquals(1, bstatus);
|
||||
bstatus = jedis.hset(bfoo, bbar, bfoo);
|
||||
assertEquals(0, bstatus);
|
||||
// Binary
|
||||
long bstatus = jedis.hset(bfoo, bbar, bcar);
|
||||
assertEquals(1, bstatus);
|
||||
bstatus = jedis.hset(bfoo, bbar, bfoo);
|
||||
assertEquals(0, bstatus);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hget() {
|
||||
jedis.hset("foo", "bar", "car");
|
||||
assertEquals(null, jedis.hget("bar", "foo"));
|
||||
assertEquals(null, jedis.hget("foo", "car"));
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
jedis.hset("foo", "bar", "car");
|
||||
assertEquals(null, jedis.hget("bar", "foo"));
|
||||
assertEquals(null, jedis.hget("foo", "car"));
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
|
||||
// Binary
|
||||
jedis.hset(bfoo, bbar, bcar);
|
||||
assertEquals(null, jedis.hget(bbar, bfoo));
|
||||
assertEquals(null, jedis.hget(bfoo, bcar));
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
// Binary
|
||||
jedis.hset(bfoo, bbar, bcar);
|
||||
assertEquals(null, jedis.hget(bbar, bfoo));
|
||||
assertEquals(null, jedis.hget(bfoo, bcar));
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hsetnx() {
|
||||
long status = jedis.hsetnx("foo", "bar", "car");
|
||||
assertEquals(1, status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
long status = jedis.hsetnx("foo", "bar", "car");
|
||||
assertEquals(1, status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
|
||||
status = jedis.hsetnx("foo", "bar", "foo");
|
||||
assertEquals(0, status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
status = jedis.hsetnx("foo", "bar", "foo");
|
||||
assertEquals(0, status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
|
||||
status = jedis.hsetnx("foo", "car", "bar");
|
||||
assertEquals(1, status);
|
||||
assertEquals("bar", jedis.hget("foo", "car"));
|
||||
status = jedis.hsetnx("foo", "car", "bar");
|
||||
assertEquals(1, status);
|
||||
assertEquals("bar", jedis.hget("foo", "car"));
|
||||
|
||||
// Binary
|
||||
long bstatus = jedis.hsetnx(bfoo, bbar, bcar);
|
||||
assertEquals(1, bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
// Binary
|
||||
long bstatus = jedis.hsetnx(bfoo, bbar, bcar);
|
||||
assertEquals(1, bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
|
||||
bstatus = jedis.hsetnx(bfoo, bbar, bfoo);
|
||||
assertEquals(0, bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
bstatus = jedis.hsetnx(bfoo, bbar, bfoo);
|
||||
assertEquals(0, bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
|
||||
bstatus = jedis.hsetnx(bfoo, bcar, bbar);
|
||||
assertEquals(1, bstatus);
|
||||
assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
|
||||
bstatus = jedis.hsetnx(bfoo, bcar, bbar);
|
||||
assertEquals(1, bstatus);
|
||||
assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hmset() {
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
String status = jedis.hmset("foo", hash);
|
||||
assertEquals("OK", status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
assertEquals("bar", jedis.hget("foo", "car"));
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
String status = jedis.hmset("foo", hash);
|
||||
assertEquals("OK", status);
|
||||
assertEquals("car", jedis.hget("foo", "bar"));
|
||||
assertEquals("bar", jedis.hget("foo", "car"));
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
String bstatus = jedis.hmset(bfoo, bhash);
|
||||
assertEquals("OK", bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
String bstatus = jedis.hmset(bfoo, bhash);
|
||||
assertEquals("OK", bstatus);
|
||||
assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
|
||||
assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hmget() {
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
List<String> values = jedis.hmget("foo", "bar", "car", "foo");
|
||||
List<String> expected = new ArrayList<String>();
|
||||
expected.add("car");
|
||||
expected.add("bar");
|
||||
expected.add(null);
|
||||
List<String> values = jedis.hmget("foo", "bar", "car", "foo");
|
||||
List<String> expected = new ArrayList<String>();
|
||||
expected.add("car");
|
||||
expected.add("bar");
|
||||
expected.add(null);
|
||||
|
||||
assertEquals(expected, values);
|
||||
assertEquals(expected, values);
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
List<byte[]> bvalues = jedis.hmget(bfoo, bbar, bcar, bfoo);
|
||||
List<byte[]> bexpected = new ArrayList<byte[]>();
|
||||
bexpected.add(bcar);
|
||||
bexpected.add(bbar);
|
||||
bexpected.add(null);
|
||||
List<byte[]> bvalues = jedis.hmget(bfoo, bbar, bcar, bfoo);
|
||||
List<byte[]> bexpected = new ArrayList<byte[]>();
|
||||
bexpected.add(bcar);
|
||||
bexpected.add(bbar);
|
||||
bexpected.add(null);
|
||||
|
||||
assertEquals(bexpected, bvalues);
|
||||
assertEquals(bexpected, bvalues);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hincrBy() {
|
||||
long value = jedis.hincrBy("foo", "bar", 1);
|
||||
assertEquals(1, value);
|
||||
value = jedis.hincrBy("foo", "bar", -1);
|
||||
assertEquals(0, value);
|
||||
value = jedis.hincrBy("foo", "bar", -10);
|
||||
assertEquals(-10, value);
|
||||
long value = jedis.hincrBy("foo", "bar", 1);
|
||||
assertEquals(1, value);
|
||||
value = jedis.hincrBy("foo", "bar", -1);
|
||||
assertEquals(0, value);
|
||||
value = jedis.hincrBy("foo", "bar", -10);
|
||||
assertEquals(-10, value);
|
||||
|
||||
// Binary
|
||||
long bvalue = jedis.hincrBy(bfoo, bbar, 1);
|
||||
assertEquals(1, bvalue);
|
||||
bvalue = jedis.hincrBy(bfoo, bbar, -1);
|
||||
assertEquals(0, bvalue);
|
||||
bvalue = jedis.hincrBy(bfoo, bbar, -10);
|
||||
assertEquals(-10, bvalue);
|
||||
// Binary
|
||||
long bvalue = jedis.hincrBy(bfoo, bbar, 1);
|
||||
assertEquals(1, bvalue);
|
||||
bvalue = jedis.hincrBy(bfoo, bbar, -1);
|
||||
assertEquals(0, bvalue);
|
||||
bvalue = jedis.hincrBy(bfoo, bbar, -10);
|
||||
assertEquals(-10, bvalue);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hexists() {
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
assertFalse(jedis.hexists("bar", "foo"));
|
||||
assertFalse(jedis.hexists("foo", "foo"));
|
||||
assertTrue(jedis.hexists("foo", "bar"));
|
||||
assertFalse(jedis.hexists("bar", "foo"));
|
||||
assertFalse(jedis.hexists("foo", "foo"));
|
||||
assertTrue(jedis.hexists("foo", "bar"));
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
assertFalse(jedis.hexists(bbar, bfoo));
|
||||
assertFalse(jedis.hexists(bfoo, bfoo));
|
||||
assertTrue(jedis.hexists(bfoo, bbar));
|
||||
assertFalse(jedis.hexists(bbar, bfoo));
|
||||
assertFalse(jedis.hexists(bfoo, bfoo));
|
||||
assertTrue(jedis.hexists(bfoo, bbar));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hdel() {
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
assertEquals(0, jedis.hdel("bar", "foo").intValue());
|
||||
assertEquals(0, jedis.hdel("foo", "foo").intValue());
|
||||
assertEquals(1, jedis.hdel("foo", "bar").intValue());
|
||||
assertEquals(null, jedis.hget("foo", "bar"));
|
||||
assertEquals(0, jedis.hdel("bar", "foo").intValue());
|
||||
assertEquals(0, jedis.hdel("foo", "foo").intValue());
|
||||
assertEquals(1, jedis.hdel("foo", "bar").intValue());
|
||||
assertEquals(null, jedis.hget("foo", "bar"));
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
assertEquals(0, jedis.hdel(bbar, bfoo).intValue());
|
||||
assertEquals(0, jedis.hdel(bfoo, bfoo).intValue());
|
||||
assertEquals(1, jedis.hdel(bfoo, bbar).intValue());
|
||||
assertEquals(null, jedis.hget(bfoo, bbar));
|
||||
assertEquals(0, jedis.hdel(bbar, bfoo).intValue());
|
||||
assertEquals(0, jedis.hdel(bfoo, bfoo).intValue());
|
||||
assertEquals(1, jedis.hdel(bfoo, bbar).intValue());
|
||||
assertEquals(null, jedis.hget(bfoo, bbar));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hlen() {
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new HashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
assertEquals(0, jedis.hlen("bar").intValue());
|
||||
assertEquals(2, jedis.hlen("foo").intValue());
|
||||
assertEquals(0, jedis.hlen("bar").intValue());
|
||||
assertEquals(2, jedis.hlen("foo").intValue());
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
assertEquals(0, jedis.hlen(bbar).intValue());
|
||||
assertEquals(2, jedis.hlen(bfoo).intValue());
|
||||
assertEquals(0, jedis.hlen(bbar).intValue());
|
||||
assertEquals(2, jedis.hlen(bfoo).intValue());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hkeys() {
|
||||
Map<String, String> hash = new LinkedHashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new LinkedHashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
Set<String> keys = jedis.hkeys("foo");
|
||||
Set<String> expected = new LinkedHashSet<String>();
|
||||
expected.add("bar");
|
||||
expected.add("car");
|
||||
assertEquals(expected, keys);
|
||||
Set<String> keys = jedis.hkeys("foo");
|
||||
Set<String> expected = new LinkedHashSet<String>();
|
||||
expected.add("bar");
|
||||
expected.add("car");
|
||||
assertEquals(expected, keys);
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
Set<byte[]> bkeys = jedis.hkeys(bfoo);
|
||||
Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
|
||||
bexpected.add(bbar);
|
||||
bexpected.add(bcar);
|
||||
assertEquals(bexpected, bkeys);
|
||||
Set<byte[]> bkeys = jedis.hkeys(bfoo);
|
||||
Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
|
||||
bexpected.add(bbar);
|
||||
bexpected.add(bcar);
|
||||
assertEquals(bexpected, bkeys);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hvals() {
|
||||
Map<String, String> hash = new LinkedHashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
Map<String, String> hash = new LinkedHashMap<String, String>();
|
||||
hash.put("bar", "car");
|
||||
hash.put("car", "bar");
|
||||
jedis.hmset("foo", hash);
|
||||
|
||||
List<String> vals = jedis.hvals("foo");
|
||||
assertEquals(2, vals.size());
|
||||
assertTrue(vals.contains("bar"));
|
||||
assertTrue(vals.contains("car"));
|
||||
List<String> vals = jedis.hvals("foo");
|
||||
assertEquals(2, vals.size());
|
||||
assertTrue(vals.contains("bar"));
|
||||
assertTrue(vals.contains("car"));
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
|
||||
bhash.put(bbar, bcar);
|
||||
bhash.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bhash);
|
||||
|
||||
List<byte[]> bvals = jedis.hvals(bfoo);
|
||||
List<byte[]> bvals = jedis.hvals(bfoo);
|
||||
|
||||
assertEquals(2, bvals.size());
|
||||
assertTrue(arrayContains(bvals, bbar));
|
||||
assertTrue(arrayContains(bvals, bcar));
|
||||
assertEquals(2, bvals.size());
|
||||
assertTrue(arrayContains(bvals, bbar));
|
||||
assertTrue(arrayContains(bvals, bcar));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hgetAll() {
|
||||
Map<String, String> h = new HashMap<String, String>();
|
||||
h.put("bar", "car");
|
||||
h.put("car", "bar");
|
||||
jedis.hmset("foo", h);
|
||||
Map<String, String> h = new HashMap<String, String>();
|
||||
h.put("bar", "car");
|
||||
h.put("car", "bar");
|
||||
jedis.hmset("foo", h);
|
||||
|
||||
Map<String, String> hash = jedis.hgetAll("foo");
|
||||
assertEquals(2, hash.size());
|
||||
assertEquals("car", hash.get("bar"));
|
||||
assertEquals("bar", hash.get("car"));
|
||||
Map<String, String> hash = jedis.hgetAll("foo");
|
||||
assertEquals(2, hash.size());
|
||||
assertEquals("car", hash.get("bar"));
|
||||
assertEquals("bar", hash.get("car"));
|
||||
|
||||
// Binary
|
||||
Map<byte[], byte[]> bh = new HashMap<byte[], byte[]>();
|
||||
bh.put(bbar, bcar);
|
||||
bh.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bh);
|
||||
Map<byte[], byte[]> bhash = jedis.hgetAll(bfoo);
|
||||
// Binary
|
||||
Map<byte[], byte[]> bh = new HashMap<byte[], byte[]>();
|
||||
bh.put(bbar, bcar);
|
||||
bh.put(bcar, bbar);
|
||||
jedis.hmset(bfoo, bh);
|
||||
Map<byte[], byte[]> bhash = jedis.hgetAll(bfoo);
|
||||
|
||||
assertEquals(2, bhash.size());
|
||||
assertArrayEquals(bcar, bhash.get(bbar));
|
||||
assertArrayEquals(bbar, bhash.get(bcar));
|
||||
assertEquals(2, bhash.size());
|
||||
assertArrayEquals(bcar, bhash.get(bbar));
|
||||
assertArrayEquals(bbar, bhash.get(bcar));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hscan() {
|
||||
jedis.hset("foo", "b", "b");
|
||||
jedis.hset("foo", "a", "a");
|
||||
|
||||
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hscanMatch() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.match("a*");
|
||||
|
||||
jedis.hset("foo", "b", "b");
|
||||
jedis.hset("foo", "a", "a");
|
||||
jedis.hset("foo", "aa", "aa");
|
||||
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hscanCount() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.count(2);
|
||||
|
||||
for (int i = 0; i < 10; i++) {
|
||||
jedis.hset("foo", "a" + i, "a" + i);
|
||||
}
|
||||
|
||||
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params);
|
||||
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,10 +2,14 @@ package redis.clients.jedis.tests.commands;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import redis.clients.jedis.ScanParams;
|
||||
import redis.clients.jedis.ScanResult;
|
||||
|
||||
public class SetCommandsTest extends JedisCommandTestBase {
|
||||
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
|
||||
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
|
||||
@@ -448,7 +452,40 @@ public class SetCommandsTest extends JedisCommandTestBase {
|
||||
|
||||
bmember = jedis.srandmember(bbar);
|
||||
assertNull(bmember);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void sscan() {
|
||||
jedis.sadd("foo", "a", "b");
|
||||
|
||||
ScanResult<String> result = jedis.sscan("foo", 0);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sscanMatch() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.match("a*");
|
||||
|
||||
jedis.sadd("foo", "b", "a", "aa");
|
||||
ScanResult<String> result = jedis.sscan("foo", 0, params);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void sscanCount() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.count(2);
|
||||
|
||||
jedis.sadd("foo", "a1", "a2", "a3", "a4", "a5");
|
||||
|
||||
ScanResult<String> result = jedis.sscan("foo", 0, params);
|
||||
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,8 @@ import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import redis.clients.jedis.ScanParams;
|
||||
import redis.clients.jedis.ScanResult;
|
||||
import redis.clients.jedis.Tuple;
|
||||
import redis.clients.jedis.ZParams;
|
||||
import redis.clients.util.SafeEncoder;
|
||||
@@ -885,4 +887,46 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
|
||||
assertEquals(1, t2.compareTo(t1));
|
||||
assertEquals(0, t2.compareTo(t2));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void zscan() {
|
||||
jedis.zadd("foo", 1, "a");
|
||||
jedis.zadd("foo", 2, "b");
|
||||
|
||||
ScanResult<Tuple> result = jedis.zscan("foo", 0);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void zscanMatch() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.match("a*");
|
||||
|
||||
jedis.zadd("foo", 2, "b");
|
||||
jedis.zadd("foo", 1, "a");
|
||||
jedis.zadd("foo", 11, "aa");
|
||||
ScanResult<Tuple> result = jedis.zscan("foo", 0, params);
|
||||
|
||||
assertEquals(0, result.getCursor());
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void zscanCount() {
|
||||
ScanParams params = new ScanParams();
|
||||
params.count(2);
|
||||
|
||||
jedis.zadd("foo", 1, "a1");
|
||||
jedis.zadd("foo", 2, "a2");
|
||||
jedis.zadd("foo", 3, "a3");
|
||||
jedis.zadd("foo", 4, "a4");
|
||||
jedis.zadd("foo", 5, "a5");
|
||||
|
||||
ScanResult<Tuple> result = jedis.zscan("foo", 0, params);
|
||||
|
||||
assertFalse(result.getResult().isEmpty());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user