RSet implements RSortable interface #703

redisson/src/main/java/org/redisson/RedissonList.java

@@ -636,7 +636,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
     
     @Override
     public RFuture<List<V>> readSortAsync(SortOrder order) {
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), order);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), order);
     }
 
     @Override
@@ -646,7 +646,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
     
     @Override
     public RFuture<List<V>> readSortAsync(SortOrder order, int offset, int count) {
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "LIMIT", offset, count, order);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "LIMIT", offset, count, order);
     }
 
     @Override
@@ -656,7 +656,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
     
     @Override
     public RFuture<List<V>> readSortAsync(String byPattern, SortOrder order) {
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "BY", byPattern, order);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, order);
     }
     
     @Override
@@ -666,7 +666,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
     
     @Override
     public RFuture<List<V>> readSortAsync(String byPattern, SortOrder order, int offset, int count) {
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, getName(), "BY", byPattern, "LIMIT", offset, count, order);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, getName(), "BY", byPattern, "LIMIT", offset, count, order);
     }
 
     @Override
@@ -707,7 +707,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
         }
         params.add(order);
         
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT, params.toArray());
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_LIST, params.toArray());
     }
     
     @Override
@@ -790,7 +790,7 @@ public class RedissonList<V> extends RedissonExpirable implements RList<V> {
         params.add("STORE");
         params.add(destName);
         
-        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
+        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
     }
 
 }

redisson/src/main/java/org/redisson/RedissonSet.java

@@ -19,12 +19,14 @@ import java.net.InetSocketAddress;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
 import org.redisson.api.RFuture;
 import org.redisson.api.RSet;
+import org.redisson.api.SortOrder;
 import org.redisson.client.codec.Codec;
 import org.redisson.client.protocol.RedisCommand;
 import org.redisson.client.protocol.RedisCommand.ValueType;
@@ -356,4 +358,168 @@ public class RedissonSet<V> extends RedissonExpirable implements RSet<V> {
         }
     }
     
+    @Override
+    public Set<V> readSort(SortOrder order) {
+        return get(readSortAsync(order));
+    }
+    
+    @Override
+    public RFuture<Set<V>> readSortAsync(SortOrder order) {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), order);
+    }
+
+    @Override
+    public Set<V> readSort(SortOrder order, int offset, int count) {
+        return get(readSortAsync(order, offset, count));
+    }
+    
+    @Override
+    public RFuture<Set<V>> readSortAsync(SortOrder order, int offset, int count) {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "LIMIT", offset, count, order);
+    }
+
+    @Override
+    public Set<V> readSort(String byPattern, SortOrder order) {
+        return get(readSortAsync(byPattern, order));
+    }
+    
+    @Override
+    public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order) {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, order);
+    }
+    
+    @Override
+    public Set<V> readSort(String byPattern, SortOrder order, int offset, int count) {
+        return get(readSortAsync(byPattern, order, offset, count));
+    }
+    
+    @Override
+    public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order, int offset, int count) {
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, getName(), "BY", byPattern, "LIMIT", offset, count, order);
+    }
+
+    @Override
+    public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order) {
+        return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order));
+    }
+    
+    @Override
+    public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order) {
+        return readSortAsync(byPattern, getPatterns, order, -1, -1);
+    }
+    
+    @Override
+    public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
+        return (Collection<T>)get(readSortAsync(byPattern, getPatterns, order, offset, count));
+    }
+
+    @Override
+    public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
+        List<Object> params = new ArrayList<Object>();
+        params.add(getName());
+        if (byPattern != null) {
+            params.add("BY");
+            params.add(byPattern);
+        }
+        if (offset != -1 && count != -1) {
+            params.add("LIMIT");
+        }
+        if (offset != -1) {
+            params.add(offset);
+        }
+        if (count != -1) {
+            params.add(count);
+        }
+        for (String pattern : getPatterns) {
+            params.add("GET");
+            params.add(pattern);
+        }
+        params.add(order);
+        
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.SORT_SET, params.toArray());
+    }
+    
+    @Override
+    public int sortTo(String destName, SortOrder order) {
+        return get(sortToAsync(destName, order));
+    }
+    
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, SortOrder order) {
+        return sortToAsync(destName, null, Collections.<String>emptyList(), order, -1, -1);
+    }
+    
+    @Override
+    public int sortTo(String destName, SortOrder order, int offset, int count) {
+        return get(sortToAsync(destName, order, offset, count));
+    }
+    
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, SortOrder order, int offset, int count) {
+        return sortToAsync(destName, null, Collections.<String>emptyList(), order, offset, count);
+    }
+
+    @Override
+    public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) {
+        return get(sortToAsync(destName, byPattern, order, offset, count));
+    }
+    
+    @Override
+    public int sortTo(String destName, String byPattern, SortOrder order) {
+        return get(sortToAsync(destName, byPattern, order));
+    }
+
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order) {
+        return sortToAsync(destName, byPattern, Collections.<String>emptyList(), order, -1, -1);
+    }
+
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) {
+        return sortToAsync(destName, byPattern, Collections.<String>emptyList(), order, offset, count);
+    }
+
+    @Override
+    public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
+        return get(sortToAsync(destName, byPattern, getPatterns, order));
+    }
+    
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
+        return sortToAsync(destName, byPattern, getPatterns, order, -1, -1);
+    }
+    
+    @Override
+    public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
+        return get(sortToAsync(destName, byPattern, getPatterns, order, offset, count));
+    }
+
+    @Override
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset, int count) {
+        List<Object> params = new ArrayList<Object>();
+        params.add(getName());
+        if (byPattern != null) {
+            params.add("BY");
+            params.add(byPattern);
+        }
+        if (offset != -1 && count != -1) {
+            params.add("LIMIT");
+        }
+        if (offset != -1) {
+            params.add(offset);
+        }
+        if (count != -1) {
+            params.add(count);
+        }
+        for (String pattern : getPatterns) {
+            params.add("GET");
+            params.add(pattern);
+        }
+        params.add(order);
+        params.add("STORE");
+        params.add(destName);
+        
+        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SORT_TO, params.toArray());
+    }
+    
 }

redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java

@@ -27,6 +27,7 @@ import java.util.concurrent.TimeUnit;
 
 import org.redisson.api.RFuture;
 import org.redisson.api.RSet;
+import org.redisson.api.SortOrder;
 import org.redisson.client.codec.Codec;
 import org.redisson.client.protocol.RedisCommand;
 import org.redisson.client.protocol.RedisCommand.ValueType;
@@ -55,6 +56,7 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
     private static final RedisCommand<Boolean> EVAL_CONTAINS_VALUE = new RedisCommand<Boolean>("EVAL", new BooleanReplayConvertor(), 6, Arrays.asList(ValueType.MAP_KEY, ValueType.MAP_VALUE));
     private static final RedisCommand<Boolean> EVAL_CONTAINS_ALL_WITH_VALUES = new RedisCommand<Boolean>("EVAL", new BooleanReplayConvertor(), 7, ValueType.OBJECTS);
     
+    private final RSet<V> set;
     private final Object key;
     private final String timeoutSetName;
     
@@ -62,6 +64,7 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
         super(codec, commandExecutor, name);
         this.timeoutSetName = timeoutSetName;
         this.key = key;
+        this.set = new RedissonSet<V>(codec, commandExecutor, name);
     }
 
     @Override
@@ -225,17 +228,17 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
 
     @Override
     public boolean add(V e) {
-        return get(addAsync(e));
+        return set.add(e);
     }
 
     @Override
     public RFuture<Boolean> addAsync(V e) {
-        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SADD_SINGLE, getName(), e);
+        return set.addAsync(e);
     }
 
     @Override
     public V removeRandom() {
-        return get(removeRandomAsync());
+        return set.removeRandom();
     }
 
     @Override
@@ -515,4 +518,106 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
         return commandExecutor.writeAsync(getName(), codec, RedisCommands.SINTER, args.toArray());
     }
 
+    public RFuture<Set<V>> readSortAsync(SortOrder order) {
+        return set.readSortAsync(order);
+    }
+
+    public Set<V> readSort(SortOrder order) {
+        return set.readSort(order);
+    }
+
+    public RFuture<Set<V>> readSortAsync(SortOrder order, int offset, int count) {
+        return set.readSortAsync(order, offset, count);
+    }
+
+    public Set<V> readSort(SortOrder order, int offset, int count) {
+        return set.readSort(order, offset, count);
+    }
+
+    public Set<V> readSort(String byPattern, SortOrder order) {
+        return set.readSort(byPattern, order);
+    }
+
+    public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order) {
+        return set.readSortAsync(byPattern, order);
+    }
+
+    public Set<V> readSort(String byPattern, SortOrder order, int offset, int count) {
+        return set.readSort(byPattern, order, offset, count);
+    }
+
+    public RFuture<Set<V>> readSortAsync(String byPattern, SortOrder order, int offset, int count) {
+        return set.readSortAsync(byPattern, order, offset, count);
+    }
+
+    public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order) {
+        return set.readSort(byPattern, getPatterns, order);
+    }
+
+    public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order) {
+        return set.readSortAsync(byPattern, getPatterns, order);
+    }
+
+    public <T> Collection<T> readSort(String byPattern, List<String> getPatterns, SortOrder order, int offset,
+            int count) {
+        return set.readSort(byPattern, getPatterns, order, offset, count);
+    }
+
+    public <T> RFuture<Collection<T>> readSortAsync(String byPattern, List<String> getPatterns, SortOrder order,
+            int offset, int count) {
+        return set.readSortAsync(byPattern, getPatterns, order, offset, count);
+    }
+
+    public int sortTo(String destName, SortOrder order) {
+        return set.sortTo(destName, order);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, SortOrder order) {
+        return set.sortToAsync(destName, order);
+    }
+
+    public int sortTo(String destName, SortOrder order, int offset, int count) {
+        return set.sortTo(destName, order, offset, count);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, SortOrder order, int offset, int count) {
+        return set.sortToAsync(destName, order, offset, count);
+    }
+
+    public int sortTo(String destName, String byPattern, SortOrder order) {
+        return set.sortTo(destName, byPattern, order);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order) {
+        return set.sortToAsync(destName, byPattern, order);
+    }
+
+    public int sortTo(String destName, String byPattern, SortOrder order, int offset, int count) {
+        return set.sortTo(destName, byPattern, order, offset, count);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, SortOrder order, int offset, int count) {
+        return set.sortToAsync(destName, byPattern, order, offset, count);
+    }
+
+    public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
+        return set.sortTo(destName, byPattern, getPatterns, order);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order) {
+        return set.sortToAsync(destName, byPattern, getPatterns, order);
+    }
+
+    public int sortTo(String destName, String byPattern, List<String> getPatterns, SortOrder order, int offset,
+            int count) {
+        return set.sortTo(destName, byPattern, getPatterns, order, offset, count);
+    }
+
+    public RFuture<Integer> sortToAsync(String destName, String byPattern, List<String> getPatterns, SortOrder order,
+            int offset, int count) {
+        return set.sortToAsync(destName, byPattern, getPatterns, order, offset, count);
+    }
+
+    
+    
 }

redisson/src/main/java/org/redisson/api/RSet.java

@@ -24,7 +24,7 @@ import java.util.Set;
  *
  * @param <V> value
  */
-public interface RSet<V> extends Set<V>, RExpirable, RSetAsync<V> {
+public interface RSet<V> extends Set<V>, RExpirable, RSetAsync<V>, RSortable<Set<V>> {
 
     /**
      * Removes and returns random elements from set

redisson/src/main/java/org/redisson/client/protocol/RedisCommands.java

@@ -184,7 +184,8 @@ public interface RedisCommands {
     RedisStrictCommand<Long> PFCOUNT = new RedisStrictCommand<Long>("PFCOUNT");
     RedisStrictCommand<Void> PFMERGE = new RedisStrictCommand<Void>("PFMERGE", new VoidReplayConvertor());
 
-    RedisCommand<List<Object>> SORT = new RedisCommand<List<Object>>("SORT", new ObjectListReplayDecoder<Object>());
+    RedisCommand<List<Object>> SORT_LIST = new RedisCommand<List<Object>>("SORT", new ObjectListReplayDecoder<Object>());
+    RedisCommand<Set<Object>> SORT_SET = new RedisCommand<Set<Object>>("SORT", new ObjectSetReplayDecoder<Object>());
     RedisCommand<Integer> SORT_TO = new RedisCommand<Integer>("SORT", new IntegerReplayConvertor());
     
     RedisStrictCommand<Long> RPOP = new RedisStrictCommand<Long>("RPOP");

redisson/src/test/java/org/redisson/RedissonSetTest.java

@@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 import java.io.Serializable;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -13,7 +14,11 @@ import java.util.concurrent.ExecutionException;
 import org.junit.Assert;
 import org.junit.Test;
 import org.redisson.api.RFuture;
+import org.redisson.api.RList;
 import org.redisson.api.RSet;
+import org.redisson.api.SortOrder;
+import org.redisson.client.codec.IntegerCodec;
+import org.redisson.client.codec.StringCodec;
 
 public class RedissonSetTest extends BaseTest {
 
@@ -31,6 +36,168 @@ public class RedissonSetTest extends BaseTest {
 
     }
 
+    @Test
+    public void testSortOrder() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        Set<Integer> descSort = list.readSort(SortOrder.DESC);
+        assertThat(descSort).containsExactly(3, 2, 1);
+
+        Set<Integer> ascSort = list.readSort(SortOrder.ASC);
+        assertThat(ascSort).containsExactly(1, 2, 3);
+    }
+    
+    @Test
+    public void testSortOrderLimit() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        Set<Integer> descSort = list.readSort(SortOrder.DESC, 1, 2);
+        assertThat(descSort).containsExactly(2, 1);
+
+        Set<Integer> ascSort = list.readSort(SortOrder.ASC, 1, 2);
+        assertThat(ascSort).containsExactly(2, 3);
+    }
+
+    @Test
+    public void testSortOrderByPattern() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3);
+        redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2);
+        redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1);
+        
+        Set<Integer> descSort = list.readSort("test*", SortOrder.DESC);
+        assertThat(descSort).containsExactly(1, 2, 3);
+
+        Set<Integer> ascSort = list.readSort("test*", SortOrder.ASC);
+        assertThat(ascSort).containsExactly(3, 2, 1);
+    }
+    
+    @Test
+    public void testSortOrderByPatternLimit() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3);
+        redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2);
+        redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1);
+        
+        Set<Integer> descSort = list.readSort("test*", SortOrder.DESC, 1, 2);
+        assertThat(descSort).containsExactly(2, 3);
+
+        Set<Integer> ascSort = list.readSort("test*", SortOrder.ASC, 1, 2);
+        assertThat(ascSort).containsExactly(2, 1);
+    }
+
+    @Test
+    public void testSortOrderByPatternGet() {
+        RSet<String> list = redisson.getSet("list", StringCodec.INSTANCE);
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        
+        redisson.getBucket("test1", IntegerCodec.INSTANCE).set(1);
+        redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2);
+        redisson.getBucket("test3", IntegerCodec.INSTANCE).set(3);
+        
+        redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1");
+        redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2");
+        redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3");
+        
+        Collection<String> descSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC);
+        assertThat(descSort).containsExactly("obj3", "obj2", "obj1");
+
+        Collection<String> ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC);
+        assertThat(ascSort).containsExactly("obj1", "obj2", "obj3");
+    }
+    
+    @Test
+    public void testSortOrderByPatternGetLimit() {
+        RSet<String> list = redisson.getSet("list", StringCodec.INSTANCE);
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        
+        redisson.getBucket("test1", IntegerCodec.INSTANCE).set(1);
+        redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2);
+        redisson.getBucket("test3", IntegerCodec.INSTANCE).set(3);
+        
+        redisson.getBucket("tester1", StringCodec.INSTANCE).set("obj1");
+        redisson.getBucket("tester2", StringCodec.INSTANCE).set("obj2");
+        redisson.getBucket("tester3", StringCodec.INSTANCE).set("obj3");
+        
+        Collection<String> descSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.DESC, 1, 2);
+        assertThat(descSort).containsExactly("obj2", "obj1");
+
+        Collection<String> ascSort = list.readSort("test*", Arrays.asList("tester*"), SortOrder.ASC, 1, 2);
+        assertThat(ascSort).containsExactly("obj2", "obj3");
+    }
+    
+    @Test
+    public void testSortTo() {
+        RSet<String> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add("1");
+        list.add("2");
+        list.add("3");
+        
+        assertThat(list.sortTo("test3", SortOrder.DESC)).isEqualTo(3);
+        RList<String> list2 = redisson.getList("test3", StringCodec.INSTANCE);
+        assertThat(list2).containsExactly("3", "2", "1");
+        
+        assertThat(list.sortTo("test4", SortOrder.ASC)).isEqualTo(3);
+        RList<String> list3 = redisson.getList("test4", StringCodec.INSTANCE);
+        assertThat(list3).containsExactly("1", "2", "3");
+
+    }
+
+    @Test
+    public void testSortToLimit() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        assertThat(list.sortTo("test3", SortOrder.DESC, 1, 2)).isEqualTo(2);
+        RList<String> list2 = redisson.getList("test3", StringCodec.INSTANCE);
+        assertThat(list2).containsExactly("2", "1");
+        
+        assertThat(list.sortTo("test4", SortOrder.ASC, 1, 2)).isEqualTo(2);
+        RList<String> list3 = redisson.getList("test4", StringCodec.INSTANCE);
+        assertThat(list3).containsExactly("2", "3");
+    }
+
+    @Test
+    public void testSortToByPattern() {
+        RSet<Integer> list = redisson.getSet("list", IntegerCodec.INSTANCE);
+        list.add(1);
+        list.add(2);
+        list.add(3);
+        
+        redisson.getBucket("test1", IntegerCodec.INSTANCE).set(3);
+        redisson.getBucket("test2", IntegerCodec.INSTANCE).set(2);
+        redisson.getBucket("test3", IntegerCodec.INSTANCE).set(1);
+        
+        assertThat(list.sortTo("tester3", "test*", SortOrder.DESC, 1, 2)).isEqualTo(2);
+        RList<String> list2 = redisson.getList("tester3", StringCodec.INSTANCE);
+        assertThat(list2).containsExactly("2", "3");
+        
+        assertThat(list.sortTo("tester4", "test*", SortOrder.ASC, 1, 2)).isEqualTo(2);
+        RList<String> list3 = redisson.getList("tester4", StringCodec.INSTANCE);
+        assertThat(list3).containsExactly("2", "1");
+    }
+
+    
     @Test
     public void testRemoveRandom() {
         RSet<Integer> set = redisson.getSet("simple");