Tricky Revert Test With Missing Coverage Branch

[Niferu]

Hello Guys,

Does anyone have an idea how can I test revert from this function:

    /// @dev Override Vote Function
    /// @notice Changes block.number into block.timestamp for snapshot
    function clock() public view override returns (uint48) {
        return Time.timestamp();
    }

    /// @dev Override Vote Function
    /// @notice Changes block.number into block.timestamp for snapshot
    function CLOCK_MODE() public view override returns (string memory) {
        // Check that the clock was not modified
        if (clock() != Time.timestamp()) revert ERC6372InconsistentClock();

        return "mode=timestamp";
    }

The problem is that mocking revert doesnt count as proper test and I still have missing branch in my coverage report...

    /// @dev COVERAGE DOES NOT ACCEPT 'MockCallRevert', SO THER IS MISSING BRANCH FOR THIS ERROR In COVERAGE
    function testClockMode() public {
        uint256 currentClock = asset.clock();
        uint256 currentTimestamp = block.timestamp;

        assertEq(currentClock, currentTimestamp);
        assertEq(asset.CLOCK_MODE(), "mode=timestamp");

        vm.expectRevert(Votes.ERC6372InconsistentClock.selector);
        vm.mockCallRevert(address(asset), abi.encodeWithSignature("CLOCK_MODE()"), abi.encodeWithSelector(Votes.ERC6372InconsistentClock.selector));
        asset.CLOCK_MODE();
    }

Would much appreciate any tips/ideas how can I properly test this revert I believe that foundry somehow allows that but I just have no idea how... Thanks in advance!

[Niferu]

Update, I was trying to use try catch blocks but it did not help... If anyone has some smart advice for such testing problems please let me know

[0xkoiner]

The issue is that vm.mockCallRevert mocks the external call to CLOCK_MODE() — it never actually executes the function body, so the if (clock() != Time.timestamp()) branch is never evaluated by the EVM. That's why coverage doesn't pick it up. You need the actual code path inside CLOCK_MODE() to execute and hit that revert.

The core problem: clock() returns Time.timestamp(), and inside CLOCK_MODE() it checks clock() != Time.timestamp() — but since both are called in the same transaction, they will always be equal. Under normal execution, this branch is unreachable.

The trick is to mock clock() (not CLOCK_MODE()) so it returns a value different from block.timestamp. This forces the real CLOCK_MODE() code to execute and hit the revert path:

function testClockModeRevert() public {
    // Mock clock() to return a value that differs from block.timestamp
    // This causes the check inside CLOCK_MODE() to fail
    vm.mockCall(
        address(asset),
        abi.encodeWithSignature("clock()"),
        abi.encode(uint48(block.timestamp + 1))
    );

    vm.expectRevert(Votes.ERC6372InconsistentClock.selector);
    asset.CLOCK_MODE();
}

This works because:

1. CLOCK_MODE() is called for real (not mocked) — so coverage tracks it
2. Inside CLOCK_MODE(), when it calls clock(), the mock intercepts and returns block.timestamp + 1
3. The check clock() != Time.timestamp() becomes (block.timestamp + 1) != block.timestamp → true
4. The revert fires, vm.expectRevert catches it, and coverage sees both branches as covered

Important note: vm.mockCall works on external calls. Since clock() is a public function and CLOCK_MODE() calls it with clock() (which for public functions is an internal call if on the same contract), this depends on whether the compiler routes it as an internal or external call. If the mock doesn't trigger, you can use a test harness instead:

// In your test file
contract BrokenClockHarness is YourToken {
    bool public breakClock;

    function setBreakClock(bool _break) external {
        breakClock = _break;
    }

    function clock() public view override returns (uint48) {
        if (breakClock) return uint48(block.timestamp + 1);
        return super.clock();
    }
}

// In your test
function testClockModeRevertWithHarness() public {
    BrokenClockHarness harness = new BrokenClockHarness();
    // ... initialize harness same as asset ...

    harness.setBreakClock(true);

    vm.expectRevert(Votes.ERC6372InconsistentClock.selector);
    harness.CLOCK_MODE();
}

The harness approach is the most reliable because it guarantees the actual revert path executes inside the real CLOCK_MODE() code — no mocking ambiguity. It's a common pattern for testing "unreachable" branches in OpenZeppelin overrides.