《纸上谈兵·solidity》第 4 课：Solidity 合约中的错误处理机制（`require`、`revert`、`assert`）和自定义错误

require(condition, "Failure message");

function deposit(uint amount) public {
    require(amount > 0, "Deposit amount must be greater than zero");
    balance[msg.sender] += amount;
}

if (conditionFails) {
    revert("Reason for failure");
}

function withdraw(uint amount) public {
    if (amount > balance[msg.sender]) {
        revert("Insufficient balance");
    }
    balance[msg.sender] -= amount;
}

function executeTrade(address user, uint amount) public {
    if (!isWhitelisted(user)) {
        revert("User not whitelisted");
    }
    if (amount < minTradeSize) {
        revert("Trade amount too small");
    }
    // proceed with trade
}

assert(condition);

function increment() public {
    count += 1;
    assert(count > 0); // 这个永远应该成立
}

error NotEnoughBalance(uint256 requested, uint256 available);

function withdraw(uint amount) public {
    if (amount > balance[msg.sender]) {
        revert NotEnoughBalance(amount, balance[msg.sender]);
    }
}

error Unauthorized(address caller);
error InvalidAmount(uint256 amount);

function transferOwnership(address newOwner) public {
    if (msg.sender != owner) revert Unauthorized(msg.sender);
    if (newOwner == address(0)) revert InvalidAmount(0);
    owner = newOwner;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Counter {
    uint256 public count;

    // 添加事件
    event Incremented(uint256 newCount);


    function increment() public {
        count += 1;
        
        // 触发事件
        emit Incremented(count);
    }

    function getCount() public view returns (uint256) {
        return count;
    }

    function whoAmI() public view returns (address) {
        return msg.sender;
    }
}

function incrementRequire() public {
    require(count < 10, "Counter overflow");
    count += 1;
}

error CounterOverflow(uint current);

function incrementRevert() public {
    if (count >= 10) {
        revert CounterOverflow(count);
    }
    count += 1;
}

function decrement() public {
    count -= 1;
    assert(count >= 0); // uint 永远不能 < 0，会 Panic
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "forge-std/Test.sol";
import "../src/Counter.sol";

contract CounterTest is Test {
    Counter counter;

    function setUp() public {
        counter = new Counter();
    }

    function testInitialCountIsZero() view public {
        uint256 c = counter.getCount();
        assertEq(c, 0);
    }

    function testIncrementIncreasesCount() public {
        counter.increment();
        uint256 c = counter.getCount();
        assertEq(c, 1);
    }

    // 测试事件是否正确触发
    function testIncrementEmitsEvent() public {
        // 设定期望的事件参数（按顺序匹配）
        vm.expectEmit(false, false, false, true); // 只检查数据，不检查 topics（因为 uint256 不能 indexed）
        emit Counter.Incremented(1);

        counter.increment();
    }

        function testIncrementRequireSuccess() public {
        for (uint i = 0; i < 10; i++) {
            counter.incrementRequire();
        }
    }

    function testIncrementRequireFail() public {
        for (uint i = 0; i < 10; i++) {
            counter.incrementRequire();
        }
        vm.expectRevert("Counter overflow");
        counter.incrementRequire();
    }

    function testIncrementRevertCustomError() public {
        for (uint i = 0; i < 10; i++) {
            counter.incrementRevert();
        }
        vm.expectRevert(abi.encodeWithSelector(Counter.CounterOverflow.selector, 10));
        counter.incrementRevert();
    }

    function testDecrementPanics() public {
        vm.expectRevert(); // expect a panic due to underflow
        counter.decrement();
    }

    function testDecrementAfterIncrement() public {
        counter.increment();
        counter.decrement();
        assertEq(counter.getCount(), 0);
    }
}