refactor(tests): update checklist item for eip7939 (#2097)

* feat: update checklist item for clz

* feat: add new checklist items

* refactor: update checklist items for eip7939

* refactor: update checklist not applicable itemss

* feat(checklist): Add checklist warnings

* feat(checklist): ad coverage and reentry notes to eip7939 checklist

* fix linting issue

* refactor(checklist): remove duplicate ban check items

---------

Co-authored-by: Mario Vega <[email protected]>

Author: LouisTsai-Csie

docs/writing_tests/checklist_templates/eip_testing_checklist_template.md

@@ -108,6 +108,7 @@ Verify opcode operation in a subcall frame originated from a `STATICCALL` opcode
 
 | ID                                                                 | Description                                                                                                                                                                                                                                                                                | Status | Tests |
 | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------ | ----- |
+| `opcode/test/execution_context/staticcall` | `STATICCALL`.     |        |       |
 | `opcode/test/execution_context/staticcall/ban_check`           | Verify exceptional abort if the opcode attempts to modify the code, storage or balance of an account.                                                                                                                                                                                      |        |       |
 | `opcode/test/execution_context/staticcall/ban_no_modification` | If the opcode is completely banned from static contexts, verify that even when its inputs would not cause any account modification, the opcode still results in exceptional abort of the execution (e.g. `PAY` with zero value, or `SSTORE` to the value it already has in the storage). |        |       |
 | `opcode/test/execution_context/staticcall/sub_calls`           | Verify sub-calls using other opcodes (e.g. `CALL`, `DELEGATECALL`, etc) also results in the same exceptional abort behavior.                                                                                                                                                               |        |       |
@@ -193,6 +194,14 @@ Verify that the memory expansion correctly follows the gas calculation.
 | -------------------------------------------- | ----------------- | ------ | ----- |
 | `opcode/test/gas_usage/memory_expansion` | Memory expansion. |        |       |
 
+##### Extra Gas
+
+Verify that attempting to execute the opcode when gas available is 1 more than the required gas results in exceptional abort.
+
+| ID                                               | Description                         | Status | Tests |
+| ------------------------------------------------ | ----------------------------------- | ------ | ----- |
+| `opcode/test/gas_usage/extra_gas` | extra gas should not fail the execution  |        |       |
+
 ##### Out-Of-Gas
 
 Verify that attempting to execute the opcode when gas available is 1 less than the required gas results in exceptional abort.

src/ethereum_test_checklists/eip_checklist.py

@@ -386,6 +386,11 @@ class OutOfGasMemory(ChecklistItem):
 
                     pass
 
+                class ExtraGas(ChecklistItem):
+                    """Extra gas usage tests."""
+
+                    pass
+
                 class OrderOfOperations(ChecklistItem):
                     """Order of operations tests."""
 

src/ethereum_test_checklists/eip_checklist.pyi

@@ -138,6 +138,7 @@ class EIPChecklist:
                 Invalid: _CallableChecklistItem
 
             class GasUsage(_CallableChecklistItem):
+                ExtraGas: _CallableChecklistItem
                 MemoryExpansion: _CallableChecklistItem
                 Normal: _CallableChecklistItem
                 OutOfGasExecution: _CallableChecklistItem

src/pytest_plugins/filler/eip_checklist.py

@@ -118,7 +118,7 @@ def __str__(self) -> str:
                 status = "❓"
             else:
                 status = "✅"
-            tests = ", ".join(sorted(map(resolve_test_link, self.tests)))
+            tests = ", ".join(sorted(self.tests))
         elif self.not_applicable:
             status = "N/A"
             tests = self.not_applicable_reason
@@ -160,17 +160,6 @@ def resolve_id(item_id: str) -> Set[str]:
     return covered_ids
 
 
-def resolve_test_link(test_id: str) -> str:
-    """Resolve a test ID to a test link."""
-    # test_id example: tests/fork/eip1234_some_eip/test_file.py::test_function[test_param1-...]
-    # Relative path:  ../../../../tests/fork/eip1234_some_eip/test_file/test_function/
-    pattern = r"(.*)\.py::(\w+)"
-    match = re.match(pattern, test_id)
-    if not match:
-        return test_id
-    return f"[{test_id}](../../../../{match.group(1)}/{match.group(2)}/)"
-
-
 ALL_CHECKLIST_WARNINGS: Dict[str, Type["ChecklistWarning"]] = {}
 
 
@@ -222,8 +211,7 @@ def from_items(cls, all_items: Dict[str, EIPItem]) -> ChecklistWarning | None:
         for item in conflicting_items:
             details.append(
                 f"| {item.id} | {item.description} | "
-                + f"{item.not_applicable_reason} | "
-                + f"{', '.join(sorted(map(resolve_test_link, item.tests)))} |"
+                + f"{item.not_applicable_reason} | {', '.join(sorted(item.tests))} |"
             )
 
         return cls(details=details)
@@ -245,6 +233,7 @@ def add_covered_test(self, checklist_id: str, node_id: str) -> None:
     def covered_items(self) -> int:
         """Return the number of covered items."""
         return sum(1 for item in self.items.values() if item.covered and not item.not_applicable)
+        return sum(1 for item in self.items.values() if item.covered and not item.not_applicable)
 
     @property
     def total_items(self) -> int:

tests/osaka/eip7939_count_leading_zeros/eip_checklist_external_coverage.txt

@@ -0,0 +1,2 @@
+general/code_coverage/eels = Please check https://app.codecov.io/gh/ethereum/execution-specs/pull/1388/blob/src/ethereum/osaka/vm/instructions/bitwise.py#L243 for relevant test coverage
+general/code_coverage/test_coverage = Please run the test with `--cov` flag for final coverage

tests/osaka/eip7939_count_leading_zeros/eip_checklist_not_applicable.txt

@@ -0,0 +1,29 @@
+system_contract = EIP does not introduce a new system contract
+precompile = EIP does not introduce a new precompile
+removed_precompile = EIP does not remove a precompile
+transaction_type = EIP does not introduce a new transaction type
+block_header_field = EIP does not add any new block header fields
+block_body_field = EIP does not add any new block body fields
+gas_cost_changes = EIP does not modify existing gas costs, only introduces new opcode with fixed cost
+gas_refunds_changes = EIP does not introduce any gas refund changes
+blob_count_changes = EIP does not introduce any blob count changes
+execution_layer_request = EIP does not introduce an execution layer request
+new_transaction_validity_constraint = EIP does not introduce a new transaction validity constraint
+modified_transaction_validity_constraint = EIP does not introduce a modified transaction validity constraint
+opcode/test/mem_exp = CLZ does not read/write to memory component
+opcode/test/stack_overflow = CLZ takes one args and pushes one args to stack, not increasing stack element, hence no overflow issue
+opcode/test/stack_complex_operations/data_portion_variables = there is no data portion for CLZ
+opcode/test/execution_context/delegatecall/code = CLZ does not modify code
+opcode/test/execution_context/tx_context = CLZ does not change behavior depending on transaction property
+opcode/test/execution_context/block_context = CLZ does not change behavior depending on block property
+opcode/test/execution_context/initcode/reentry = CLZ is not a stateful opcode
+opcode/test/gas_usage/memory_expansion = no memory read/write for CLZ
+opcode/test/gas_usage/out_of_gas_memory = no memory read/write for CLZ
+opcode/test/gas_usage/order_of_operations = the order will not affect result of CLZ
+opcode/test/return_data = although we could verify the return buffer is not affected, but it is more like testing memory write operation, as CLZ does not write to memory directly
+opcode/test/terminating = not such opcode
+opcode/test/terminating/rollback = CLZ is not a terminating opcode, so no rollback behavior
+opcode/test/out_of_bounds = takes one element from stack, no specific boundary
+opcode/test/exceptional_abort = underflow is the only exceptional abort scenario and it is included already
+opcode/test/data_portion = no data portion
+opcode/test/contract_creation = no contract created in execution

tests/osaka/eip7939_count_leading_zeros/test_count_leading_zeros.py

@@ -6,6 +6,7 @@
 import pytest
 
 from ethereum_test_base_types import Storage
+from ethereum_test_checklists import EIPChecklist
 from ethereum_test_forks import Fork
 from ethereum_test_tools import (
     Account,
@@ -144,6 +145,9 @@ def test_clz_gas_cost(state_test: StateTestFiller, pre: Alloc, fork: Fork):
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.GasUsage.Normal()
+@EIPChecklist.Opcode.Test.GasUsage.OutOfGasExecution()
+@EIPChecklist.Opcode.Test.GasUsage.ExtraGas()
 @pytest.mark.valid_from("Osaka")
 @pytest.mark.parametrize("bits", [0, 64, 128, 255])
 @pytest.mark.parametrize("gas_cost_delta", [-2, -1, 0, 1, 2])
@@ -178,6 +182,8 @@ def test_clz_gas_cost_boundary(
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.StackUnderflow()
+@EIPChecklist.Opcode.Test.StackComplexOperations.StackHeights.Zero()
 @pytest.mark.valid_from("Osaka")
 def test_clz_stack_underflow(state_test: StateTestFiller, pre: Alloc):
     """Test CLZ opcode with empty stack (should revert due to stack underflow)."""
@@ -202,6 +208,8 @@ def test_clz_stack_underflow(state_test: StateTestFiller, pre: Alloc):
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.StackComplexOperations.StackHeights.Odd()
+@EIPChecklist.Opcode.Test.StackComplexOperations.StackHeights.Even()
 @pytest.mark.valid_from("Osaka")
 def test_clz_stack_not_overflow(state_test: StateTestFiller, pre: Alloc, fork: Fork):
     """Test CLZ opcode never causes stack overflow."""
@@ -260,6 +268,8 @@ def test_clz_push_operation_same_value(state_test: StateTestFiller, pre: Alloc):
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.ForkTransition.Invalid()
+@EIPChecklist.Opcode.Test.ForkTransition.At()
 @pytest.mark.valid_at_transition_to("Osaka", subsequent_forks=True)
 def test_clz_fork_transition(blockchain_test: BlockchainTestFiller, pre: Alloc):
     """Test CLZ opcode behavior at fork transition."""
@@ -386,6 +396,7 @@ def test_clz_jump_operation(
 auth_account_start_balance = 0
 
 
+@EIPChecklist.Opcode.Test.ExecutionContext.SetCode()
 @pytest.mark.valid_from("Osaka")
 def test_clz_from_set_code(
     state_test: StateTestFiller,
@@ -530,6 +541,7 @@ def test_clz_with_memory_operation(state_test: StateTestFiller, pre: Alloc, bits
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.ExecutionContext.Initcode.Behavior.Tx()
 @pytest.mark.valid_from("Osaka")
 def test_clz_initcode_context(state_test: StateTestFiller, pre: Alloc):
     """Test CLZ opcode behavior when creating a contract."""
@@ -559,6 +571,7 @@ def test_clz_initcode_context(state_test: StateTestFiller, pre: Alloc):
     state_test(pre=pre, post=post, tx=tx)
 
 
+@EIPChecklist.Opcode.Test.ExecutionContext.Initcode.Behavior.Opcode()
 @pytest.mark.valid_from("Osaka")
 @pytest.mark.parametrize("opcode", [Op.CREATE, Op.CREATE2])
 def test_clz_initcode_create(state_test: StateTestFiller, pre: Alloc, opcode: Op):
@@ -609,6 +622,10 @@ class CallingContext:
     no_context = 3  # STATICCALL
 
 
+@EIPChecklist.Opcode.Test.ExecutionContext.Call()
+@EIPChecklist.Opcode.Test.ExecutionContext.Delegatecall()
+@EIPChecklist.Opcode.Test.ExecutionContext.Callcode()
+@EIPChecklist.Opcode.Test.ExecutionContext.Staticcall()
 @pytest.mark.valid_from("Osaka")
 @pytest.mark.parametrize(
     "opcode,context",