feat: filter reference test with specified parameter

LouisTsai-Csie · LouisTsai-Csie · commit 92793f3cb970 · 2025-11-11T10:55:04.000+08:00
diff --git a/packages/testing/src/execution_testing/cli/pytest_commands/plugins/shared/benchmarking.py b/packages/testing/src/execution_testing/cli/pytest_commands/plugins/shared/benchmarking.py
@@ -50,14 +50,30 @@ def pytest_collection_modifyitems(
         # If --fixed-opcode-count is not specified, don't filter anything
         return
 
-    items = [
-        item
-        for item in items
-        if not (
-            item.get_closest_marker("benchmark") is not None
-            and item.get_closest_marker("repricing") is None
-        )
-    ]
+    filtered = []
+    for item in items:
+        if not item.get_closest_marker("benchmark"):
+            continue
+
+        repricing_marker = item.get_closest_marker("repricing")
+        if not repricing_marker:
+            continue
+
+        if not repricing_marker.kwargs:
+            filtered.append(item)
+            continue
+
+        if hasattr(item, "callspec"):
+            if all(
+                item.callspec.params.get(key) == value
+                for key, value in repricing_marker.kwargs.items()
+            ):
+                filtered.append(item)
+        else:
+            if not repricing_marker.kwargs:
+                filtered.append(item)
+
+    items[:] = filtered
 
 
 def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
diff --git a/tests/benchmark/compute/instruction/test_account_query.py b/tests/benchmark/compute/instruction/test_account_query.py
@@ -39,7 +39,7 @@
 )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(contract_balance=0)
 @pytest.mark.parametrize("contract_balance", [0, 1])
 def test_selfbalance(
     benchmark_test: BenchmarkTestFiller,
@@ -359,7 +359,7 @@ def test_extcodecopy_warm(
     benchmark_test(tx=tx)
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(absent_target=False)
 @pytest.mark.parametrize(
     "opcode",
     [
diff --git a/tests/benchmark/compute/instruction/test_arithmetic.py b/tests/benchmark/compute/instruction/test_arithmetic.py
@@ -33,24 +33,26 @@
 from tests.benchmark.compute.helpers import DEFAULT_BINOP_ARGS, make_dup, neg
 
 
-@pytest.mark.repricing
 @pytest.mark.parametrize(
     "opcode,opcode_args",
     [
-        (
+        pytest.param(
             Op.ADD,
             DEFAULT_BINOP_ARGS,
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             Op.MUL,
             DEFAULT_BINOP_ARGS,
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # After every 2 SUB operations, values return to initial.
             Op.SUB,
             DEFAULT_BINOP_ARGS,
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # This has the cycle of 2:
             # v[0] = a // b
             # v[1] = a // v[0] = a // (a // b) = b
@@ -63,8 +65,9 @@
                 # optimized paths for division by 1 and 2 words.
                 0x100000000000000000000000000000033,
             ),
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # This has the cycle of 2, see above.
             Op.DIV,
             (
@@ -75,16 +78,17 @@
                 0x10000000000000033,
             ),
         ),
-        (
+        pytest.param(
             # Same as DIV-0
             # But the numerator made positive, and the divisor made negative.
             Op.SDIV,
             (
                 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F,
                 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCD,
             ),
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # Same as DIV-1
             # But the numerator made positive, and the divisor made negative.
             Op.SDIV,
@@ -93,32 +97,36 @@
                 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFCD,
             ),
         ),
-        (
+        pytest.param(
             # Not suitable for MOD, as values quickly become zero.
             Op.MOD,
             DEFAULT_BINOP_ARGS,
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # Not suitable for SMOD, as values quickly become zero.
             Op.SMOD,
             DEFAULT_BINOP_ARGS,
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # This keeps the values unchanged
             # pow(2**256-1, 2**256-1, 2**256) == 2**256-1.
             Op.EXP,
             (
                 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
                 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF,
             ),
+            marks=pytest.mark.repricing,
         ),
-        (
+        pytest.param(
             # Not great, as we always sign-extend the 4 bytes.
             Op.SIGNEXTEND,
             (
                 3,
                 0xFFDADADA,  # Negative to have more work.
             ),
+            marks=pytest.mark.repricing,
         ),
     ],
     ids=lambda param: "" if isinstance(param, tuple) else param,
@@ -150,7 +158,7 @@ def test_arithmetic(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(mod_bits=255)
 @pytest.mark.parametrize("mod_bits", [255, 191, 127, 63])
 @pytest.mark.parametrize("op", [Op.MOD, Op.SMOD])
 def test_mod(
@@ -269,6 +277,7 @@ def test_mod(
     )
 
 
+@pytest.mark.repricing(mod_bits=255)
 @pytest.mark.parametrize("mod_bits", [255, 191, 127, 63])
 @pytest.mark.parametrize("op", [Op.ADDMOD, Op.MULMOD])
 def test_mod_arithmetic(
diff --git a/tests/benchmark/compute/instruction/test_call_context.py b/tests/benchmark/compute/instruction/test_call_context.py
@@ -49,7 +49,7 @@ def test_call_frame_context_ops(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(calldata_length=1_000)
 @pytest.mark.parametrize("calldata_length", [0, 1_000, 10_000])
 def test_calldatasize(
     benchmark_test: BenchmarkTestFiller,
@@ -64,6 +64,7 @@ def test_calldatasize(
     )
 
 
+@pytest.mark.repricing(non_zero_value=True, from_origin=True)
 @pytest.mark.parametrize("non_zero_value", [True, False])
 @pytest.mark.parametrize("from_origin", [True, False])
 def test_callvalue(
@@ -103,7 +104,7 @@ def test_callvalue(
     benchmark_test(tx=tx)
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(calldata=b"")
 @pytest.mark.parametrize(
     "calldata",
     [
@@ -233,7 +234,10 @@ def test_calldatacopy(
     benchmark_test(tx=tx)
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(
+    returned_size=1,
+    return_data_style=ReturnDataStyle.RETURN,
+)
 @pytest.mark.parametrize(
     "return_data_style",
     [
@@ -287,7 +291,7 @@ def test_returndatasize_zero(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(size=10 * 1024, fixed_dst=True)
 @pytest.mark.parametrize(
     "size",
     [
diff --git a/tests/benchmark/compute/instruction/test_log.py b/tests/benchmark/compute/instruction/test_log.py
@@ -18,7 +18,12 @@
 )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(
+    size=1024 * 1024,
+    non_zero_data=True,
+    zeros_topic=False,
+    fixed_offset=True,
+)
 @pytest.mark.parametrize(
     "opcode",
     [
diff --git a/tests/benchmark/compute/instruction/test_memory.py b/tests/benchmark/compute/instruction/test_memory.py
@@ -19,7 +19,7 @@
 )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(mem_size=1_000)
 @pytest.mark.parametrize("mem_size", [0, 1, 1_000, 100_000, 1_000_000])
 def test_msize(
     benchmark_test: BenchmarkTestFiller,
@@ -39,7 +39,11 @@ def test_msize(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(
+    offset=31,
+    offset_initialized=True,
+    big_memory_expansion=True,
+)
 @pytest.mark.parametrize("opcode", [Op.MLOAD, Op.MSTORE, Op.MSTORE8])
 @pytest.mark.parametrize("offset", [0, 1, 31])
 @pytest.mark.parametrize("offset_initialized", [True, False])
@@ -73,7 +77,7 @@ def test_memory_access(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(size=10 * 1024, fixed_src_dst=True)
 @pytest.mark.parametrize(
     "size",
     [
diff --git a/tests/benchmark/compute/instruction/test_storage.py b/tests/benchmark/compute/instruction/test_storage.py
@@ -27,6 +27,7 @@
 from tests.benchmark.compute.helpers import StorageAction, TransactionResult
 
 
+@pytest.mark.repricing(key_mut=False, val_mut=False)
 # `key_mut` indicates the key isn't fixed.
 @pytest.mark.parametrize("key_mut", [True, False])
 # `val_mut` indicates that at the end of each big-loop, the value of the target
@@ -72,7 +73,7 @@ def test_tload(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(key_mut=False, dense_val_mut=False)
 @pytest.mark.parametrize("key_mut", [True, False])
 @pytest.mark.parametrize("dense_val_mut", [True, False])
 def test_tstore(
diff --git a/tests/benchmark/compute/instruction/test_system.py b/tests/benchmark/compute/instruction/test_system.py
@@ -431,7 +431,7 @@ def test_creates_collisions(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(return_size=1024, return_non_zero_data=True)
 @pytest.mark.parametrize(
     "opcode",
     [Op.RETURN, Op.REVERT],
diff --git a/tests/benchmark/compute/instruction/test_tx_context.py b/tests/benchmark/compute/instruction/test_tx_context.py
@@ -40,7 +40,7 @@ def test_call_frame_context_ops(
     )
 
 
-@pytest.mark.repricing
+@pytest.mark.repricing(blob_index=0, blobs_present=0)
 @pytest.mark.parametrize(
     "blob_index, blobs_present",
     [

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@`
`39`	`39`	`)`
`40`	`40`
`41`	`41`
`42`		`-@pytest.mark.repricing`
	`42`	`+@pytest.mark.repricing(contract_balance=0)`
`43`	`43`	`@pytest.mark.parametrize("contract_balance", [0, 1])`
`44`	`44`	`def test_selfbalance(`
`45`	`45`	`benchmark_test: BenchmarkTestFiller,`
`@@ -359,7 +359,7 @@ def test_extcodecopy_warm(`
`359`	`359`	`benchmark_test(tx=tx)`
`360`	`360`
`361`	`361`
`362`		`-@pytest.mark.repricing`
	`362`	`+@pytest.mark.repricing(absent_target=False)`
`363`	`363`	`@pytest.mark.parametrize(`
`364`	`364`	`"opcode",`
`365`	`365`	`[`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ def test_call_frame_context_ops(`
`49`	`49`	`)`
`50`	`50`
`51`	`51`
`52`		`-@pytest.mark.repricing`
	`52`	`+@pytest.mark.repricing(calldata_length=1_000)`
`53`	`53`	`@pytest.mark.parametrize("calldata_length", [0, 1_000, 10_000])`
`54`	`54`	`def test_calldatasize(`
`55`	`55`	`benchmark_test: BenchmarkTestFiller,`
`@@ -64,6 +64,7 @@ def test_calldatasize(`
`64`	`64`	`)`
`65`	`65`
`66`	`66`
	`67`	`+@pytest.mark.repricing(non_zero_value=True, from_origin=True)`
`67`	`68`	`@pytest.mark.parametrize("non_zero_value", [True, False])`
`68`	`69`	`@pytest.mark.parametrize("from_origin", [True, False])`
`69`	`70`	`def test_callvalue(`
`@@ -103,7 +104,7 @@ def test_callvalue(`
`103`	`104`	`benchmark_test(tx=tx)`
`104`	`105`
`105`	`106`
`106`		`-@pytest.mark.repricing`
	`107`	`+@pytest.mark.repricing(calldata=b"")`
`107`	`108`	`@pytest.mark.parametrize(`
`108`	`109`	`"calldata",`
`109`	`110`	`[`
`@@ -233,7 +234,10 @@ def test_calldatacopy(`
`233`	`234`	`benchmark_test(tx=tx)`
`234`	`235`
`235`	`236`
`236`		`-@pytest.mark.repricing`
	`237`	`+@pytest.mark.repricing(`
	`238`	`+ returned_size=1,`
	`239`	`+ return_data_style=ReturnDataStyle.RETURN,`
	`240`	`+)`
`237`	`241`	`@pytest.mark.parametrize(`
`238`	`242`	`"return_data_style",`
`239`	`243`	`[`
`@@ -287,7 +291,7 @@ def test_returndatasize_zero(`
`287`	`291`	`)`
`288`	`292`
`289`	`293`
`290`		`-@pytest.mark.repricing`
	`294`	`+@pytest.mark.repricing(size=10 * 1024, fixed_dst=True)`
`291`	`295`	`@pytest.mark.parametrize(`
`292`	`296`	`"size",`
`293`	`297`	`[`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,12 @@`
`18`	`18`	`)`
`19`	`19`
`20`	`20`
`21`		`-@pytest.mark.repricing`
	`21`	`+@pytest.mark.repricing(`
	`22`	`+ size=1024 * 1024,`
	`23`	`+ non_zero_data=True,`
	`24`	`+ zeros_topic=False,`
	`25`	`+ fixed_offset=True,`
	`26`	`+)`
`22`	`27`	`@pytest.mark.parametrize(`
`23`	`28`	`"opcode",`
`24`	`29`	`[`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`)`
`20`	`20`
`21`	`21`
`22`		`-@pytest.mark.repricing`
	`22`	`+@pytest.mark.repricing(mem_size=1_000)`
`23`	`23`	`@pytest.mark.parametrize("mem_size", [0, 1, 1_000, 100_000, 1_000_000])`
`24`	`24`	`def test_msize(`
`25`	`25`	`benchmark_test: BenchmarkTestFiller,`
`@@ -39,7 +39,11 @@ def test_msize(`
`39`	`39`	`)`
`40`	`40`
`41`	`41`
`42`		`-@pytest.mark.repricing`
	`42`	`+@pytest.mark.repricing(`
	`43`	`+ offset=31,`
	`44`	`+ offset_initialized=True,`
	`45`	`+ big_memory_expansion=True,`
	`46`	`+)`
`43`	`47`	`@pytest.mark.parametrize("opcode", [Op.MLOAD, Op.MSTORE, Op.MSTORE8])`
`44`	`48`	`@pytest.mark.parametrize("offset", [0, 1, 31])`
`45`	`49`	`@pytest.mark.parametrize("offset_initialized", [True, False])`
`@@ -73,7 +77,7 @@ def test_memory_access(`
`73`	`77`	`)`
`74`	`78`
`75`	`79`
`76`		`-@pytest.mark.repricing`
	`80`	`+@pytest.mark.repricing(size=10 * 1024, fixed_src_dst=True)`
`77`	`81`	`@pytest.mark.parametrize(`
`78`	`82`	`"size",`
`79`	`83`	`[`
Original file line number	Diff line number	Diff line change
`@@ -431,7 +431,7 @@ def test_creates_collisions(`
`431`	`431`	`)`
`432`	`432`
`433`	`433`
`434`		`-@pytest.mark.repricing`
	`434`	`+@pytest.mark.repricing(return_size=1024, return_non_zero_data=True)`
`435`	`435`	`@pytest.mark.parametrize(`
`436`	`436`	`"opcode",`
`437`	`437`	`[Op.RETURN, Op.REVERT],`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ def test_call_frame_context_ops(`
`40`	`40`	`)`
`41`	`41`
`42`	`42`
`43`		`-@pytest.mark.repricing`
	`43`	`+@pytest.mark.repricing(blob_index=0, blobs_present=0)`
`44`	`44`	`@pytest.mark.parametrize(`
`45`	`45`	`"blob_index, blobs_present",`
`46`	`46`	`[`