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.

[DefiAudit0x]

The reason nothing works: that branch is unreachable on the contract under test. clock() returns Time.timestamp() and CLOCK_MODE() compares it against Time.timestamp() — the two are always equal, so no state manipulation can make them diverge, and mockCallRevert can't cover it because it never executes the function body (the branch is never evaluated by the EVM).

The standard pattern for defensive-but-dead branches: deploy a test harness that inherits the contract under test and overrides only clock(), so the comparison genuinely fails and the real code path executes:

import {ERC20Votes} from "openzeppelin/token/ERC20/extensions/ERC20Votes.sol";

contract InconsistentClock is ERC20Votes {
    function clock() public view override returns (uint48) {
        return uint48(block.number); // always != block.timestamp -> branch taken
    }
}

function test_clockMode_revertsOnInconsistentClock() public {
    InconsistentClock token = new InconsistentClock();
    vm.expectRevert(Votes.ERC6372InconsistentClock.selector);
    token.CLOCK_MODE(); // real execution -> branch counted in forge coverage
}

Because CLOCK_MODE() itself runs unmodified, the if (clock() != Time.timestamp()) revert ERC6372InconsistentClock() branch is genuinely evaluated and shows up in forge coverage — unlike the mock, which short-circuits at the call boundary.

Keep your original happy-path test as-is; together the two tests cover both branches of the check. This harness-override trick is generally the cleanest way to cover "this should never happen" guards that are provably unreachable on a correct implementation.