Merge pull request #2074 from lucasbalieiro/add-fuzz-targets-datatypes

Add fuzz targets for sv2 datatypes

Author: Shourya742

fuzz/Cargo.toml

@@ -31,30 +31,12 @@ path = "fuzz_targets/deserialize_sv2frame.rs"
 test = false
 doc = false
 
-[[bin]]
-name = "deserialize_seq0255"
-path = "fuzz_targets/deserialize_seq0255.rs"
-test = false
-doc = false
-
-[[bin]]
-name = "deserialize_seq064k"
-path = "fuzz_targets/deserialize_seq064k.rs"
-test = false
-doc = false
-
 [[bin]]
 name = "deserialize_stdframe"
 path = "fuzz_targets/deserialize_stdframe.rs"
 test = false
 doc = false
 
-[[bin]]
-name = "deserialize_datatypes"
-path = "fuzz_targets/deserialize_datatypes.rs"
-test = false
-doc = false
-
 [[bin]]
 name = "end_to_end_serialization_for_common_messages"
 path = "fuzz_targets/end_to_end_serialization_for_common_messages.rs"
@@ -78,3 +60,10 @@ name = "end_to_end_serialization_for_template_distribution_messages"
 path = "fuzz_targets/end_to_end_serialization_for_template_distribution_messages.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "end_to_end_serialization_for_datatypes"
+path = "fuzz_targets/end_to_end_serialization_for_datatypes.rs"
+test = false
+doc = false
+

fuzz/fuzz_targets/common.rs

@@ -57,3 +57,112 @@ macro_rules! test_roundtrip {
         };
     }};
 }
+
+#[macro_export]
+macro_rules! test_datatype_roundtrip {
+    // ---- special rule for bool ----
+    // Bool has a non-canonical encoding in the spec: only the lowest bit is meaningful.
+    // Multiple byte values can parse to the same logical bool, so we cannot require a
+    // strict byte-for-byte roundtrip. Instead we check semantic stability and canonicalization.
+    (bool, $data:expr) => {{
+        let mut input = $data.clone();
+
+        // Only run the roundtrip checks if parsing succeeds. Invalid inputs are ignored,
+        // because this macro validates stability of valid encodings, not rejection behavior.
+        if let Ok(parsed) = bool::from_bytes(&mut input) {
+            // Allocate exactly the number of bytes required by the parsed value.
+            // This ensures we test the canonical serialized size.
+            let mut encoded = vec![0u8; parsed.get_size()];
+
+            // A successful parse must always be serializable.
+            parsed
+                .to_bytes(&mut encoded)
+                .expect("Bool encoding failed after a successfull parse");
+
+            // Bytes produced by serialization must always be parseable again.
+            let reparsed = bool::from_bytes(&mut encoded)
+                .expect("The bytes generated from a valid bool should be parseable");
+
+            // Logical value must be preserved by parse → serialize → parse.
+            assert_eq!(parsed, reparsed, "Bool roundtrip is not stable");
+
+            // Because only the lowest bit is significant, we compare the semantic bit,
+            // not the full original byte. This verifies canonical encoding.
+            assert_eq!(input[0] & 1, encoded[0], "Bool serialization is not stable");
+        }
+    }};
+
+    // ---- special rule for f32 ----
+    // Floats require bit-level comparison IEEE-754.
+    (f32, $data:expr) => {{
+        let mut input = $data.clone();
+
+        // Only validate successful parses; invalid encodings are outside this macro’s scope.
+        if let Ok(parsed) = f32::from_bytes(&mut input) {
+            // Allocate the exact canonical size of the float representation.
+            let mut encoded = vec![0u8; parsed.get_size()];
+
+            // A successfully parsed float must serialize without failure.
+            parsed
+                .to_bytes(&mut encoded)
+                .expect("Encoding failed after a successful parse");
+
+            // Serialized bytes must be parseable back into a float.
+            let reparsed = f32::from_bytes(&mut encoded)
+                .expect("The bytes generated from a valid datatype should be parseable");
+
+            // Compare raw bits to enforce strict roundtrip stability, including NaN payloads.
+            assert_eq!(
+                parsed.to_bits(),
+                reparsed.to_bits(),
+                "Float roundtrip is not bit-stable"
+            );
+
+            // Ensure serialization is canonical: re-encoding must match the consumed input.
+            assert_eq!(
+                encoded,
+                input[..encoded.get_size()],
+                "Serialization is not stable"
+            );
+        }
+    }};
+
+    // ---- generic rule ----
+    ($datatype:ty, $data:expr) => {{
+        let mut input = $data.clone();
+
+        // Only test successful parses; this macro checks roundtrip invariants.
+        if let Ok(parsed) = <$datatype>::from_bytes(&mut input) {
+            // Allocate exactly the canonical serialized size.
+            let mut encoded = vec![0u8; parsed.get_size()];
+
+            // A parsed value must always serialize successfully.
+            parsed.clone().to_bytes(&mut encoded).expect(concat!(
+                stringify!($datatype),
+                ": Encoding failed after a successful parse"
+            ));
+
+            // Serialized bytes must be parseable again into the same datatype.
+            let reparsed = <$datatype>::from_bytes(&mut encoded).expect(concat!(
+                stringify!($datatype),
+                ": The bytes generated from a valid datatype should be parseable"
+            ));
+
+            // Semantic equality after roundtrip is required.
+            assert_eq!(
+                parsed,
+                reparsed,
+                "{}: The roundtrip should produce the same message",
+                stringify!($datatype)
+            );
+
+            // reserialization must match the consumed input bytes.
+            assert_eq!(
+                encoded,
+                input[..encoded.get_size()],
+                "{}: Serialization is not stable",
+                stringify!($datatype)
+            );
+        }
+    }};
+}