Binary U test on Lists ...

src/test/java/redis/clients/jedis/tests/commands/ListCommandsTest.java

@@ -8,14 +8,35 @@ import org.junit.Test;
 import redis.clients.jedis.Client;
 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisException;
+import redis.clients.jedis.tests.JedisTest;
 
 public class ListCommandsTest extends JedisCommandTestBase {
+	final byte[] bfoo  = {0x01, 0x02, 0x03, 0x04};
+	final byte[] bbar  = {0x05, 0x06, 0x07, 0x08};
+	final byte[] bcar  = {0x09, 0x0A, 0x0B, 0x0C};
+	final byte[] bA  = {0x0A};
+	final byte[] bB  = {0x0B};
+	final byte[] bC  = {0x0C};
+	final byte[] b1  = {0x01};
+	final byte[] b2  = {0x02};
+	final byte[] b3  = {0x03};
+	final byte[] bhello  = {0x04, 0x02};
+	final byte[] bx  = {0x02, 0x04};
+	final byte[] bdst  = {0x11, 0x12, 0x13, 0x14};
+
     @Test
     public void rpush() {
 	int size = jedis.rpush("foo", "bar");
 	assertEquals(1, size);
 	size = jedis.rpush("foo", "foo");
 	assertEquals(2, size);
+	
+	//Binary
+	int bsize = jedis.rpush(bfoo, bbar);
+	assertEquals(1, bsize);
+	bsize = jedis.rpush(bfoo, bfoo);
+	assertEquals(2, bsize);
+
     }
 
     @Test
@@ -24,20 +45,46 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	assertEquals(1, size);
 	size = jedis.lpush("foo", "foo");
 	assertEquals(2, size);
+	
+	//Binary
+	int bsize = jedis.lpush(bfoo, bbar);
+	assertEquals(1, bsize);
+	bsize = jedis.lpush(bfoo, bfoo);
+	assertEquals(2, bsize);
+
     }
     
+
     @Test
     public void llen() {
 	assertEquals(0, jedis.llen("foo").intValue());
 	jedis.lpush("foo", "bar");
 	jedis.lpush("foo", "car");
 	assertEquals(2, jedis.llen("foo").intValue());
+	
+	//Binary
+	assertEquals(0, jedis.llen(bfoo).intValue());
+	jedis.lpush(bfoo, bbar);
+	jedis.lpush(bfoo, bcar);
+	assertEquals(2, jedis.llen(bfoo).intValue());
+
     }
 
-    @Test(expected = JedisException.class)
+    @Test
     public void llenNotOnList() {
+    	try {
 			jedis.set("foo", "bar");
 			jedis.llen("foo");
+			fail("JedisException expected");
+    	} catch (final JedisException e){}
+    	
+    	//Binary
+    	try {
+			jedis.set(bfoo, bbar);
+			jedis.llen(bfoo);
+			fail("JedisException expected");
+    	} catch (final JedisException e){}
+
     }
 
     @Test
@@ -67,6 +114,35 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	expected = new ArrayList<String>();
 	range = jedis.lrange("foo", 2, 1);
 	assertEquals(expected, range);
+	
+	//Binary
+	jedis.rpush(bfoo, bA);
+	jedis.rpush(bfoo, bB);
+	jedis.rpush(bfoo, bC);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(bA);
+	bexpected.add(bB);
+	bexpected.add(bC);
+
+	List<byte[]> brange = jedis.lrange(bfoo, 0, 2);
+	JedisTest.isListAreEquals(bexpected, brange);
+
+	brange = jedis.lrange(bfoo, 0, 20);
+	JedisTest.isListAreEquals(bexpected, brange);
+
+	bexpected = new ArrayList<byte[]>();
+	bexpected.add(bB);
+	bexpected.add(bC);
+
+	brange = jedis.lrange(bfoo, 1, 2);
+	JedisTest.isListAreEquals(bexpected, brange);
+
+	bexpected = new ArrayList<byte[]>();
+	brange = jedis.lrange(bfoo, 2, 1);
+	JedisTest.isListAreEquals(bexpected, brange);
+
+
     }
 
     @Test
@@ -83,6 +159,21 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	assertEquals("OK", status);
 	assertEquals(2, jedis.llen("foo").intValue());
 	assertEquals(expected, jedis.lrange("foo", 0, 100));
+
+	//Binary
+	jedis.lpush(bfoo, b1);
+	jedis.lpush(bfoo, b2);
+	jedis.lpush(bfoo, b3);
+	String bstatus = jedis.ltrim(bfoo, 0, 1);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(b3);
+	bexpected.add(b2);
+
+	assertEquals("OK", bstatus);
+	assertEquals(2, jedis.llen(bfoo).intValue());
+	assertTrue(JedisTest.isListAreEquals(bexpected, jedis.lrange(bfoo, 0, 100)));
+
     }
 
     @Test
@@ -100,6 +191,21 @@ public class ListCommandsTest extends JedisCommandTestBase {
 
 	assertEquals("OK", status);
 	assertEquals(expected, jedis.lrange("foo", 0, 100));
+	
+	//Binary
+	jedis.lpush(bfoo, b1);
+	jedis.lpush(bfoo, b2);
+	jedis.lpush(bfoo, b3);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(b3);
+	bexpected.add(bbar);
+	bexpected.add(b1);
+
+	String bstatus = jedis.lset(bfoo, 1, bbar);
+
+	assertEquals("OK", bstatus);
+	assertTrue(JedisTest.isListAreEquals(bexpected, jedis.lrange(bfoo, 0, 100)));
     }
 
     @Test
@@ -110,8 +216,18 @@ public class ListCommandsTest extends JedisCommandTestBase {
 
 	assertEquals("3", jedis.lindex("foo", 0));
 	assertEquals(null, jedis.lindex("foo", 100));
+	
+	//Binary
+	jedis.lpush(bfoo, b1);
+	jedis.lpush(bfoo, b2);
+	jedis.lpush(bfoo, b3);
+
+	assertArrayEquals(b3, jedis.lindex(bfoo, 0));
+	assertEquals(null, jedis.lindex(bfoo, 100));
+
     }
     
+
     @Test
     public void lrem() {
 	jedis.lpush("foo", "hello");
@@ -134,6 +250,29 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	assertEquals(2, count);
 	assertEquals(expected, jedis.lrange("foo", 0, 1000));
 	assertEquals(0, jedis.lrem("bar", 100, "foo").intValue());
+	
+	//Binary
+	jedis.lpush(bfoo, bhello);
+	jedis.lpush(bfoo, bhello);
+	jedis.lpush(bfoo, bx);
+	jedis.lpush(bfoo, bhello);
+	jedis.lpush(bfoo, bC);
+	jedis.lpush(bfoo, bB);
+	jedis.lpush(bfoo, bA);
+
+	int bcount = jedis.lrem(bfoo, -2, bhello);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(bA);
+	bexpected.add(bB);
+	bexpected.add(bC);
+	bexpected.add(bhello);
+	bexpected.add(bx);
+
+	assertEquals(2, bcount);
+	assertTrue(JedisTest.isListAreEquals(bexpected, jedis.lrange(bfoo, 0, 1000)));
+	assertEquals(0, jedis.lrem(bbar, 100, bfoo).intValue());
+
     }
 
     @Test
@@ -155,6 +294,26 @@ public class ListCommandsTest extends JedisCommandTestBase {
 
 	element = jedis.lpop("foo");
 	assertEquals(null, element);
+	
+	//Binary
+	jedis.rpush(bfoo, bA);
+	jedis.rpush(bfoo, bB);
+	jedis.rpush(bfoo, bC);
+
+	byte[] belement = jedis.lpop(bfoo);
+	assertArrayEquals(bA, belement);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(bB);
+	bexpected.add(bC);
+
+	assertTrue(JedisTest.isListAreEquals(bexpected, jedis.lrange(bfoo, 0, 1000)));
+	jedis.lpop(bfoo);
+	jedis.lpop(bfoo);
+
+	belement = jedis.lpop(bfoo);
+	assertEquals(null, belement);
+
     }
 
     @Test
@@ -176,6 +335,26 @@ public class ListCommandsTest extends JedisCommandTestBase {
 
 	element = jedis.rpop("foo");
 	assertEquals(null, element);
+	
+	//Binary
+	jedis.rpush(bfoo, bA);
+	jedis.rpush(bfoo, bB);
+	jedis.rpush(bfoo, bC);
+
+	byte[] belement = jedis.rpop(bfoo);
+	assertArrayEquals(bC, belement);
+
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(bA);
+	bexpected.add(bB);
+
+	assertTrue(JedisTest.isListAreEquals(bexpected, jedis.lrange(bfoo, 0, 1000)));
+	jedis.rpop(bfoo);
+	jedis.rpop(bfoo);
+
+	belement = jedis.rpop(bfoo);
+	assertEquals(null, belement);
+
     }
 
     @Test
@@ -202,6 +381,31 @@ public class ListCommandsTest extends JedisCommandTestBase {
 
 	assertEquals(srcExpected, jedis.lrange("foo", 0, 1000));
 	assertEquals(dstExpected, jedis.lrange("dst", 0, 1000));
+	
+	//Binary
+	jedis.rpush(bfoo, bA);
+	jedis.rpush(bfoo, bB);
+	jedis.rpush(bfoo, bC);
+
+	jedis.rpush(bdst, bfoo);
+	jedis.rpush(bdst, bbar);
+
+	byte[] belement = jedis.rpoplpush(bfoo, bdst);
+
+	assertArrayEquals(bC, belement);
+
+	List<byte[]> bsrcExpected = new ArrayList<byte[]>();
+	bsrcExpected.add(bA);
+	bsrcExpected.add(bB);
+
+	List<byte[]> bdstExpected = new ArrayList<byte[]>();
+	bdstExpected.add(bC);
+	bdstExpected.add(bfoo);
+	bdstExpected.add(bbar);
+
+	assertTrue(JedisTest.isListAreEquals(bsrcExpected, jedis.lrange(bfoo, 0, 1000)));
+	assertTrue(JedisTest.isListAreEquals(bdstExpected, jedis.lrange(bdst, 0, 1000)));
+
     }
 
     @Test
@@ -226,6 +430,29 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	assertEquals(2, result.size());
 	assertEquals("foo", result.get(0));
 	assertEquals("bar", result.get(1));
+	
+	//Binary
+	List<byte[]> bresult = jedis.blpop(1, bfoo);
+	assertNull(bresult);
+
+	new Thread(new Runnable() {
+	    public void run() {
+		try {
+		    Jedis j = createJedis();
+		    j.lpush(bfoo, bbar);
+		    j.disconnect();
+		} catch (Exception ex) {
+		    fail(ex.getMessage());
+		}
+	    }
+	}).start();
+
+	bresult = jedis.blpop(1, bfoo);
+	assertNotNull(bresult);
+	assertEquals(2, bresult.size());
+	assertArrayEquals(bfoo, bresult.get(0));
+	assertArrayEquals(bbar, bresult.get(1));
+
     }
 
     @Test
@@ -250,6 +477,29 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	assertEquals(2, result.size());
 	assertEquals("foo", result.get(0));
 	assertEquals("bar", result.get(1));
+	
+	//Binary
+	List<byte[]> bresult = jedis.brpop(1, bfoo);
+	assertNull(bresult);
+
+	new Thread(new Runnable() {
+	    public void run() {
+		try {
+		    Jedis j = createJedis();
+		    j.lpush(bfoo, bbar);
+		    j.disconnect();
+		} catch (Exception ex) {
+		    fail(ex.getMessage());
+		}
+	    }
+	}).start();
+
+	bresult = jedis.brpop(1, bfoo);
+	assertNotNull(bresult);
+	assertEquals(2, bresult.size());
+	assertArrayEquals(bfoo, bresult.get(0));
+	assertArrayEquals(bbar, bresult.get(1));
+
     }
 
     @Test
@@ -260,6 +510,15 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	jedis.lpush("foo", "a");
 	status = jedis.lpushx("foo", "b");
 	assertEquals(2, status);
+	
+	//Binary
+	int bstatus = jedis.lpushx(bfoo, bbar);
+	assertEquals(0, bstatus);
+
+	jedis.lpush(bfoo, bA);
+	bstatus = jedis.lpushx(bfoo, bB);
+	assertEquals(2, bstatus);
+
     }
 
     @Test
@@ -270,12 +529,19 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	jedis.lpush("foo", "a");
 	status = jedis.rpushx("foo", "b");
 	assertEquals(2, status);
+	
+	//Binary
+	int bstatus = jedis.rpushx(bfoo, bbar);
+	assertEquals(0, bstatus);
+
+	jedis.lpush(bfoo, bA);
+	bstatus = jedis.rpushx(bfoo, bB);
+	assertEquals(2, bstatus);
     }
 
     @Test
     public void linsert() {
-	int status = jedis.linsert("foo", Client.LIST_POSITION.BEFORE, "bar",
+	int status = jedis.linsert("foo", Client.LIST_POSITION.BEFORE, "bar", "car");
-		"car");
 	assertEquals(0, status);
 
 	jedis.lpush("foo", "a");
@@ -292,5 +558,25 @@ public class ListCommandsTest extends JedisCommandTestBase {
 	status = jedis
 		.linsert("foo", Client.LIST_POSITION.BEFORE, "bar", "car");
 	assertEquals(-1, status);
+	
+	//Binary
+	int bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar, bcar);
+	assertEquals(0, bstatus);
+
+	jedis.lpush(bfoo, bA);
+	bstatus = jedis.linsert(bfoo, Client.LIST_POSITION.AFTER, bA, bB);
+	assertEquals(2, bstatus);
+
+	List<byte[]> bactual = jedis.lrange(bfoo, 0, 100);
+	List<byte[]> bexpected = new ArrayList<byte[]>();
+	bexpected.add(bA);
+	bexpected.add(bB);
+
+	assertTrue(JedisTest.isListAreEquals(bexpected, bactual));
+
+	bstatus = jedis
+		.linsert(bfoo, Client.LIST_POSITION.BEFORE, bbar, bcar);
+	assertEquals(-1, bstatus);
+ 
     }
 }