fixup

Signed-off-by: Joe Isaacs <joe.isaacs@live.co.uk>

Author: joseph-isaacs

encodings/fsst/src/compute/like.rs

@@ -351,124 +351,4 @@ mod tests {
         assert_arrays_eq!(direct.unwrap(), BoolArray::from_iter([true, false, true]));
         Ok(())
     }
-
-    // -----------------------------------------------------------------------
-    // Fuzz tests: compare FSST kernel against naive string matching
-    // -----------------------------------------------------------------------
-
-    fn random_string(rng: &mut StdRng, max_len: usize) -> String {
-        let len = rng.random_range(0..=max_len);
-        // Use a small alphabet to increase substring hit rate.
-        (0..len)
-            .map(|_| (b'a' + rng.random_range(0..6u8)) as char)
-            .collect()
-    }
-
-    fn fuzz_contains(seed: u64, needle_len: usize, n_strings: usize) -> VortexResult<()> {
-        let mut rng = StdRng::seed_from_u64(seed);
-
-        let needle: String = (0..needle_len)
-            .map(|_| (b'a' + rng.random_range(0..6u8)) as char)
-            .collect();
-
-        let owned: Vec<String> = (0..n_strings)
-            .map(|_| random_string(&mut rng, 80))
-            .collect();
-        let strings: Vec<Option<&str>> = owned.iter().map(|s| Some(s.as_str())).collect();
-
-        let expected: Vec<bool> = owned.iter().map(|s| s.contains(&needle)).collect();
-
-        let fsst = make_fsst(&strings, Nullability::NonNullable);
-        let pattern = format!("%{needle}%");
-        let result = run_like(fsst, &pattern, LikeOptions::default())?;
-
-        let got: Vec<bool> = (0..n_strings)
-            .map(|i| result.to_bit_buffer().value(i))
-            .collect();
-
-        for (i, (e, g)) in expected.iter().zip(got.iter()).enumerate() {
-            assert_eq!(
-                e, g,
-                "mismatch at index {i}: string={:?}, needle={needle:?}, expected={e}, got={g}",
-                &owned[i],
-            );
-        }
-        Ok(())
-    }
-
-    fn fuzz_prefix(seed: u64, prefix_len: usize, n_strings: usize) -> VortexResult<()> {
-        let mut rng = StdRng::seed_from_u64(seed);
-
-        let prefix: String = (0..prefix_len)
-            .map(|_| (b'a' + rng.random_range(0..6u8)) as char)
-            .collect();
-
-        let owned: Vec<String> = (0..n_strings)
-            .map(|_| random_string(&mut rng, 80))
-            .collect();
-        let strings: Vec<Option<&str>> = owned.iter().map(|s| Some(s.as_str())).collect();
-
-        let expected: Vec<bool> = owned.iter().map(|s| s.starts_with(&prefix)).collect();
-
-        let fsst = make_fsst(&strings, Nullability::NonNullable);
-        let pattern = format!("{prefix}%");
-        let result = run_like(fsst, &pattern, LikeOptions::default())?;
-
-        let got: Vec<bool> = (0..n_strings)
-            .map(|i| result.to_bit_buffer().value(i))
-            .collect();
-
-        for (i, (e, g)) in expected.iter().zip(got.iter()).enumerate() {
-            assert_eq!(
-                e, g,
-                "mismatch at index {i}: string={:?}, prefix={prefix:?}, expected={e}, got={g}",
-                &owned[i],
-            );
-        }
-        Ok(())
-    }
-
-    /// Fuzz contains with short needles (1-7 chars) -> BranchlessShiftDfa
-    #[test]
-    fn fuzz_contains_short_needle() -> VortexResult<()> {
-        for seed in 0..50 {
-            for needle_len in 1..=7 {
-                fuzz_contains(seed, needle_len, 200)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Fuzz contains with medium needles (8-14 chars) -> FlatBranchlessDfa
-    #[test]
-    fn fuzz_contains_medium_needle() -> VortexResult<()> {
-        for seed in 0..50 {
-            for needle_len in [8, 10, 14] {
-                fuzz_contains(seed, needle_len, 200)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Fuzz contains with long needles (>14 chars) -> FsstContainsDfa
-    #[test]
-    fn fuzz_contains_long_needle() -> VortexResult<()> {
-        for seed in 0..30 {
-            for needle_len in [15, 20, 30] {
-                fuzz_contains(seed, needle_len, 200)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Fuzz prefix matching
-    #[test]
-    fn fuzz_prefix_matching() -> VortexResult<()> {
-        for seed in 0..50 {
-            for prefix_len in [1, 3, 5, 10, 13, 20, 40] {
-                fuzz_prefix(seed, prefix_len, 200)?;
-            }
-        }
-        Ok(())
-    }
 }

encodings/fsst/src/dfa/tests.rs

@@ -237,7 +237,9 @@ fn run_like(array: FSSTArray, pattern: &str) -> VortexResult<BoolArray> {
 #[case(&[""], "aaaa%", &[false])]
 #[case(&[""], "%aaaa%", &[false])]
 #[case(&[""], "%", &[true])]
+#[case(&[""], "%%", &[true])]
 #[case(&["", "", ""], "%", &[true, true, true])]
+#[case(&["", "abc", ""], "%%", &[true, true, true])]
 // Single-char patterns
 #[case(&["a", "b", ""], "a%", &[true, false, false])]
 #[case(&["a", "b", ""], "%a%", &[true, false, false])]