Slightly nicer fuzzer assertions

Signed-off-by: Robert Kruszewski <[email protected]>

Author: robert3005

fuzz/fuzz_targets/array_ops.rs

@@ -8,7 +8,9 @@ use std::backtrace::Backtrace;
 
 use libfuzzer_sys::{Corpus, fuzz_target};
 use vortex_array::arrays::ConstantArray;
-use vortex_array::compute::{cast, compare, fill_null, filter, mask, min_max, sum, take};
+use vortex_array::compute::{
+    MinMaxResult, cast, compare, fill_null, filter, mask, min_max, sum, take,
+};
 use vortex_array::search_sorted::{SearchResult, SearchSorted, SearchSortedSide};
 use vortex_array::{Array, ArrayRef, IntoArray};
 use vortex_btrblocks::BtrBlocksCompressor;
@@ -88,7 +90,7 @@ fuzz_target!(|fuzz_action: FuzzArrayAction| -> Corpus {
             }
             Action::Sum => {
                 let sum_result = sum(&current_array).vortex_unwrap();
-                assert_scalar_eq(&expected.scalar(), &sum_result);
+                assert_scalar_eq(&expected.scalar(), &sum_result, i).unwrap();
             }
             Action::MinMax => {
                 let min_max_result = min_max(&current_array).vortex_unwrap();
@@ -106,7 +108,7 @@ fuzz_target!(|fuzz_action: FuzzArrayAction| -> Corpus {
                 let expected_scalars = expected.scalar_vec();
                 for (j, &idx) in indices.iter().enumerate() {
                     let scalar = current_array.scalar_at(idx);
-                    assert_scalar_eq(&expected_scalars[j], &scalar);
+                    assert_scalar_eq(&expected_scalars[j], &scalar, i).unwrap();
                 }
             }
         }
@@ -137,8 +139,16 @@ fn assert_search_sorted(
     }
 }
 
-// TODO(ngates): this is horrific... we should have an array_equals compute function?
 fn assert_array_eq(lhs: &ArrayRef, rhs: &ArrayRef, step: usize) -> VortexFuzzResult<()> {
+    if lhs.dtype() != rhs.dtype() {
+        return Err(VortexFuzzError::DTypeMismatch(
+            lhs.clone(),
+            rhs.clone(),
+            step,
+            Backtrace::capture(),
+        ));
+    }
+
     if lhs.len() != rhs.len() {
         return Err(VortexFuzzError::LengthMismatch(
             lhs.len(),
@@ -168,22 +178,30 @@ fn assert_array_eq(lhs: &ArrayRef, rhs: &ArrayRef, step: usize) -> VortexFuzzRes
     Ok(())
 }
 
-fn assert_scalar_eq(lhs: &Scalar, rhs: &Scalar) {
-    // Use catch_unwind to handle panics in scalar comparison (e.g., decimal conversion issues)
-    assert_eq!(
-        lhs, rhs,
-        "Scalar mismatch: expected {:?}, got {:?}",
-        lhs, rhs
-    );
+fn assert_scalar_eq(lhs: &Scalar, rhs: &Scalar, step: usize) -> VortexFuzzResult<()> {
+    if lhs != rhs {
+        return Err(VortexFuzzError::ScalarMismatch(
+            lhs.clone(),
+            rhs.clone(),
+            step,
+            Backtrace::capture(),
+        ));
+    }
+    Ok(())
 }
 
 fn assert_min_max_eq(
-    lhs: &Option<vortex_array::compute::MinMaxResult>,
-    rhs: &Option<vortex_array::compute::MinMaxResult>,
-    _step: usize,
+    lhs: &Option<MinMaxResult>,
+    rhs: &Option<MinMaxResult>,
+    step: usize,
 ) -> VortexFuzzResult<()> {
     if lhs != rhs {
-        vortex_panic!("MinMax mismatch: expected {:?}, got {:?}", lhs, rhs);
+        return Err(VortexFuzzError::MinMaxMismatch(
+            lhs.clone(),
+            rhs.clone(),
+            step,
+            Backtrace::capture(),
+        ));
     }
     Ok(())
 }

fuzz/src/error.rs

@@ -6,13 +6,16 @@ use std::error::Error;
 use std::fmt;
 use std::fmt::{Debug, Display, Formatter};
 
-use vortex_array::ArrayRef;
+use vortex_array::compute::MinMaxResult;
 use vortex_array::search_sorted::{SearchResult, SearchSortedSide};
+use vortex_array::{Array, ArrayRef};
 use vortex_error::VortexError;
 use vortex_scalar::Scalar;
 
 #[non_exhaustive]
 pub enum VortexFuzzError {
+    ScalarMismatch(Scalar, Scalar, usize, Backtrace),
+
     SearchSortedError(
         Scalar,
         SearchResult,
@@ -23,8 +26,12 @@ pub enum VortexFuzzError {
         Backtrace,
     ),
 
+    MinMaxMismatch(Option<MinMaxResult>, Option<MinMaxResult>, usize, Backtrace),
+
     ArrayNotEqual(Scalar, Scalar, usize, ArrayRef, ArrayRef, usize, Backtrace),
 
+    DTypeMismatch(ArrayRef, ArrayRef, usize, Backtrace),
+
     LengthMismatch(usize, usize, ArrayRef, ArrayRef, usize, Backtrace),
 
     VortexError(VortexError, Backtrace),
@@ -39,6 +46,12 @@ impl Debug for VortexFuzzError {
 impl Display for VortexFuzzError {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
+            VortexFuzzError::ScalarMismatch(lhs, rhs, step, backtrace) => {
+                write!(
+                    f,
+                    "Scalar mismatch: expected {lhs}, got {rhs} in step {step}\nBacktrace:\n{backtrace}"
+                )
+            }
             VortexFuzzError::SearchSortedError(
                 a,
                 expected,
@@ -54,6 +67,12 @@ impl Display for VortexFuzzError {
                     array.display_tree(),
                 )
             }
+            VortexFuzzError::MinMaxMismatch(lhs, rhs, step, backtrace) => {
+                write!(
+                    f,
+                    "MinMax mismatch: expected {lhs:?} got {rhs:?} in step {step}\nBacktrace:\n{backtrace}"
+                )
+            }
             VortexFuzzError::ArrayNotEqual(expected, actual, idx, lhs, rhs, step, backtrace) => {
                 write!(
                     f,
@@ -62,6 +81,14 @@ impl Display for VortexFuzzError {
                     rhs.display_tree(),
                 )
             }
+            VortexFuzzError::DTypeMismatch(lhs, rhs, step, backtrace) => {
+                write!(
+                    f,
+                    "DType mismatch: expected {}, got {} in step {step}\nBacktrace:\n{backtrace}",
+                    lhs.dtype(),
+                    rhs.dtype()
+                )
+            }
             VortexFuzzError::LengthMismatch(lhs_len, rhs_len, lhs, rhs, step, backtrace) => {
                 write!(
                     f,
@@ -80,10 +107,13 @@ impl Display for VortexFuzzError {
 impl Error for VortexFuzzError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         match self {
-            VortexFuzzError::SearchSortedError(..) => None,
-            VortexFuzzError::ArrayNotEqual(..) => None,
-            VortexFuzzError::LengthMismatch(..) => None,
             VortexFuzzError::VortexError(err, ..) => Some(err),
+            VortexFuzzError::SearchSortedError(..)
+            | VortexFuzzError::ArrayNotEqual(..)
+            | VortexFuzzError::LengthMismatch(..)
+            | VortexFuzzError::ScalarMismatch(..)
+            | VortexFuzzError::MinMaxMismatch(..)
+            | VortexFuzzError::DTypeMismatch(..) => None,
         }
     }
 }