diff --git a/src/main/java/org/redisson/RedissonBitSet.java b/src/main/java/org/redisson/RedissonBitSet.java
index aef6ed9b8..2fceb04f5 100644
--- a/src/main/java/org/redisson/RedissonBitSet.java
+++ b/src/main/java/org/redisson/RedissonBitSet.java
@@ -35,82 +35,102 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
         super(connectionManager, name);
     }
 
+    @Override
     public int length() {
         return get(lengthAsync());
     }
 
+    @Override
     public void set(BitSet bs) {
         get(setAsync(bs));
     }
 
-    public boolean get(int bitIndex) {
+    @Override
+    public boolean get(long bitIndex) {
         return get(getAsync(bitIndex));
     }
 
-    public Future<Boolean> getAsync(int bitIndex) {
+    @Override
+    public Future<Boolean> getAsync(long bitIndex) {
         return commandExecutor.readAsync(getName(), codec, RedisCommands.GETBIT, getName(), bitIndex);
     }
 
-    public void set(int bitIndex) {
+    @Override
+    public void set(long bitIndex) {
         get(setAsync(bitIndex, true));
     }
 
-    public void set(int fromIndex, int toIndex, boolean value) {
+    @Override
+    public void set(long fromIndex, long toIndex, boolean value) {
         get(setAsync(fromIndex, toIndex, value));
     }
 
-    public void set(int fromIndex, int toIndex) {
+    @Override
+    public void set(long fromIndex, long toIndex) {
         get(setAsync(fromIndex, toIndex));
     }
 
-    public void set(int bitIndex, boolean value) {
+    @Override
+    public void set(long bitIndex, boolean value) {
         get(setAsync(bitIndex, value));
     }
 
-    public Future<Void> setAsync(int bitIndex, boolean value) {
-        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), bitIndex, value ? 1 : 0);
+    @Override
+    public Future<Void> setAsync(long bitIndex, boolean value) {
+        return commandExecutor.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), bitIndex, value ? 1 : 0);
     }
 
+    @Override
     public byte[] toByteArray() {
         return get(toByteArrayAsync());
     }
 
+    @Override
     public Future<byte[]> toByteArrayAsync() {
         return commandExecutor.readAsync(getName(), ByteArrayCodec.INSTANCE, RedisCommands.GET, getName());
     }
 
+    @Override
     public int cardinality() {
         return get(cardinalityAsync());
     }
 
+    @Override
     public int size() {
         return get(sizeAsync());
     }
 
-    public void clear(int fromIndex, int toIndex) {
+    @Override
+    public void clear(long fromIndex, long toIndex) {
         get(clearAsync(fromIndex, toIndex));
     }
 
-    public void clear(int bitIndex) {
+    @Override
+    public void clear(long bitIndex) {
         get(clearAsync(bitIndex));
     }
 
+    @Override
     public void clear() {
         get(clearAsync());
     }
 
+    @Override
     public void or(String... bitSetNames) {
         get(orAsync(bitSetNames));
     }
 
+    @Override
     public void and(String... bitSetNames) {
         get(andAsync(bitSetNames));
     }
 
+    @Override
     public void xor(String... bitSetNames) {
         get(xorAsync(bitSetNames));
     }
 
+    @Override
     public void not() {
         get(notAsync());
     }
@@ -124,6 +144,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
         return commandExecutor.writeAsync(getName(), codec, RedisCommands.BITOP, params.toArray());
     }
 
+    @Override
     public BitSet asBitSet() {
         return fromByteArrayReverse(toByteArray());
     }
@@ -171,7 +192,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
     }
 
     @Override
-    public Future<Void> setAsync(int fromIndex, int toIndex, boolean value) {
+    public Future<Void> setAsync(long fromIndex, long toIndex, boolean value) {
         if (value) {
             return setAsync(fromIndex, toIndex);
         }
@@ -179,10 +200,10 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
     }
 
     @Override
-    public Future<Void> clearAsync(int fromIndex, int toIndex) {
+    public Future<Void> clearAsync(long fromIndex, long toIndex) {
         CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
-        for (int i = fromIndex; i < toIndex; i++) {
-            executorService.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), i, 0);
+        for (long i = fromIndex; i < toIndex; i++) {
+            executorService.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), i, 0);
         }
         return executorService.executeAsyncVoid();
     }
@@ -198,10 +219,10 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
     }
 
     @Override
-    public Future<Void> setAsync(int fromIndex, int toIndex) {
+    public Future<Void> setAsync(long fromIndex, long toIndex) {
         CommandBatchService executorService = new CommandBatchService(commandExecutor.getConnectionManager());
-        for (int i = fromIndex; i < toIndex; i++) {
-            executorService.writeAsync(getName(), codec, RedisCommands.SETBIT, getName(), i, 1);
+        for (long i = fromIndex; i < toIndex; i++) {
+            executorService.writeAsync(getName(), codec, RedisCommands.SETBIT_VOID, getName(), i, 1);
         }
         return executorService.executeAsyncVoid();
     }
@@ -212,7 +233,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
     }
 
     @Override
-    public Future<Void> setAsync(int bitIndex) {
+    public Future<Void> setAsync(long bitIndex) {
         return setAsync(bitIndex, true);
     }
 
@@ -222,7 +243,7 @@ public class RedissonBitSet extends RedissonExpirable implements RBitSet {
     }
 
     @Override
-    public Future<Void> clearAsync(int bitIndex) {
+    public Future<Void> clearAsync(long bitIndex) {
         return setAsync(bitIndex, false);
     }
 
diff --git a/src/main/java/org/redisson/RedissonObject.java b/src/main/java/org/redisson/RedissonObject.java
index 07c85e825..845350e52 100644
--- a/src/main/java/org/redisson/RedissonObject.java
+++ b/src/main/java/org/redisson/RedissonObject.java
@@ -54,7 +54,7 @@ abstract class RedissonObject implements RObject {
     }
 
     protected <V> Future<V> newSucceededFuture(V result) {
-        return commandExecutor.getConnectionManager().getGroup().next().<V>newSucceededFuture(result);
+        return commandExecutor.getConnectionManager().<V>newSucceededFuture(result);
     }
 
     @Override
diff --git a/src/main/java/org/redisson/core/RBitSet.java b/src/main/java/org/redisson/core/RBitSet.java
index 3f1fbbff5..c934f4875 100644
--- a/src/main/java/org/redisson/core/RBitSet.java
+++ b/src/main/java/org/redisson/core/RBitSet.java
@@ -26,29 +26,29 @@ public interface RBitSet extends RExpirable, RBitSetAsync {
 
     int length();
 
-    void set(int fromIndex, int toIndex, boolean value);
+    void set(long fromIndex, long toIndex, boolean value);
 
-    void clear(int fromIndex, int toIndex);
+    void clear(long fromIndex, long toIndex);
 
     void set(BitSet bs);
 
     void not();
 
-    void set(int fromIndex, int toIndex);
+    void set(long fromIndex, long toIndex);
 
     int size();
 
-    boolean get(int bitIndex);
+    boolean get(long bitIndex);
 
-    void set(int bitIndex);
+    void set(long bitIndex);
 
-    void set(int bitIndex, boolean value);
+    void set(long bitIndex, boolean value);
 
     byte[] toByteArray();
 
     int cardinality();
 
-    void clear(int bitIndex);
+    void clear(long bitIndex);
 
     void clear();
 
diff --git a/src/main/java/org/redisson/core/RBitSetAsync.java b/src/main/java/org/redisson/core/RBitSetAsync.java
index f22de3927..8fdb93cea 100644
--- a/src/main/java/org/redisson/core/RBitSetAsync.java
+++ b/src/main/java/org/redisson/core/RBitSetAsync.java
@@ -30,27 +30,27 @@ public interface RBitSetAsync extends RExpirableAsync {
 
     Future<Integer> lengthAsync();
 
-    Future<Void> setAsync(int fromIndex, int toIndex, boolean value);
+    Future<Void> setAsync(long fromIndex, long toIndex, boolean value);
 
-    Future<Void> clearAsync(int fromIndex, int toIndex);
+    Future<Void> clearAsync(long fromIndex, long toIndex);
 
     Future<Void> setAsync(BitSet bs);
 
     Future<Void> notAsync();
 
-    Future<Void> setAsync(int fromIndex, int toIndex);
+    Future<Void> setAsync(long fromIndex, long toIndex);
 
     Future<Integer> sizeAsync();
 
-    Future<Boolean> getAsync(int bitIndex);
+    Future<Boolean> getAsync(long bitIndex);
 
-    Future<Void> setAsync(int bitIndex);
+    Future<Void> setAsync(long bitIndex);
 
-    Future<Void> setAsync(int bitIndex, boolean value);
+    Future<Void> setAsync(long bitIndex, boolean value);
 
     Future<Integer> cardinalityAsync();
 
-    Future<Void> clearAsync(int bitIndex);
+    Future<Void> clearAsync(long bitIndex);
 
     Future<Void> clearAsync();
 
diff --git a/src/test/java/org/redisson/RedissonBitSetTest.java b/src/test/java/org/redisson/RedissonBitSetTest.java
index 83ece26fc..8c83e301d 100644
--- a/src/test/java/org/redisson/RedissonBitSetTest.java
+++ b/src/test/java/org/redisson/RedissonBitSetTest.java
@@ -2,38 +2,47 @@ package org.redisson;
 
 import java.util.BitSet;
 
-import org.junit.Assert;
+import static org.assertj.core.api.Assertions.*;
 import org.junit.Test;
 import org.redisson.core.RBitSet;
 
 public class RedissonBitSetTest extends BaseTest {
 
+    @Test
+    public void testIndexRange() {
+        RBitSet bs = redisson.getBitSet("testbitset");
+        long topIndex = Integer.MAX_VALUE*2L;
+        assertThat(bs.get(topIndex)).isFalse();
+        bs.set(topIndex);
+        assertThat(bs.get(topIndex)).isTrue();
+    }
+
     @Test
     public void testLength() {
         RBitSet bs = redisson.getBitSet("testbitset");
         bs.set(0, 5);
         bs.clear(0, 1);
-        Assert.assertEquals(5, bs.length());
+        assertThat(bs.length()).isEqualTo(5);
 
         bs.clear();
         bs.set(28);
         bs.set(31);
-        Assert.assertEquals(32, bs.length());
+        assertThat(bs.length()).isEqualTo(32);
 
         bs.clear();
         bs.set(3);
         bs.set(7);
-        Assert.assertEquals(8, bs.length());
+        assertThat(bs.length()).isEqualTo(8);
 
         bs.clear();
         bs.set(3);
         bs.set(120);
         bs.set(121);
-        Assert.assertEquals(122, bs.length());
+        assertThat(bs.length()).isEqualTo(122);
 
         bs.clear();
         bs.set(0);
-        Assert.assertEquals(1, bs.length());
+        assertThat(bs.length()).isEqualTo(1);
     }
 
     @Test
@@ -41,7 +50,7 @@ public class RedissonBitSetTest extends BaseTest {
         RBitSet bs = redisson.getBitSet("testbitset");
         bs.set(0, 8);
         bs.clear(0, 3);
-        Assert.assertEquals("{3, 4, 5, 6, 7}", bs.toString());
+        assertThat(bs.toString()).isEqualTo("{3, 4, 5, 6, 7}");
     }
 
     @Test
@@ -50,7 +59,7 @@ public class RedissonBitSetTest extends BaseTest {
         bs.set(3);
         bs.set(5);
         bs.not();
-        Assert.assertEquals("{0, 1, 2, 4, 6, 7}", bs.toString());
+        assertThat(bs.toString()).isEqualTo("{0, 1, 2, 4, 6, 7}");
     }
 
     @Test
@@ -58,7 +67,7 @@ public class RedissonBitSetTest extends BaseTest {
         RBitSet bs = redisson.getBitSet("testbitset");
         bs.set(3);
         bs.set(5);
-        Assert.assertEquals("{3, 5}", bs.toString());
+        assertThat(bs.toString()).isEqualTo("{3, 5}");
 
         BitSet bs1 = new BitSet();
         bs1.set(1);
@@ -66,31 +75,30 @@ public class RedissonBitSetTest extends BaseTest {
         bs.set(bs1);
 
         bs = redisson.getBitSet("testbitset");
-
-        Assert.assertEquals("{1, 10}", bs.toString());
+        assertThat(bs.toString()).isEqualTo("{1, 10}");
     }
 
     @Test
     public void testSetGet() {
         RBitSet bitset = redisson.getBitSet("testbitset");
-        Assert.assertEquals(0, bitset.cardinality());
-        Assert.assertEquals(0, bitset.size());
+        assertThat(bitset.cardinality()).isZero();
+        assertThat(bitset.size()).isZero();
 
         bitset.set(10, true);
         bitset.set(31, true);
-        Assert.assertFalse(bitset.get(0));
-        Assert.assertTrue(bitset.get(31));
-        Assert.assertTrue(bitset.get(10));
-        Assert.assertEquals(2, bitset.cardinality());
-        Assert.assertEquals(32, bitset.size());
+        assertThat(bitset.get(0)).isFalse();
+        assertThat(bitset.get(31)).isTrue();
+        assertThat(bitset.get(10)).isTrue();
+        assertThat(bitset.cardinality()).isEqualTo(2);
+        assertThat(bitset.size()).isEqualTo(32);
     }
 
     @Test
     public void testSetRange() {
         RBitSet bs = redisson.getBitSet("testbitset");
         bs.set(3, 10);
-        Assert.assertEquals(7, bs.cardinality());
-        Assert.assertEquals(16, bs.size());
+        assertThat(bs.cardinality()).isEqualTo(7);
+        assertThat(bs.size()).isEqualTo(16);
     }
 
     @Test
@@ -98,32 +106,32 @@ public class RedissonBitSetTest extends BaseTest {
         RBitSet bs = redisson.getBitSet("testbitset");
         bs.set(3, true);
         bs.set(41, true);
-        Assert.assertEquals(48, bs.size());
+        assertThat(bs.size()).isEqualTo(48);
 
         BitSet bitset = bs.asBitSet();
-        Assert.assertTrue(bitset.get(3));
-        Assert.assertTrue(bitset.get(41));
-        Assert.assertEquals(2, bitset.cardinality());
+        assertThat(bitset.get(3)).isTrue();
+        assertThat(bitset.get(41)).isTrue();
+        assertThat(bs.cardinality()).isEqualTo(2);
     }
 
     @Test
     public void testAnd() {
         RBitSet bs1 = redisson.getBitSet("testbitset1");
         bs1.set(3, 5);
-        Assert.assertEquals(2, bs1.cardinality());
-        Assert.assertEquals(8, bs1.size());
+        assertThat(bs1.cardinality()).isEqualTo(2);
+        assertThat(bs1.size()).isEqualTo(8);
 
         RBitSet bs2 = redisson.getBitSet("testbitset2");
         bs2.set(4);
         bs2.set(10);
         bs1.and(bs2.getName());
-        Assert.assertFalse(bs1.get(3));
-        Assert.assertTrue(bs1.get(4));
-        Assert.assertFalse(bs1.get(5));
-        Assert.assertTrue(bs2.get(10));
+        assertThat(bs1.get(3)).isFalse();
+        assertThat(bs1.get(4)).isTrue();
+        assertThat(bs1.get(5)).isFalse();
+        assertThat(bs2.get(10)).isTrue();
 
-        Assert.assertEquals(1, bs1.cardinality());
-        Assert.assertEquals(16, bs1.size());
+        assertThat(bs1.cardinality()).isEqualTo(1);
+        assertThat(bs1.size()).isEqualTo(16);
     }