bit set and string compatibility (#547)

Author: inponomarev

src/main/java/com/github/fppt/jedismock/datastructures/RMBitMap.java

@@ -5,7 +5,6 @@
 import java.util.BitSet;
 
 public class RMBitMap extends StringCompatible {
-    private static final long serialVersionUID = 1L;
     private final BitSet bitSet;
     private int size;
 
@@ -16,7 +15,11 @@ public RMBitMap() {
 
     public RMBitMap(byte[] data) {
         this.size = data.length;
-        this.bitSet = BitSet.valueOf(data);
+        byte[] reversed = new byte[data.length];
+        for (int i = 0; i < data.length; i++) {
+            reversed[i] = reverseBits(data[i]);
+        }
+        this.bitSet = BitSet.valueOf(reversed);
     }
 
     public RMBitMap(int size, BitSet bitSet) {
@@ -46,4 +49,34 @@ public boolean getBit(int pos) {
     public void raiseTypeCastException() {
         throw new WrongValueTypeException("WRONGTYPE RMBitMap value is used in the wrong place");
     }
+
+    @Override
+    public final Slice getAsSlice() {
+        return Slice.create(toByteArray());
+    }
+
+    /**
+     * Produce little-endian bitewise representation of the bit set.
+     */
+    private byte[] toByteArray() {
+        long[] longs = bitSet.toLongArray();
+        int nBytes = (bitSet.length() + 7) / 8;
+        byte[] bytes = new byte[nBytes];
+        int byteIndex = 0;
+        for (long value : longs) {
+            for (int i = 0; i < 8 && byteIndex < nBytes; i++) {
+                bytes[byteIndex++] = reverseBits((byte) (value & 0xFF));
+                value >>>= 8;
+            }
+        }
+        return bytes;
+    }
+
+    private static byte reverseBits(byte b) {
+        int buf = b & 0xFF;
+        buf = ((buf & 0xF0) >>> 4) | ((buf & 0x0F) << 4);
+        buf = ((buf & 0xCC) >>> 2) | ((buf & 0x33) << 2);
+        buf = ((buf & 0xAA) >>> 1) | ((buf & 0x55) << 1);
+        return (byte) buf;
+    }
 }

src/main/java/com/github/fppt/jedismock/datastructures/RMHyperLogLog.java

@@ -2,11 +2,15 @@
 
 import com.github.fppt.jedismock.exception.WrongValueTypeException;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
 
-public class RMHyperLogLog extends StringCompatible {
+public class RMHyperLogLog extends StringCompatible implements Serializable {
     private static final long serialVersionUID = 1L;
     private transient HashSet<Slice> storedData;
 
@@ -60,4 +64,16 @@ private void readObject(java.io.ObjectInputStream s)
             storedData.add(Slice.create(buf));
         }
     }
+
+    @Override
+    public final Slice getAsSlice() {
+        ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+        try {
+            ObjectOutputStream outputStream = new ObjectOutputStream(byteOutputStream);
+            outputStream.writeObject(this);
+            return Slice.create(byteOutputStream.toByteArray());
+        } catch (IOException exp) {
+            throw new IllegalStateException(exp);
+        }
+    }
 }

src/main/java/com/github/fppt/jedismock/datastructures/StringCompatible.java

@@ -1,26 +1,11 @@
 package com.github.fppt.jedismock.datastructures;
 
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
 
-public abstract class StringCompatible implements RMDataStructure, Serializable {
+public abstract class StringCompatible implements RMDataStructure {
 
     @Override
     public final String getTypeName() {
         return "string";
     }
 
-    @Override
-    public final Slice getAsSlice() {
-        ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
-        try {
-            ObjectOutputStream outputStream = new ObjectOutputStream(byteOutputStream);
-            outputStream.writeObject(this);
-            return Slice.create(byteOutputStream.toByteArray());
-        } catch (IOException exp) {
-            throw new IllegalStateException(exp);
-        }
-    }
 }

src/main/java/com/github/fppt/jedismock/operations/strings/SetRange.java

@@ -37,7 +37,9 @@ protected Slice response() {
         if (offset + value.length() < oldValue.length()) {
             newValue += oldValue.substring(offset + value.length());
         }
-        base().putValue(key, Slice.create(newValue).extract(), null);
+        if (!oldValue.equals(newValue)) {
+            base().putValue(key, Slice.create(newValue).extract(), null);
+        }
         return Response.integer(newValue.length());
     }
 }

src/test/java/com/github/fppt/jedismock/comparisontests/bitmaps/BitMapsOperationsTest.java

@@ -9,6 +9,8 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -55,6 +57,9 @@ void testValueAftersetbit(Jedis jedis) {
         assertThat(jedis.getbit("foo", 0L)).isTrue();
         jedis.setbit("foo", 1L, true);
         assertThat(jedis.getbit("foo", 0L)).isTrue();
+        jedis.setbit("foo", 0L, false);
+        assertThat(jedis.getbit("foo", 0L)).isFalse();
+
     }
 
     @TestTemplate
@@ -65,4 +70,47 @@ public void testStringAndBitmapGet(Jedis jedis) {
         assertThat(jedis.getbit("something2", 1)).isTrue();
         assertThat(jedis.getbit("something2", 41)).isTrue();
     }
+
+    @TestTemplate
+    public void bitsToString(Jedis jedis) {
+        jedis.setbit("bitmapsarestrings", 2, true);
+        jedis.setbit("bitmapsarestrings", 3, true);
+        jedis.setbit("bitmapsarestrings", 5, true);
+        jedis.setbit("bitmapsarestrings", 10, true);
+        jedis.setbit("bitmapsarestrings", 11, true);
+        jedis.setbit("bitmapsarestrings", 14, true);
+        String result = jedis.get("bitmapsarestrings");
+        assertThat(result).isEqualTo("42");
+    }
+
+    @TestTemplate
+    public void stringToBits(Jedis jedis) {
+        jedis.set("foo", "e");
+        assertThat(jedis.getbit("foo", 0)).isFalse();
+        assertThat(jedis.getbit("foo", 1)).isTrue();
+    }
+
+    @TestTemplate
+    public void testLongSetBit(Jedis jedis) {
+        int len = 256 * 8;
+        jedis.del("mykey");
+        byte[] expectedBytes = new byte[256];
+        Random random = new Random(42);
+        for (int i = 0; i < 2000; i++) {
+            int bitPosition = random.nextInt(len);
+            boolean bitValue = random.nextBoolean();
+            int byteIndex = bitPosition / 8;
+            int bitIndex = 7 - (bitPosition % 8);
+            if (bitValue) {
+                expectedBytes[byteIndex] |= (byte) (1 << bitIndex);
+            } else {
+                expectedBytes[byteIndex] &= (byte) ~(1 << bitIndex);
+            }
+            jedis.setbit("mykey", bitPosition, bitValue);
+            byte[] redisBytes = jedis.get("mykey".getBytes());
+            byte[] expectedTruncated = new byte[redisBytes.length];
+            System.arraycopy(expectedBytes, 0, expectedTruncated, 0, redisBytes.length);
+            assertThat(redisBytes).isEqualTo(expectedTruncated);
+        }
+    }
 }

src/test/java/com/github/fppt/jedismock/comparisontests/strings/TestSetRange.java

@@ -46,4 +46,23 @@ public void setRangeZeroPadding(Jedis jedis) {
         assertThat(l).isEqualTo(11);
         assertThat(jedis.get("key2")).isEqualTo(new String(new byte[6]) + "Redis");
     }
+
+    @TestTemplate
+    public void setRangeAgainstNonExistent(Jedis jedis) {
+        assertThat(jedis.setrange("mykey", 0, "foo"))
+                .isEqualTo(3);
+        assertThat(jedis.get("mykey")).isEqualTo("foo");
+    }
+
+    @TestTemplate
+    public void setRangeAgainstNonExistentNoOp(Jedis jedis) {
+        assertThat(jedis.setrange("mykey", 0, "")).isEqualTo(0);
+        assertThat(jedis.exists("mykey")).isFalse();
+    }
+
+    @TestTemplate
+    public void setRangeAgainstNonExistentPadding(Jedis jedis) {
+        assertThat(jedis.setrange("mykey", 1, "foo")).isEqualTo(4);
+        assertThat(jedis.get("mykey")).isEqualTo("\000foo");
+    }
 }