Binary U test on SortedSets ...

src/main/java/redis/clients/jedis/BinaryJedis.java

@@ -1574,14 +1574,14 @@ public class BinaryJedis implements BinaryJedisCommands {
     public Set<Tuple> zrangeWithScores(final byte[] key, final int start, final int end) {
         checkIsInMulti();
         client.zrangeWithScores(key, start, end);
-        Set<Tuple> set = getTupledSet();
+        Set<Tuple> set = getBinaryTupledSet();
         return set;
     }
 
     public Set<Tuple> zrevrangeWithScores(final byte[] key, final int start, final int end) {
         checkIsInMulti();
         client.zrevrangeWithScores(key, start, end);
-        Set<Tuple> set = getTupledSet();
+        Set<Tuple> set = getBinaryTupledSet();
         return set;
     }
 
@@ -2225,7 +2225,7 @@ public class BinaryJedis implements BinaryJedisCommands {
     public Set<Tuple> zrangeByScoreWithScores(final byte[] key, final double min, final double max) {
         checkIsInMulti();
         client.zrangeByScoreWithScores(key, min, max);
-        Set<Tuple> set = getTupledSet();
+        Set<Tuple> set = getBinaryTupledSet();
         return set;
     }
 
@@ -2289,19 +2289,22 @@ public class BinaryJedis implements BinaryJedisCommands {
     		final double max, final int offset, final int count) {
         checkIsInMulti();
         client.zrangeByScoreWithScores(key, min, max, offset, count);
-        Set<Tuple> set = getTupledSet();
+        Set<Tuple> set = getBinaryTupledSet();
         return set;
     }
 
-    private Set<Tuple> getTupledSet() {
+    private Set<Tuple> getBinaryTupledSet() {
         checkIsInMulti();
-        List<String> membersWithScores = client.getMultiBulkReply();
+        List<byte[]> membersWithScores = client.getBinaryMultiBulkReply();
         Set<Tuple> set = new LinkedHashSet<Tuple>();
-        Iterator<String> iterator = membersWithScores.iterator();
+        Iterator<byte[]> iterator = membersWithScores.iterator();
         while (iterator.hasNext()) {
-            set
+            set.add(
-                    .add(new Tuple(iterator.next(), Double.valueOf(iterator
+            	new Tuple(
-                            .next())));
+            			iterator.next(),
+            			Double.valueOf(new String(iterator.next(), Protocol.UTF8))
+            	)
+            );
         }
         return set;
     }

src/main/java/redis/clients/jedis/Tuple.java

@@ -1,14 +1,21 @@
 package redis.clients.jedis;
 
+import java.util.Arrays;
+
 public class Tuple {
-    private String element;
+    private byte[] element;
     private Double score;
 
     @Override
     public int hashCode() {
 	final int prime = 31;
 	int result = 1;
-	result = prime * result + ((element == null) ? 0 : element.hashCode());
+	result = prime * result;
+	if (null != element) {
+		for(final byte b : element) {
+			result = prime * result + b;
+		}
+	}
 	long temp;
 	temp = Double.doubleToLongBits(score);
 	result = prime * result + (int) (temp ^ (temp >>> 32));
@@ -27,7 +34,7 @@ public class Tuple {
 	if (element == null) {
 	    if (other.element != null)
 		return false;
-	} else if (!element.equals(other.element))
+	} else if (!Arrays.equals(element, other.element))
 	    return false;
 	if (Double.doubleToLongBits(score) != Double
 		.doubleToLongBits(other.score))
@@ -37,15 +44,33 @@ public class Tuple {
 
     public Tuple(String element, Double score) {
 	super();
-	this.element = element;
+	this.element = element.getBytes(Protocol.UTF8);
 	this.score = score;
     }
 
+    public Tuple(byte[] element, Double score) {
+    	super();
+    	this.element = element;
+    	this.score = score;
+        }
+
     public String getElement() {
-	return element;
+    	if(null != element) {
+    		return new String(element, Protocol.UTF8);
+    	} else {
+    		return null;
+    	}
+    }
+
+    public byte[] getBinaryElement() {
+   		return element;
     }
 
     public double getScore() {
 	return score;
     }
+    
+    public String toString() {
+    	return '['+Arrays.toString(element)+','+score+']';
+    }
 }

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

@@ -145,7 +145,7 @@ public class SetCommandsTest extends JedisCommandTestBase {
 	assertEquals(expectedSrc, jedis.smembers("foo"));
 	assertEquals(expectedDst, jedis.smembers("bar"));
 
-	status = jedis.smove("foo", "bar", "a");	final byte[] bD  = {0x0D};
+	status = jedis.smove("foo", "bar", "a");
 
 	assertEquals(status, 0);
 	

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

@@ -5,10 +5,19 @@ import java.util.Set;
 
 import org.junit.Test;
 
+import redis.clients.jedis.Protocol;
 import redis.clients.jedis.Tuple;
 import redis.clients.jedis.ZParams;
+import redis.clients.jedis.tests.JedisTest;
 
 public class SortedSetCommandsTest 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};
+
     @Test
     public void zadd() {
         int status = jedis.zadd("foo", 1d, "a");
@@ -22,6 +31,20 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         status = jedis.zadd("foo", 2d, "a");
         assertEquals(0, status);
+        
+        //Binary
+        int bstatus = jedis.zadd(bfoo, 1d, ba);
+        assertEquals(1, bstatus);
+
+        bstatus = jedis.zadd(bfoo, 10d, bb);
+        assertEquals(1, bstatus);
+
+        bstatus = jedis.zadd(bfoo, 0.1d, bc);
+        assertEquals(1, bstatus);
+
+        bstatus = jedis.zadd(bfoo, 2d, ba);
+        assertEquals(0, bstatus);
+
     }
 
     @Test
@@ -41,6 +64,24 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add("b");
         range = jedis.zrange("foo", 0, 100);
         assertEquals(expected, range);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bc);
+        bexpected.add(ba);
+
+        Set<byte[]> brange = jedis.zrange(bfoo, 0, 1);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        bexpected.add(bb);
+        brange = jedis.zrange(bfoo, 0, 100);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -60,6 +101,24 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add("c");
         range = jedis.zrevrange("foo", 0, 100);
         assertEquals(expected, range);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bb);
+        bexpected.add(ba);
+
+        Set<byte[]> brange = jedis.zrevrange(bfoo, 0, 1);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        bexpected.add(bc);
+        brange = jedis.zrevrange(bfoo, 0, 100);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -78,6 +137,23 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         status = jedis.zrem("foo", "bar");
 
         assertEquals(0, status);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 2d, bb);
+
+        int bstatus = jedis.zrem(bfoo, ba);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bb);
+
+        assertEquals(1, bstatus);
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrange(bfoo, 0, 100)));
+
+        bstatus = jedis.zrem(bfoo, bbar);
+
+        assertEquals(0, bstatus);
+
     }
 
     @Test
@@ -93,6 +169,20 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         assertEquals(3d, score, 0);
         assertEquals(expected, jedis.zrange("foo", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 2d, bb);
+
+        double bscore = jedis.zincrby(bfoo, 2d, ba);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(ba);
+        bexpected.add(bb);
+
+        assertEquals(3d, bscore, 0);
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrange(bfoo, 0, 100)));
+
     }
 
     @Test
@@ -108,6 +198,20 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         rank = jedis.zrank("car", "b");
         assertNull(rank);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 2d, bb);
+
+        Integer brank = jedis.zrank(bfoo, ba);
+        assertEquals(0, brank.intValue());
+
+        brank = jedis.zrank(bfoo, bb);
+        assertEquals(1, brank.intValue());
+
+        brank = jedis.zrank(bcar, bb);
+        assertNull(brank);
+
     }
 
     @Test
@@ -120,6 +224,17 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         rank = jedis.zrevrank("foo", "b");
         assertEquals(0, rank);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 2d, bb);
+
+        int brank = jedis.zrevrank(bfoo, ba);
+        assertEquals(1, brank);
+
+        brank = jedis.zrevrank(bfoo, bb);
+        assertEquals(0, brank);
+
     }
 
     @Test
@@ -139,6 +254,24 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("b", 10d));
         range = jedis.zrangeWithScores("foo", 0, 100);
         assertEquals(expected, range);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bc, 0.1d));
+        bexpected.add(new Tuple(ba, 2d));
+
+        Set<Tuple> brange = jedis.zrangeWithScores(bfoo, 0, 1);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        bexpected.add(new Tuple(bb, 10d));
+        brange = jedis.zrangeWithScores(bfoo, 0, 100);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -158,6 +291,24 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("c", 0.1d));
         range = jedis.zrevrangeWithScores("foo", 0, 100);
         assertEquals(expected, range);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bb, 10d));
+        bexpected.add(new Tuple(ba, 2d));
+
+        Set<Tuple> brange = jedis.zrevrangeWithScores(bfoo, 0, 1);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        bexpected.add(new Tuple(bc, 0.1d));
+        brange = jedis.zrevrangeWithScores(bfoo, 0, 100);
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -169,6 +320,16 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         int size = jedis.zcard("foo");
         assertEquals(3, size);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        int bsize = jedis.zcard(bfoo);
+        assertEquals(3, bsize);
+
     }
 
     @Test
@@ -186,6 +347,22 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
 
         score = jedis.zscore("foo", "s");
         assertNull(score);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Double bscore = jedis.zscore(bfoo, bb);
+        assertEquals((Double)10d, bscore);
+
+        bscore = jedis.zscore(bfoo, bc);
+        assertEquals((Double)0.1d, bscore);
+
+        bscore = jedis.zscore(bfoo, "s".getBytes(Protocol.UTF8));
+        assertNull(bscore);
+
     }
 
     @Test
@@ -198,6 +375,17 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         int result = jedis.zcount("foo", 0.01d, 2.1d);
 
         assertEquals(2, result);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        int bresult = jedis.zcount(bfoo, 0.01d, 2.1d);
+
+        assertEquals(2, bresult);
+
     }
 
     @Test
@@ -230,6 +418,37 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add("a");
 
         assertEquals(expected, range);
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d,bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<byte[]> brange = jedis.zrangeByScore(bfoo, 0d, 2d);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bc);
+        bexpected.add(ba);
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        brange = jedis.zrangeByScore(bfoo, 0d, 2d, 0, 1);
+
+        bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bc);
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        brange = jedis.zrangeByScore(bfoo, 0d, 2d, 1, 1);
+        Set<byte[]> brange2 = jedis.zrangeByScore(bfoo, "-inf".getBytes(Protocol.UTF8), "(2".getBytes(Protocol.UTF8));
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange2));
+
+        bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(ba);
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -260,6 +479,36 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("a", 2d));
 
         assertEquals(expected, range);
+        
+        //Binary
+        
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        Set<Tuple> brange = jedis.zrangeByScoreWithScores(bfoo, 0d, 2d);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bc, 0.1d));
+        bexpected.add(new Tuple(ba, 2d));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        brange = jedis.zrangeByScoreWithScores(bfoo, 0d, 2d, 0, 1);
+
+        bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bc, 0.1d));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
+        brange = jedis.zrangeByScoreWithScores(bfoo, 0d, 2d, 1, 1);
+
+        bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(ba, 2d));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, brange));
+
     }
 
     @Test
@@ -278,6 +527,23 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add("b");
 
         assertEquals(expected, jedis.zrange("foo", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d, bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        int bresult = jedis.zremrangeByRank(bfoo, 0, 0);
+
+        assertEquals(1, bresult);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(ba);
+        bexpected.add(bb);
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrange(bfoo, 0, 100)));
+
     }
 
     @Test
@@ -295,6 +561,22 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add("b");
 
         assertEquals(expected, jedis.zrange("foo", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1d, ba);
+        jedis.zadd(bfoo, 10d, bb);
+        jedis.zadd(bfoo, 0.1d,bc);
+        jedis.zadd(bfoo, 2d, ba);
+
+        int bresult = jedis.zremrangeByScore(bfoo, 0, 2);
+
+        assertEquals(2, bresult);
+
+        Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
+        bexpected.add(bb);
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrange(bfoo, 0, 100)));
+
     }
 
     @Test
@@ -313,6 +595,23 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("a", new Double(3)));
 
         assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1, ba);
+        jedis.zadd(bfoo, 2, bb);
+        jedis.zadd(bbar, 2, ba);
+        jedis.zadd(bbar, 2, bb);
+
+        int bresult = jedis.zunionstore("dst".getBytes(Protocol.UTF8), bfoo, bbar);
+
+        assertEquals(2, bresult);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bb, new Double(4)));
+        bexpected.add(new Tuple(ba, new Double(3)));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrangeWithScores("dst".getBytes(Protocol.UTF8), 0, 100)));
+
     }
 
     @Test
@@ -334,6 +633,26 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("a", new Double(6)));
 
         assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1, ba);
+        jedis.zadd(bfoo, 2, bb);
+        jedis.zadd(bbar, 2, ba);
+        jedis.zadd(bbar, 2, bb);
+
+        ZParams bparams = new ZParams();
+        bparams.weights(2, 2);
+        bparams.aggregate(ZParams.Aggregate.SUM);
+        int bresult = jedis.zunionstore("dst".getBytes(Protocol.UTF8), bparams, bfoo, bbar);
+
+        assertEquals(2, bresult);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(bb, new Double(8)));
+        bexpected.add(new Tuple(ba, new Double(6)));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrangeWithScores("dst".getBytes(Protocol.UTF8), 0, 100)));
+
     }
 
     @Test
@@ -350,7 +669,23 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("a", new Double(3)));
 
         assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1, ba);
+        jedis.zadd(bfoo, 2, bb);
+        jedis.zadd(bbar, 2, ba);
+
+        int bresult = jedis.zinterstore("dst".getBytes(Protocol.UTF8), bfoo, bbar);
+
+        assertEquals(1, bresult);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(ba, new Double(3)));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrangeWithScores("dst".getBytes(Protocol.UTF8), 0, 100)));
+
     }
+    
 
     @Test
     public void zintertoreParams() {
@@ -369,5 +704,23 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
         expected.add(new Tuple("a", new Double(6)));
 
         assertEquals(expected, jedis.zrangeWithScores("dst", 0, 100));
+        
+        //Binary
+        jedis.zadd(bfoo, 1, ba);
+        jedis.zadd(bfoo, 2, bb);
+        jedis.zadd(bbar, 2, ba);
+
+        ZParams bparams = new ZParams();
+        bparams.weights(2, 2);
+        bparams.aggregate(ZParams.Aggregate.SUM);
+        int bresult = jedis.zinterstore("dst".getBytes(Protocol.UTF8), bparams, bfoo, bbar);
+
+        assertEquals(1, bresult);
+
+        Set<Tuple> bexpected = new LinkedHashSet<Tuple>();
+        bexpected.add(new Tuple(ba, new Double(6)));
+
+        assertTrue(JedisTest.isListAreEquals(bexpected, jedis.zrangeWithScores("dst".getBytes(Protocol.UTF8), 0, 100)));
+
     }
 }