From 8e6778c35624cec90e0809d151d8fbcbf1940a42 Mon Sep 17 00:00:00 2001 From: Justin Traglia Date: Mon, 19 May 2025 17:23:06 -0500 Subject: [PATCH] Bind inputs in ssz_generic reftests --- .../ssz_generic_cases/ssz_basic_vector.py | 20 ++++++++++++----- .../runners/ssz_generic_cases/ssz_bitlist.py | 6 +++-- .../ssz_generic_cases/ssz_bitvector.py | 4 ++-- .../ssz_generic_cases/ssz_container.py | 22 +++++++++++-------- .../runners/ssz_generic_cases/ssz_uints.py | 16 +++++++++----- 5 files changed, 44 insertions(+), 24 deletions(-) diff --git a/tests/generators/runners/ssz_generic_cases/ssz_basic_vector.py b/tests/generators/runners/ssz_generic_cases/ssz_basic_vector.py index 1a4ca3836b..bc34471e57 100644 --- a/tests/generators/runners/ssz_generic_cases/ssz_basic_vector.py +++ b/tests/generators/runners/ssz_generic_cases/ssz_basic_vector.py @@ -51,7 +51,9 @@ def valid_cases(): for length in [1, 2, 3, 4, 5, 8, 16, 31, 512, 513]: for mode in random_modes: yield f"vec_{name}_{length}_{mode.to_name()}", valid_test_case( - lambda: basic_vector_case_fn(rng, mode, typ, length) + lambda rng=rng, mode=mode, typ=typ, length=length: basic_vector_case_fn( + rng, mode, typ, length + ) ) @@ -75,15 +77,23 @@ def invalid_cases(): ) else: yield f"vec_{name}_{length}_{mode.to_name()}_one_less", invalid_test_case( - lambda: serialize(basic_vector_case_fn(rng, mode, typ, length - 1)) + lambda rng=rng, mode=mode, typ=typ, length=length: serialize( + basic_vector_case_fn(rng, mode, typ, length - 1) + ) ) yield f"vec_{name}_{length}_{mode.to_name()}_one_more", invalid_test_case( - lambda: serialize(basic_vector_case_fn(rng, mode, typ, length + 1)) + lambda rng=rng, mode=mode, typ=typ, length=length: serialize( + basic_vector_case_fn(rng, mode, typ, length + 1) + ) ) yield f"vec_{name}_{length}_{mode.to_name()}_one_byte_less", invalid_test_case( - lambda: serialize(basic_vector_case_fn(rng, mode, typ, length))[:-1] + lambda rng=rng, mode=mode, typ=typ, length=length: serialize( + basic_vector_case_fn(rng, mode, typ, length) + )[:-1] ) yield f"vec_{name}_{length}_{mode.to_name()}_one_byte_more", invalid_test_case( - lambda: serialize(basic_vector_case_fn(rng, mode, typ, length)) + lambda rng=rng, mode=mode, typ=typ, length=length: serialize( + basic_vector_case_fn(rng, mode, typ, length) + ) + serialize(basic_vector_case_fn(rng, mode, uint8, 1)) ) diff --git a/tests/generators/runners/ssz_generic_cases/ssz_bitlist.py b/tests/generators/runners/ssz_generic_cases/ssz_bitlist.py index 5641eb5045..4c3c54c5a4 100644 --- a/tests/generators/runners/ssz_generic_cases/ssz_bitlist.py +++ b/tests/generators/runners/ssz_generic_cases/ssz_bitlist.py @@ -30,7 +30,7 @@ def valid_cases(): RandomizationMode.mode_max, ]: yield f"bitlist_{size}_{mode.to_name()}_{variation}", valid_test_case( - lambda: bitlist_case_fn(rng, mode, size) + lambda rng=rng, mode=mode, size=size: bitlist_case_fn(rng, mode, size) ) @@ -53,5 +53,7 @@ def invalid_cases(): (512, 513), ]: yield f"bitlist_{typ_limit}_but_{test_limit}", invalid_test_case( - lambda: serialize(bitlist_case_fn(rng, RandomizationMode.mode_max_count, test_limit)) + lambda rng=rng, test_limit=test_limit: serialize( + bitlist_case_fn(rng, RandomizationMode.mode_max_count, test_limit) + ) ) diff --git a/tests/generators/runners/ssz_generic_cases/ssz_bitvector.py b/tests/generators/runners/ssz_generic_cases/ssz_bitvector.py index 26604b106d..428ad9e814 100644 --- a/tests/generators/runners/ssz_generic_cases/ssz_bitvector.py +++ b/tests/generators/runners/ssz_generic_cases/ssz_bitvector.py @@ -37,7 +37,7 @@ def valid_cases(): RandomizationMode.mode_max, ]: yield f"bitvec_{size}_{mode.to_name()}", valid_test_case( - lambda: bitvector_case_fn(rng, mode, size) + lambda rng=rng, mode=mode, size=size: bitvector_case_fn(rng, mode, size) ) @@ -66,7 +66,7 @@ def invalid_cases(): RandomizationMode.mode_max, ]: yield f"bitvec_{typ_size}_{mode.to_name()}_{test_size}", invalid_test_case( - lambda: serialize( + lambda rng=rng, mode=mode, test_size=test_size, typ_size=typ_size: serialize( bitvector_case_fn(rng, mode, test_size, invalid_making_pos=typ_size) ) ) diff --git a/tests/generators/runners/ssz_generic_cases/ssz_container.py b/tests/generators/runners/ssz_generic_cases/ssz_container.py index ceef60ed78..2083958829 100644 --- a/tests/generators/runners/ssz_generic_cases/ssz_container.py +++ b/tests/generators/runners/ssz_generic_cases/ssz_container.py @@ -81,7 +81,7 @@ def valid_cases(): for name, (typ, offsets) in PRESET_CONTAINERS.items(): for mode in [RandomizationMode.mode_zero, RandomizationMode.mode_max]: yield f"{name}_{mode.to_name()}", valid_test_case( - lambda: container_case_fn(rng, mode, typ) + lambda rng=rng, mode=mode, typ=typ: container_case_fn(rng, mode, typ) ) if len(offsets) == 0: @@ -96,7 +96,9 @@ def valid_cases(): for mode in modes: for variation in range(3): yield f"{name}_{mode.to_name()}_chaos_{variation}", valid_test_case( - lambda: container_case_fn(rng, mode, typ, chaos=True) + lambda rng=rng, mode=mode, typ=typ: container_case_fn( + rng, mode, typ, chaos=True + ) ) # Notes: Below is the second wave of iteration, and only the random mode is selected # for container without offset since ``RandomizationMode.mode_zero`` and ``RandomizationMode.mode_max`` @@ -105,7 +107,7 @@ def valid_cases(): for mode in modes: for variation in range(10): yield f"{name}_{mode.to_name()}_{variation}", valid_test_case( - lambda: container_case_fn(rng, mode, typ) + lambda rng=rng, mode=mode, typ=typ: container_case_fn(rng, mode, typ) ) @@ -125,7 +127,9 @@ def invalid_cases(): for name, (typ, offsets) in PRESET_CONTAINERS.items(): # using mode_max_count, so that the extra byte cannot be picked up as normal list content yield f"{name}_extra_byte", invalid_test_case( - lambda: serialize(container_case_fn(rng, RandomizationMode.mode_max_count, typ)) + lambda rng=rng, typ=typ: serialize( + container_case_fn(rng, RandomizationMode.mode_max_count, typ) + ) + b"\xff" ) @@ -140,14 +144,14 @@ def invalid_cases(): ]: for index, offset_index in enumerate(offsets): yield f"{name}_{mode.to_name()}_offset_{offset_index}_plus_one", invalid_test_case( - lambda: mod_offset( + lambda rng=rng, mode=mode, typ=typ, offset_index=offset_index: mod_offset( b=serialize(container_case_fn(rng, mode, typ)), offset_index=offset_index, change=lambda x: x + 1, ) ) yield f"{name}_{mode.to_name()}_offset_{offset_index}_zeroed", invalid_test_case( - lambda: mod_offset( + lambda rng=rng, mode=mode, typ=typ, offset_index=offset_index: mod_offset( b=serialize(container_case_fn(rng, mode, typ)), offset_index=offset_index, change=lambda x: 0, @@ -155,7 +159,7 @@ def invalid_cases(): ) if index == 0: yield f"{name}_{mode.to_name()}_offset_{offset_index}_minus_one", invalid_test_case( - lambda: mod_offset( + lambda rng=rng, mode=mode, typ=typ, offset_index=offset_index: mod_offset( b=serialize(container_case_fn(rng, mode, typ)), offset_index=offset_index, change=lambda x: x - 1, @@ -165,11 +169,11 @@ def invalid_cases(): serialized = serialize(container_case_fn(rng, mode, typ)) serialized = serialized + serialized[:2] yield f"{name}_{mode.to_name()}_last_offset_{offset_index}_overflow", invalid_test_case( - lambda: serialized + lambda serialized=serialized: serialized ) if mode == RandomizationMode.mode_one_count: serialized = serialize(container_case_fn(rng, mode, typ)) serialized = serialized + serialized[:1] yield f"{name}_{mode.to_name()}_last_offset_{offset_index}_wrong_byte_length", invalid_test_case( - lambda: serialized + lambda serialized=serialized: serialized ) diff --git a/tests/generators/runners/ssz_generic_cases/ssz_uints.py b/tests/generators/runners/ssz_generic_cases/ssz_uints.py index 3875a85a54..8c6cf8e264 100644 --- a/tests/generators/runners/ssz_generic_cases/ssz_uints.py +++ b/tests/generators/runners/ssz_generic_cases/ssz_uints.py @@ -22,15 +22,17 @@ def valid_cases(): mode = RandomizationMode.mode_random byte_len = uint_type.type_byte_length() yield f"uint_{byte_len * 8}_last_byte_empty", valid_test_case( - lambda: uint_type((2 ** ((byte_len - 1) * 8)) - 1) + lambda uint_type=uint_type, byte_len=byte_len: uint_type( + (2 ** ((byte_len - 1) * 8)) - 1 + ) ) for variation in range(5): yield f"uint_{byte_len * 8}_{mode.to_name()}_{variation}", valid_test_case( - lambda: uint_case_fn(rng, mode, uint_type) + lambda rng=rng, mode=mode, uint_type=uint_type: uint_case_fn(rng, mode, uint_type) ) for mode in [RandomizationMode.mode_zero, RandomizationMode.mode_max]: yield f"uint_{byte_len * 8}_{mode.to_name()}", valid_test_case( - lambda: uint_case_fn(rng, mode, uint_type) + lambda rng=rng, mode=mode, uint_type=uint_type: uint_case_fn(rng, mode, uint_type) ) @@ -38,15 +40,17 @@ def invalid_cases(): for uint_type in UINT_TYPES: byte_len = uint_type.type_byte_length() yield f"uint_{byte_len * 8}_one_too_high", invalid_test_case( - lambda: (2 ** (byte_len * 8)).to_bytes(byte_len + 1, "little") + lambda byte_len=byte_len: (2 ** (byte_len * 8)).to_bytes(byte_len + 1, "little") ) for uint_type in [uint8, uint16, uint32, uint64, uint128, uint256]: byte_len = uint_type.type_byte_length() yield f"uint_{byte_len * 8}_one_byte_longer", invalid_test_case( - lambda: (2 ** (byte_len * 8) - 1).to_bytes(byte_len + 1, "little") + lambda byte_len=byte_len: (2 ** (byte_len * 8) - 1).to_bytes(byte_len + 1, "little") ) for uint_type in [uint8, uint16, uint32, uint64, uint128, uint256]: byte_len = uint_type.type_byte_length() yield f"uint_{byte_len * 8}_one_byte_shorter", invalid_test_case( - lambda: (2 ** ((byte_len - 1) * 8) - 1).to_bytes(byte_len - 1, "little") + lambda byte_len=byte_len: (2 ** ((byte_len - 1) * 8) - 1).to_bytes( + byte_len - 1, "little" + ) )