From 827ff953bcc5de14263a251ea28249fc54c2f57c Mon Sep 17 00:00:00 2001 From: Mac L Date: Fri, 13 Feb 2026 21:10:34 +1100 Subject: [PATCH] Enable all ssz tests --- testing/ef_tests/check_all_files_accessed.py | 6 -- testing/ef_tests/src/cases/ssz_generic.rs | 71 +++++++++++++++++++- testing/ef_tests/src/handler.rs | 2 + testing/ef_tests/tests/tests.rs | 1 + 4 files changed, 71 insertions(+), 9 deletions(-) diff --git a/testing/ef_tests/check_all_files_accessed.py b/testing/ef_tests/check_all_files_accessed.py index 4b016dc0b0..fd015414cf 100755 --- a/testing/ef_tests/check_all_files_accessed.py +++ b/testing/ef_tests/check_all_files_accessed.py @@ -66,12 +66,6 @@ excluded_paths = [ "tests/.*/gloas/ssz_static/ExecutionPayloadHeader/.*", # ForkChoiceNode is internal to fork choice and probably doesn't need SSZ tests. "tests/.*/gloas/ssz_static/ForkChoiceNode/.*", - # EIP-7916 is still in draft and hasn't been implemented yet https://eips.ethereum.org/EIPS/eip-7916 - "tests/general/phase0/ssz_generic/progressive_bitlist", - "tests/general/phase0/ssz_generic/containers/.*/ProgressiveBitsStruct.*", - "tests/general/phase0/ssz_generic/containers/.*/ProgressiveTestStruct.*", - "tests/general/phase0/ssz_generic/progressive_containers/.*", - "tests/general/phase0/ssz_generic/compatible_unions/.*", # Ignore full epoch tests for now (just test the sub-transitions). "tests/.*/.*/epoch_processing/.*/pre_epoch.ssz_snappy", "tests/.*/.*/epoch_processing/.*/post_epoch.ssz_snappy", diff --git a/testing/ef_tests/src/cases/ssz_generic.rs b/testing/ef_tests/src/cases/ssz_generic.rs index e394a69437..429be3a9ae 100644 --- a/testing/ef_tests/src/cases/ssz_generic.rs +++ b/testing/ef_tests/src/cases/ssz_generic.rs @@ -7,6 +7,7 @@ use crate::decode::{context_yaml_decode_file, log_file_access, snappy_decode_fil use context_deserialize::{ContextDeserialize, context_deserialize}; use milhouse::{List, ProgressiveList, Vector}; use serde::{Deserialize, Deserializer, de::Error as SerdeError}; +use serde_json::Value as JsonValue; use ssz::ProgressiveBitList; use ssz_derive::{Decode, Encode}; use ssz_types::{BitList, BitVector, FixedVector, VariableList}; @@ -15,6 +16,43 @@ use tree_hash_derive::TreeHash; use typenum::*; use types::ForkName; +/// Helper struct for deserializing compatible unions from `{selector, data}` YAML format. +#[derive(Deserialize)] +struct CompatibleUnionYaml { + selector: u8, + data: JsonValue, +} + +/// Implements `Deserialize` for compatible union types to handle the EF test YAML format. +/// +/// Deserialize into `CompatibleUnionYaml` which captures `selector` (`u8`) and +/// `data` (`JsonValue`). +/// Match on the selector to determine which variant to construct. +/// Deserialize the `data` field into the appropriate inner type. +macro_rules! impl_compatible_union_deserialize { + ($type:ty, { $($selector:literal => $variant:ident($inner:ty)),+ $(,)? }) => { + impl<'de> Deserialize<'de> for $type { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let yaml = CompatibleUnionYaml::deserialize(deserializer)?; + match yaml.selector { + $( + $selector => { + let inner: $inner = serde_json::from_value(yaml.data).map_err(D::Error::custom)?; + Ok(<$type>::$variant(inner)) + } + )+ + s => Err(D::Error::custom(format!( + "unknown selector {s} for {}", stringify!($type) + ))), + } + } + } + }; +} + type U1280 = op!(U128 * U10); type U1281 = op!(U1280 + U1); @@ -252,6 +290,17 @@ impl Case for SszGeneric { [type_name => test_container] )?; } + "compatible_unions" => { + let type_name = parts[0]; + + type_dispatch!( + ssz_generic_test, + (&self.path, fork_name), + _, + <>, + [type_name => test_container] + )?; + } _ => panic!("unsupported handler: {}", self.handler_name), } Ok(()) @@ -425,7 +474,7 @@ struct ProgressiveComplexTestStruct { H: ProgressiveList, } -#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash, Deserialize)] +#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash)] #[ssz(enum_behaviour = "compatible_union")] #[tree_hash(enum_behaviour = "compatible_union")] #[context_deserialize(ForkName)] @@ -434,7 +483,11 @@ enum CompatibleUnionA { ProgressiveSingleFieldContainerTestStruct(ProgressiveSingleFieldContainerTestStruct), } -#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash, Deserialize)] +impl_compatible_union_deserialize!(CompatibleUnionA, { + 1 => ProgressiveSingleFieldContainerTestStruct(ProgressiveSingleFieldContainerTestStruct), +}); + +#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash)] #[ssz(enum_behaviour = "compatible_union")] #[tree_hash(enum_behaviour = "compatible_union")] #[context_deserialize(ForkName)] @@ -445,7 +498,12 @@ enum CompatibleUnionBC { ProgressiveVarTestStruct(ProgressiveVarTestStruct), } -#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash, Deserialize)] +impl_compatible_union_deserialize!(CompatibleUnionBC, { + 2 => ProgressiveSingleListContainerTestStruct(ProgressiveSingleListContainerTestStruct), + 3 => ProgressiveVarTestStruct(ProgressiveVarTestStruct), +}); + +#[derive(Debug, Clone, PartialEq, Decode, Encode, TreeHash)] #[ssz(enum_behaviour = "compatible_union")] #[tree_hash(enum_behaviour = "compatible_union")] #[context_deserialize(ForkName)] @@ -460,6 +518,13 @@ enum CompatibleUnionABCA { A2(ProgressiveSingleFieldContainerTestStruct), } +impl_compatible_union_deserialize!(CompatibleUnionABCA, { + 1 => A1(ProgressiveSingleFieldContainerTestStruct), + 2 => B1(ProgressiveSingleListContainerTestStruct), + 3 => C1(ProgressiveVarTestStruct), + 4 => A2(ProgressiveSingleFieldContainerTestStruct), +}); + fn byte_list_from_hex_str<'de, D, N: Unsigned>( deserializer: D, ) -> Result, D::Error> diff --git a/testing/ef_tests/src/handler.rs b/testing/ef_tests/src/handler.rs index 80dba59c29..5747800e73 100644 --- a/testing/ef_tests/src/handler.rs +++ b/testing/ef_tests/src/handler.rs @@ -1198,3 +1198,5 @@ pub struct Containers; type_name!(Containers, "containers"); pub struct ProgressiveContainers; type_name!(ProgressiveContainers, "progressive_containers"); +pub struct CompatibleUnions; +type_name!(CompatibleUnions, "compatible_unions"); diff --git a/testing/ef_tests/tests/tests.rs b/testing/ef_tests/tests/tests.rs index 934ae6b35e..68ab4f1eac 100644 --- a/testing/ef_tests/tests/tests.rs +++ b/testing/ef_tests/tests/tests.rs @@ -856,6 +856,7 @@ fn ssz_generic_progressive() { SszGenericHandler::::default().run(); SszGenericHandler::::default().run(); SszGenericHandler::::default().run(); + SszGenericHandler::::default().run(); } #[test]