capture more failures, leave GCS2 broken

Author: richardstartin

fastfilter/src/main/java/org/fastfilter/bloom/count/SuccinctCountingBlockedBloomRanked.java

@@ -89,7 +89,7 @@ public void add(long key) {
         if (a2 != a1) {
             increment(start, a2);
         }
-        int second = start + 1 + (int) (hash >>> 60);
+        int second = start + (int) (hash >>> 60);
         int a3 = (int) ((hash >> 12) & 63);
         int a4 = (int) ((hash >> 18) & 63);
         increment(second, a3);
@@ -114,7 +114,7 @@ public void remove(long key) {
         if (a2 != a1) {
             decrement(start, a2);
         }
-        int second = start + 1 + (int) (hash >>> 60);
+        int second = start + (int) (hash >>> 60);
         int a3 = (int) ((hash >> 12) & 63);
         int a4 = (int) ((hash >> 18) & 63);
         decrement(second, a3);
@@ -144,7 +144,7 @@ public boolean mayContain(long key) {
         int start = Hash.reduce((int) hash, buckets);
         hash = hash ^ Long.rotateLeft(hash, 32);
         long a = data[start];
-        long b = data[start + 1 + (int) (hash >>> 60)];
+        long b = data[start + (int) (hash >>> 60)];
         long m1 = (1L << hash) | (1L << (hash >> 6));
         long m2 = (1L << (hash >> 12)) | (1L << (hash >> 18));
         return ((m1 & a) == m1) && ((m2 & b) == m2);

fastfilter/src/main/java/org/fastfilter/cuckoo/Cuckoo16.java

@@ -39,7 +39,7 @@ public static Cuckoo16 construct(long[] keys) {
 
     public Cuckoo16(int capacity) {
         // bucketCount needs to be even for bucket2 to work
-        bucketCount = (int) Math.ceil((double) capacity / ENTRIES_PER_BUCKET) / 2 * 2;
+        bucketCount = Math.max(1, (int) Math.ceil((double) capacity / ENTRIES_PER_BUCKET) / 2 * 2);
         this.data = new long[bucketCount];
         this.seed = Hash.randomSeed();
     }

fastfilter/src/main/java/org/fastfilter/cuckoo/Cuckoo8.java

@@ -39,7 +39,7 @@ public static Cuckoo8 construct(long[] keys) {
 
     public Cuckoo8(int capacity) {
         // bucketCount needs to be even for bucket2 to work
-        bucketCount = (int) Math.ceil((double) capacity / ENTRIES_PER_BUCKET) / 2 * 2;
+        bucketCount = Math.max(1, (int) Math.ceil((double) capacity / ENTRIES_PER_BUCKET) / 2 * 2);
         this.data = new int[bucketCount];
         this.seed = Hash.randomSeed();
     }

fastfilter/src/main/java/org/fastfilter/xor/XorSimple.java

@@ -51,7 +51,7 @@ boolean map(long[] keys, long seed, long[] stack) {
             }
         }
         int si = 0;
-        while (si < 2 * keys.length) {
+        while (si < 2 * keys.length && qi > 0) {
             int i = Q[--qi];
             if (C[i] == 1) {
                 long x = H[i];

fastfilter/src/test/java/org/fastfilter/RegressionTests.java

@@ -0,0 +1,47 @@
+package org.fastfilter;
+
+import org.fastfilter.utils.Hash;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import static org.fastfilter.FilterType.*;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(Parameterized.class)
+public class RegressionTests {
+
+
+    @Parameterized.Parameters(name = "{0}/{1}/*")
+    public static Object[][] regressionCases() {
+        return new Object[][] {
+                {BLOCKED_BLOOM, 872153271794238865L, new long[]{1, 2, 3}},
+                {SUCCINCT_COUNTING_BLOCKED_BLOOM_RANKED, -401700599714690558L, new long[]{1, 2, 3}},
+                {SUCCINCT_COUNTING_BLOCKED_BLOOM, 6049486880293779298L, new long[]{1, 2, 3}},
+                // actual this one is impossible to reproduce because of the volatile seed
+                {XOR_SIMPLE, 6831634639270950343L, new long[]{1, 2, 3}},
+                {CUCKOO_8, 6335419348330489927L, new long[]{1, 2, 3}},
+                {CUCKOO_16, -9087718164446355442L, new long[]{1, 2, 3}},
+                {GCS2, -2130647756636796307L, new long[]{1, 2, 3}}
+        };
+    }
+
+    private final FilterType type;
+    private final long seed;
+    private final long[] keys;
+
+    public RegressionTests(FilterType type, long seed, long[] keys) {
+        this.type = type;
+        this.seed = seed;
+        this.keys = keys;
+    }
+
+    @Test
+    public void regressionTest() {
+        Hash.setSeed(seed);
+        Filter filter = type.construct(keys, 8);
+        for (long key : keys) {
+            assertTrue(filter.mayContain(key));
+        }
+    }
+}

fastfilter/src/test/java/org/fastfilter/SimpleFuzzer.java

@@ -21,9 +21,9 @@ public void fuzzTest() {
                     seed = ThreadLocalRandom.current().nextLong();
                     Hash.setSeed(seed);
                     Filter filter = type.construct(keys, 8);
-                    assertTrue(filter.mayContain(1));
-                    assertTrue(filter.mayContain(2));
-                    assertTrue(filter.mayContain(3));
+                    assertTrue(seed + "/" + type, filter.mayContain(1));
+                    assertTrue(seed + "/" + type, filter.mayContain(2));
+                    assertTrue(seed + "/" + type, filter.mayContain(3));
                 }
             } catch (Exception e) {
                 System.out.println(seed + "/" + type);