diff --git a/src/main/java/redis/clients/jedis/BinaryJedis.java b/src/main/java/redis/clients/jedis/BinaryJedis.java
index d5b01d45fb..17358d911c 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedis.java
@@ -1860,14 +1860,14 @@ public Set<Tuple> zpopmax(final byte[] key, final int count) {
   }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key) {
+  public Tuple zpopmin(final byte[] key) {
     checkIsInMultiOrPipeline();
     client.zpopmin(key);
-    return getTupledSet();
+    return BuilderFactory.TUPLE.build(client.getBinaryMultiBulkReply());
   }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key, final long count) {
+  public Set<Tuple> zpopmin(final byte[] key, final int count) {
     checkIsInMultiOrPipeline();
     client.zpopmin(key, count);
     return getTupledSet();
diff --git a/src/main/java/redis/clients/jedis/BinaryJedisCluster.java b/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
index bde70d3f33..c5dc62fe1d 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
@@ -897,6 +897,16 @@ public Long execute(Jedis connection) {
     }.runBinary(key);
   }
 
+  @Override
+  public Double zscore(final byte[] key, final byte[] member) {
+    return new JedisClusterCommand<Double>(connectionHandler, maxAttempts) {
+      @Override
+      public Double execute(Jedis connection) {
+        return connection.zscore(key, member);
+      }
+    }.runBinary(key);
+  }
+
   @Override
   public Tuple zpopmax(final byte[] key) {
     return new JedisClusterCommand<Tuple>(connectionHandler, maxAttempts) {
@@ -916,33 +926,23 @@ public Set<Tuple> execute(Jedis connection) {
       }
     }.runBinary(key);
   }
-  
-  @Override
-  public Double zscore(final byte[] key, final byte[] member) {
-    return new JedisClusterCommand<Double>(connectionHandler, maxAttempts) {
-      @Override
-      public Double execute(Jedis connection) {
-        return connection.zscore(key, member);
-      }
-    }.runBinary(key);
-  }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key, final long count) {
-    return new JedisClusterCommand<Set<Tuple>>(connectionHandler, maxAttempts) {
+  public Tuple zpopmin(final byte[] key) {
+    return new JedisClusterCommand<Tuple>(connectionHandler, maxAttempts) {
       @Override
-      public Set<Tuple> execute(Jedis connection) {
-        return connection.zpopmin(key, count);
+      public Tuple execute(Jedis connection) {
+        return connection.zpopmin(key);
       }
     }.runBinary(key);
   }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key) {
+  public Set<Tuple> zpopmin(final byte[] key, final int count) {
     return new JedisClusterCommand<Set<Tuple>>(connectionHandler, maxAttempts) {
       @Override
       public Set<Tuple> execute(Jedis connection) {
-        return connection.zpopmin(key);
+        return connection.zpopmin(key, count);
       }
     }.runBinary(key);
   }
diff --git a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
index 1de9cb7ae6..e7f530de98 100644
--- a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
@@ -532,6 +532,12 @@ public Long zcard(final byte[] key) {
     return j.zcard(key);
   }
 
+  @Override
+  public Double zscore(final byte[] key, final byte[] member) {
+    Jedis j = getShard(key);
+    return j.zscore(key, member);
+  }
+
   @Override
   public Tuple zpopmax(final byte[] key) {
     Jedis j = getShard(key);
@@ -543,21 +549,15 @@ public Set<Tuple> zpopmax(final byte[] key, final int count) {
     Jedis j = getShard(key);
     return j.zpopmax(key, count);
   }
-  
-  @Override
-  public Double zscore(final byte[] key, final byte[] member) {
-    Jedis j = getShard(key);
-    return j.zscore(key, member);
-  }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key) {
+  public Tuple zpopmin(final byte[] key) {
     Jedis j = getShard(key);
     return j.zpopmin(key);
   }
 
   @Override
-  public Set<Tuple> zpopmin(final byte[] key, final long count) {
+  public Set<Tuple> zpopmin(final byte[] key, final int count) {
     Jedis j = getShard(key);
     return j.zpopmin(key, count);
   }
diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java
index 9cefecf901..8cfa8edce0 100644
--- a/src/main/java/redis/clients/jedis/Jedis.java
+++ b/src/main/java/redis/clients/jedis/Jedis.java
@@ -1691,14 +1691,14 @@ public Set<Tuple> zpopmax(final String key, final int count) {
   }
 
   @Override
-  public Set<Tuple> zpopmin(final String key) {
+  public Tuple zpopmin(final String key) {
     checkIsInMultiOrPipeline();
     client.zpopmin(key);
-    return getTupledSet();
+    return BuilderFactory.TUPLE.build(client.getBinaryMultiBulkReply());
   }
 
   @Override
-  public Set<Tuple> zpopmin(final String key, final long count) {
+  public Set<Tuple> zpopmin(final String key, final int count) {
     checkIsInMultiOrPipeline();
     client.zpopmin(key, count);
     return getTupledSet();
diff --git a/src/main/java/redis/clients/jedis/JedisCluster.java b/src/main/java/redis/clients/jedis/JedisCluster.java
index 19aef45da6..de33155116 100644
--- a/src/main/java/redis/clients/jedis/JedisCluster.java
+++ b/src/main/java/redis/clients/jedis/JedisCluster.java
@@ -934,7 +934,17 @@ public Long execute(Jedis connection) {
       }
     }.run(key);
   }
-  
+
+  @Override
+  public Double zscore(final String key, final String member) {
+    return new JedisClusterCommand<Double>(connectionHandler, maxAttempts) {
+      @Override
+      public Double execute(Jedis connection) {
+        return connection.zscore(key, member);
+      }
+    }.run(key);
+  }
+
   @Override
   public Tuple zpopmax(final String key) {
     return new JedisClusterCommand<Tuple>(connectionHandler, maxAttempts) {
@@ -954,13 +964,23 @@ public Set<Tuple> execute(Jedis connection) {
       }
     }.run(key);
   }
-  
+
   @Override
-  public Double zscore(final String key, final String member) {
-    return new JedisClusterCommand<Double>(connectionHandler, maxAttempts) {
+  public Tuple zpopmin(final String key) {
+    return new JedisClusterCommand<Tuple>(connectionHandler, maxAttempts) {
       @Override
-      public Double execute(Jedis connection) {
-        return connection.zscore(key, member);
+      public Tuple execute(Jedis connection) {
+        return connection.zpopmin(key);
+      }
+    }.run(key);
+  }
+
+  @Override
+  public Set<Tuple> zpopmin(final String key, final int count) {
+    return new JedisClusterCommand<Set<Tuple>>(connectionHandler, maxAttempts) {
+      @Override
+      public Set<Tuple> execute(Jedis connection) {
+        return connection.zpopmin(key, count);
       }
     }.run(key);
   }
diff --git a/src/main/java/redis/clients/jedis/PipelineBase.java b/src/main/java/redis/clients/jedis/PipelineBase.java
index ae8fa2d6ca..3b27103622 100644
--- a/src/main/java/redis/clients/jedis/PipelineBase.java
+++ b/src/main/java/redis/clients/jedis/PipelineBase.java
@@ -905,31 +905,7 @@ public Response<Long> zcard(final String key) {
     getClient(key).zcard(key);
     return getResponse(BuilderFactory.LONG);
   }
-  
-  @Override
-  public Response<Tuple> zpopmax(final String key) {
-    getClient(key).zpopmax(key);
-    return getResponse(BuilderFactory.TUPLE);
-  }
-  
-  @Override
-  public Response<Tuple> zpopmax(final byte[] key) {
-    getClient(key).zpopmax(key);
-    return getResponse(BuilderFactory.TUPLE);
-  }
 
-  @Override
-  public Response<Set<Tuple>> zpopmax(final String key, final int count) {
-    getClient(key).zpopmax(key, count);
-    return getResponse(BuilderFactory.TUPLE_ZSET);
-  }
-  
-  @Override
-  public Response<Set<Tuple>> zpopmax(final byte[] key, final int count) {
-    getClient(key).zpopmax(key, count);
-    return getResponse(BuilderFactory.TUPLE_ZSET);
-  }
-  
   @Override
   public Response<Long> zcard(final byte[] key) {
     getClient(key).zcard(key);
@@ -1325,13 +1301,49 @@ public Response<Double> zscore(final byte[] key, final byte[] member) {
   }
 
   @Override
-  public Response<Set<Tuple>> zpopmin(final String key) {
+  public Response<Tuple> zpopmax(final String key) {
+    getClient(key).zpopmax(key);
+    return getResponse(BuilderFactory.TUPLE);
+  }
+
+  @Override
+  public Response<Tuple> zpopmax(final byte[] key) {
+    getClient(key).zpopmax(key);
+    return getResponse(BuilderFactory.TUPLE);
+  }
+
+  @Override
+  public Response<Set<Tuple>> zpopmax(final String key, final int count) {
+    getClient(key).zpopmax(key, count);
+    return getResponse(BuilderFactory.TUPLE_ZSET);
+  }
+
+  @Override
+  public Response<Set<Tuple>> zpopmax(final byte[] key, final int count) {
+    getClient(key).zpopmax(key, count);
+    return getResponse(BuilderFactory.TUPLE_ZSET);
+  }
+
+  @Override
+  public Response<Tuple> zpopmin(final String key) {
+    getClient(key).zpopmin(key);
+    return getResponse(BuilderFactory.TUPLE);
+  }
+
+  @Override
+  public Response<Tuple> zpopmin(final byte[] key) {
     getClient(key).zpopmin(key);
+    return getResponse(BuilderFactory.TUPLE);
+  }
+
+  @Override
+  public Response<Set<Tuple>> zpopmin(final byte[] key, final int count) {
+    getClient(key).zpopmin(key, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zpopmin(final String key, final long count) {
+  public Response<Set<Tuple>> zpopmin(final String key, final int count) {
     getClient(key).zpopmin(key, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
diff --git a/src/main/java/redis/clients/jedis/ShardedJedis.java b/src/main/java/redis/clients/jedis/ShardedJedis.java
index 25d25d030f..d35fc724da 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedis.java
@@ -567,6 +567,12 @@ public Long zcard(final String key) {
     return j.zcard(key);
   }
 
+  @Override
+  public Double zscore(final String key, final String member) {
+    Jedis j = getShard(key);
+    return j.zscore(key, member);
+  }
+
   @Override
   public Tuple zpopmax(final String key) {
     Jedis j = getShard(key);
@@ -578,21 +584,15 @@ public Set<Tuple> zpopmax(final String key, final int count) {
     Jedis j = getShard(key);
     return j.zpopmax(key, count);
   }
-  
-  @Override
-  public Double zscore(final String key, final String member) {
-    Jedis j = getShard(key);
-    return j.zscore(key, member);
-  }
 
   @Override
-  public Set<Tuple> zpopmin(final String key) {
+  public Tuple zpopmin(final String key) {
     Jedis j = getShard(key);
     return j.zpopmin(key);
   }
 
   @Override
-  public Set<Tuple> zpopmin(final String key, final long count) {
+  public Set<Tuple> zpopmin(final String key, final int count) {
     Jedis j = getShard(key);
     return j.zpopmin(key, count);
   }
diff --git a/src/main/java/redis/clients/jedis/commands/BinaryJedisClusterCommands.java b/src/main/java/redis/clients/jedis/commands/BinaryJedisClusterCommands.java
index f8d20eb0ac..746de7a8c7 100644
--- a/src/main/java/redis/clients/jedis/commands/BinaryJedisClusterCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/BinaryJedisClusterCommands.java
@@ -176,16 +176,16 @@ public interface BinaryJedisClusterCommands {
   Set<Tuple> zrevrangeWithScores(byte[] key, long start, long stop);
 
   Long zcard(byte[] key);
-  
-  Tuple zpopmax(byte[] key);
-  
-  Set<Tuple> zpopmax(byte[] key, int count);
 
   Double zscore(byte[] key, byte[] member);
 
-  Set<Tuple> zpopmin(byte[] key);
+  Tuple zpopmax(byte[] key);
+
+  Set<Tuple> zpopmax(byte[] key, int count);
+
+  Tuple zpopmin(byte[] key);
 
-  Set<Tuple> zpopmin(byte[] key, long count);
+  Set<Tuple> zpopmin(byte[] key, int count);
 
   List<byte[]> sort(byte[] key);
 
diff --git a/src/main/java/redis/clients/jedis/commands/BinaryJedisCommands.java b/src/main/java/redis/clients/jedis/commands/BinaryJedisCommands.java
index 00e464105f..30d617fa9a 100644
--- a/src/main/java/redis/clients/jedis/commands/BinaryJedisCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/BinaryJedisCommands.java
@@ -188,9 +188,9 @@ public interface BinaryJedisCommands {
 
   Set<Tuple> zpopmax(byte[] key, int count);
 
-  Set<Tuple> zpopmin(byte[] key);
+  Tuple zpopmin(byte[] key);
 
-  Set<Tuple> zpopmin(byte[] key, long count);
+  Set<Tuple> zpopmin(byte[] key, int count);
 
   List<byte[]> sort(byte[] key);
 
diff --git a/src/main/java/redis/clients/jedis/commands/BinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/commands/BinaryRedisPipeline.java
index b3c3cb0881..5bf5646fb6 100644
--- a/src/main/java/redis/clients/jedis/commands/BinaryRedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/commands/BinaryRedisPipeline.java
@@ -166,10 +166,6 @@ public interface BinaryRedisPipeline {
   Response<Long> zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params);
 
   Response<Long> zcard(byte[] key);
-  
-  Response<Tuple> zpopmax(byte[] key);
-  
-  Response<Set<Tuple>> zpopmax(byte[] key, int count);
 
   Response<Long> zcount(byte[] key, double min, double max);
 
@@ -237,6 +233,14 @@ Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] m
 
   Response<Double> zscore(byte[] key, byte[] member);
 
+  Response<Tuple> zpopmax(byte[] key);
+
+  Response<Set<Tuple>> zpopmax(byte[] key, int count);
+
+  Response<Tuple> zpopmin(byte[] key);
+
+  Response<Set<Tuple>> zpopmin(byte[] key, int count);
+
   Response<Long> zlexcount(byte[] key, byte[] min, byte[] max);
 
   Response<Set<byte[]>> zrangeByLex(byte[] key, byte[] min, byte[] max);
diff --git a/src/main/java/redis/clients/jedis/commands/JedisClusterCommands.java b/src/main/java/redis/clients/jedis/commands/JedisClusterCommands.java
index 09e508039e..fb171bd2bb 100644
--- a/src/main/java/redis/clients/jedis/commands/JedisClusterCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/JedisClusterCommands.java
@@ -175,12 +175,16 @@ public interface JedisClusterCommands {
   Set<Tuple> zrevrangeWithScores(String key, long start, long stop);
 
   Long zcard(String key);
-  
+
+  Double zscore(String key, String member);
+
   Tuple zpopmax(String key);
-  
+
   Set<Tuple> zpopmax(String key, int count);
 
-  Double zscore(String key, String member);
+  Tuple zpopmin(String key);
+
+  Set<Tuple> zpopmin(String key, int count);
 
   List<String> sort(String key);
 
diff --git a/src/main/java/redis/clients/jedis/commands/JedisCommands.java b/src/main/java/redis/clients/jedis/commands/JedisCommands.java
index 65fcf1138e..6b3506905b 100644
--- a/src/main/java/redis/clients/jedis/commands/JedisCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/JedisCommands.java
@@ -185,15 +185,15 @@ public interface JedisCommands {
 
   Long zcard(String key);
 
+  Double zscore(String key, String member);
+
   Tuple zpopmax(String key);
-  
+
   Set<Tuple> zpopmax(String key, int count);
-  
-  Double zscore(String key, String member);
 
-  Set<Tuple> zpopmin(String key);
+  Tuple zpopmin(String key);
 
-  Set<Tuple> zpopmin(String key, long count);
+  Set<Tuple> zpopmin(String key, int count);
 
   List<String> sort(String key);
 
diff --git a/src/main/java/redis/clients/jedis/commands/RedisPipeline.java b/src/main/java/redis/clients/jedis/commands/RedisPipeline.java
index e69ce72b6c..92647e0ebe 100644
--- a/src/main/java/redis/clients/jedis/commands/RedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/commands/RedisPipeline.java
@@ -166,10 +166,6 @@ public interface RedisPipeline {
   Response<Long> zadd(String key, Map<String, Double> scoreMembers, ZAddParams params);
 
   Response<Long> zcard(String key);
-  
-  Response<Tuple> zpopmax(String key);
-  
-  Response<Set<Tuple>> zpopmax(String key, int count);
 
   Response<Long> zcount(String key, double min, double max);
 
@@ -232,9 +228,13 @@ Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, String max, String m
 
   Response<Double> zscore(String key, String member);
 
-  Response<Set<Tuple>> zpopmin(String key);
+  Response<Tuple> zpopmax(String key);
+
+  Response<Set<Tuple>> zpopmax(String key, int count);
+
+  Response<Tuple> zpopmin(String key);
 
-  Response<Set<Tuple>> zpopmin(String key, long count);
+  Response<Set<Tuple>> zpopmin(String key, int count);
 
   Response<Long> zlexcount(String key, String min, String max);
 
diff --git a/src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
index 17cdc5e343..77c2bc3691 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
@@ -4,13 +4,11 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
 import static redis.clients.jedis.ScanParams.SCAN_POINTER_START;
 import static redis.clients.jedis.ScanParams.SCAN_POINTER_START_BINARY;
 import static redis.clients.jedis.tests.utils.AssertUtil.assertByteArraySetEquals;
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Map;
@@ -551,24 +549,21 @@ public void zpopmax() {
     jedis.zadd("foo", 10d, "b");
     jedis.zadd("foo", 0.1d, "c");
     jedis.zadd("foo", 2d, "d");
-
+    
     Tuple actual = jedis.zpopmax("foo");
     Tuple expected = new Tuple("b", 10d);
     assertEquals(expected, actual);
-
+    
     actual = jedis.zpopmax("foo");
     expected = new Tuple("d", 2d);
-    
     assertEquals(expected, actual);
-
+    
     actual = jedis.zpopmax("foo");
     expected = new Tuple("a", 1d);
-    
     assertEquals(expected, actual);
     
     actual = jedis.zpopmax("foo");
     expected = new Tuple("c", 0.1d);
-    
     assertEquals(expected, actual);
     
     // Empty
@@ -580,30 +575,25 @@ public void zpopmax() {
     jedis.zadd(bfoo, 10d, bb);
     jedis.zadd(bfoo, 0.1d, bc);
     jedis.zadd(bfoo, 2d, ba);
-
+    
     // First
     actual = jedis.zpopmax(bfoo);
     expected = new Tuple(bb, 10d);
-    
     assertEquals(expected, actual);
-
+    
     // Second
     actual = jedis.zpopmax(bfoo);
     expected = new Tuple(ba, 2d);
-    
     assertEquals(expected, actual);
     
     // Third
     actual = jedis.zpopmax(bfoo);
     expected = new Tuple(bc, 0.1d);
-    
     assertEquals(expected, actual);
     
     // Empty
     actual = jedis.zpopmax(bfoo);
-    expected = null;
-
-    assertEquals(expected, actual);
+    assertNull(actual);
   }
 
   @Test
@@ -613,16 +603,15 @@ public void zpopmaxWithCount() {
     jedis.zadd("foo", 0.1d, "c");
     jedis.zadd("foo", 2d, "d");
     jedis.zadd("foo", 0.03, "e");
-
+    
     Set<Tuple> actual = jedis.zpopmax("foo", 2);
     assertEquals(2, actual.size());
     
-    Set<Tuple> expected = new HashSet<Tuple>();
+    Set<Tuple> expected = new LinkedHashSet<Tuple>();
     expected.add(new Tuple("b", 10d));
     expected.add(new Tuple("d", 2d));
-    
     assertEquals(expected, actual);
-
+    
     actual = jedis.zpopmax("foo", 3);
     assertEquals(3, actual.size());
     
@@ -630,47 +619,40 @@ public void zpopmaxWithCount() {
     expected.add(new Tuple("a", 1d));
     expected.add(new Tuple("c", 0.1d));
     expected.add(new Tuple("e", 0.03d));
-    
     assertEquals(expected, actual);
     
     // Empty
     actual = jedis.zpopmax("foo", 1);
-    assertTrue(actual.isEmpty());
+    expected.clear();
+    assertEquals(expected, actual);
     
     // Binary
     jedis.zadd(bfoo, 1d, ba);
     jedis.zadd(bfoo, 10d, bb);
     jedis.zadd(bfoo, 0.1d, bc);
     jedis.zadd(bfoo, 2d, ba);
-
+    
     // First
     actual = jedis.zpopmax(bfoo, 1);
-
     expected.clear();
     expected.add(new Tuple(bb, 10d));
-    
     assertEquals(expected, actual);
 
     // Second
     actual = jedis.zpopmax(bfoo, 1);
-
     expected.clear();
     expected.add(new Tuple(ba, 2d));
-    
     assertEquals(expected, actual);
     
     // Last 2 (just 1, because 1 was overwritten)
     actual = jedis.zpopmax(bfoo, 1);
-
     expected.clear();
     expected.add(new Tuple(bc, 0.1d));
-    
     assertEquals(expected, actual);
     
     // Empty
     actual = jedis.zpopmax(bfoo, 1);
     expected.clear();
-    
     assertEquals(expected, actual);
   }
   
@@ -690,12 +672,8 @@ public void zpopmin() {
 
     assertEquals(expected, range);
 
-    range = jedis.zpopmin("foo");
-
-    expected = new LinkedHashSet<Tuple>();
-    expected.add(new Tuple("b", 10d));
-
-    assertEquals(expected, range);
+    Tuple tuple = jedis.zpopmin("foo");
+    assertEquals(new Tuple("b", 10d), tuple);
 
     // Binary
 
@@ -712,15 +690,11 @@ public void zpopmin() {
 
     assertEquals(bexpected, brange);
 
-    brange = jedis.zpopmin(bfoo);
-
-    bexpected = new LinkedHashSet<Tuple>();
-    bexpected.add(new Tuple(bb, 10d));
-
-    assertEquals(bexpected, brange);
+    tuple = jedis.zpopmin(bfoo);
+    assertEquals(new Tuple(bb, 10d), tuple);
   }
 
-    @Test
+  @Test
   public void zcount() {
     jedis.zadd("foo", 1d, "a");
     jedis.zadd("foo", 10d, "b");