[BUG] Code coverage #4142

0xAurelou · 2023-01-20T16:18:49Z

Component

Forge

Have you ensured that all of these are up to date?

Foundry
Foundryup

What version of Foundry are you on?

forge 0.2.0 (d8f2434 2023-01-20T00:09:17.907613959Z)

What command(s) is the bug in?

forge coverage

Operating System

Linux

Describe the bug

When I am doing some code coverage the same code can get me a 0% code coverage while it should be 100% (Both compile)

Source Code

mock/USDC.sol

//  SPDX-License-Identifier: MIT

pragma solidity ^0.8.16;

import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "openzeppelin-contracts/token/ERC20/ERC20.sol";
import "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";

// @notice: Really basic USDC token just an ERC20 token mocked
// @dev: Need to define
contract USDC is ERC20 {
    using SafeERC20 for IERC20;

    constructor() ERC20("Circle Token", "USDC") {}

    function mint(address account, uint256 amount) public {
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) public {
        _burn(account, amount);
    }
}

mock/USDT.sol

//  SPDX-License-Identifier: MIT

pragma solidity ^0.8.16;

import "openzeppelin-contracts/token/ERC20/IERC20.sol";
import "openzeppelin-contracts/token/ERC20/ERC20.sol";
import "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";

// @notice: Really basic USDT token just an ERC20 token mocked
contract USDT is ERC20 {
    using SafeERC20 for IERC20;

    constructor() ERC20("Tether Token", "USDT") {}

    function mint(address account, uint256 amount) public {
        _mint(account, amount);
    }

    function burn(address account, uint256 amount) public {
        _burn(account, amount);
    }
}

test/USDC.t.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.16;

import "forge-std/Test.sol";
import "../mock/USDC.sol";

contract USDCTest is Test {
    USDC public usdc;

    // hardhat getSigner() -> vm.addr()
    address public alice = vm.addr(0x1);
    address public bob = vm.addr(0x2);

    function setUp() public {
        usdc = new USDC();
    }

    function testName() external {
        assertEq("Circle Token", usdc.name());
    }

    function testSymbol() external {
        assertEq("USDC", usdc.symbol());
    }

    function testMint() public {
        usdc.mint(alice, 2e18);
        assertEq(usdc.totalSupply(), usdc.balanceOf(alice));
    }

    function testBurn() public {
        usdc.mint(alice, 10e18);
        assertEq(usdc.balanceOf(alice), 10e18);

        usdc.burn(alice, 8e18);

        assertEq(usdc.totalSupply(), 2e18);
        assertEq(usdc.balanceOf(alice), 2e18);
    }

    function testApprove() public {
        assertTrue(usdc.approve(alice, 1e18));
        assertEq(usdc.allowance(address(this), alice), 1e18);
    }

    function testIncreaseAllowance() external {
        assertEq(usdc.allowance(address(this), alice), 0);
        assertTrue(usdc.increaseAllowance(alice, 2e18));
        assertEq(usdc.allowance(address(this), alice), 2e18);
    }

    function testDescreaseAllowance() external {
        testApprove();
        assertTrue(usdc.decreaseAllowance(alice, 0.5e18));
        assertEq(usdc.allowance(address(this), alice), 0.5e18);
    }

    function testTransfer() external {
        testMint();
        vm.startPrank(alice);
        usdc.transfer(bob, 0.5e18);
        assertEq(usdc.balanceOf(bob), 0.5e18);
        assertEq(usdc.balanceOf(alice), 1.5e18);
        vm.stopPrank();
    }

    function testTransferFrom() external {
        testMint();
        vm.prank(alice);
        usdc.approve(address(this), 1e18);
        assertTrue(usdc.transferFrom(alice, bob, 0.7e18));
        assertEq(usdc.allowance(alice, address(this)), 1e18 - 0.7e18);
        assertEq(usdc.balanceOf(alice), 2e18 - 0.7e18);
        assertEq(usdc.balanceOf(bob), 0.7e18);
    }

    function testMintZero() public {
        vm.expectRevert("ERC20: mint to the zero address");
        usdc.mint(address(0), 2e18);
    }

    function testFailMintToZero() external {
        usdc.mint(address(0), 1e18);
    }

    function testFailBurnFromZero() external {
        usdc.burn(address(0), 1e18);
    }

    function testFailBurnInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdc.burn(alice, 3e18);
    }

    function testFailApproveToZeroAddress() external {
        usdc.approve(address(0), 1e18);
    }

    function testFailApproveFromZeroAddress() external {
        vm.prank(address(0));
        usdc.approve(alice, 1e18);
    }

    function testFailTransferToZeroAddress() external {
        testMint();
        vm.prank(alice);
        usdc.transfer(address(0), 1e18);
    }

    function testFailTransferFromZeroAddress() external {
        testBurn();
        vm.prank(address(0));
        usdc.transfer(alice, 1e18);
    }

    function testFailTransferInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdc.transfer(bob, 3e18);
    }

    function testFailTransferFromInsufficientApprove() external {
        testMint();
        vm.prank(alice);
        usdc.approve(address(this), 1e18);
        usdc.transferFrom(alice, bob, 2e18);
    }

    function testFailTransferFromInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdc.approve(address(this), type(uint256).max);

        usdc.transferFrom(alice, bob, 3e18);
    }

    function testMint(uint256 amount) public {
        usdc.mint(alice, amount);
        assertEq(usdc.totalSupply(), usdc.balanceOf(alice));
    }

    function testBurn(uint256 amount) public {
        usdc.mint(alice, 10e18);
        if (amount > usdc.balanceOf(alice)) {
            vm.expectRevert("ERC20: burn amount exceeds balance");
            usdc.burn(alice, amount);
            return;
        } else {
            usdc.burn(alice, amount);
        }
        assertEq(usdc.balanceOf(alice), 10e18 - amount);
        assertEq(usdc.totalSupply(), 10e18 - amount);
    }

    function testApprove(uint256 amount) public {
        assertTrue(usdc.approve(alice, amount));
        assertEq(usdc.allowance(address(this), alice), amount);
    }

    function testIncreaseAllowance(uint256 amount) external {
        assertEq(usdc.allowance(address(this), alice), 0);
        assertTrue(usdc.increaseAllowance(alice, amount));
        assertEq(usdc.allowance(address(this), alice), amount);
    }

    function testDecreaseAllowance(uint256 amount) external {
        testApprove(0.5e18);
        if (amount > 0.5e18) {
            vm.expectRevert("ERC20: decreased allowance below zero");
            usdc.decreaseAllowance(alice, amount);
            return ();
        }
        assertTrue(usdc.decreaseAllowance(alice, amount));
        assertEq(usdc.allowance(address(this), alice), 0.5e18 - amount);
    }

    function testTransfer(uint256 amount) external {
        testMint(10e18);
        if (amount > 10e18) {
            vm.startPrank(alice);
            vm.expectRevert("ERC20: transfer amount exceeds balance");
            usdc.transfer(bob, amount);
            return;
        } else {
            vm.prank(alice);
            usdc.transfer(bob, amount);
        }
        assertEq(usdc.balanceOf(bob), amount);
        vm.stopPrank();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.16;

import "forge-std/Test.sol";
import "../mock/USDT.sol";

contract USDTTest is Test {
    USDT public usdt;

    // hardhat getSigner() -> vm.addr()
    address public alice = vm.addr(0x1);
    address public bob = vm.addr(0x2);

    function setUp() public {
        usdt = new USDT();
    }

    function testName() external {
        assertEq("Tether Token", usdt.name());
    }

    function testSymbol() external {
        assertEq("USDT", usdt.symbol());
    }

    function testMint() public {
        usdt.mint(alice, 2e18);
        assertEq(usdt.totalSupply(), usdt.balanceOf(alice));
    }

    function testMint2() public {
        usdt.mint(bob, 2e18);
        assertEq(2e18, usdt.balanceOf(bob));
    }

    function testBurn() public {
        usdt.mint(alice, 10e18);
        assertEq(usdt.balanceOf(alice), 10e18);

        usdt.burn(alice, 8e18);

        assertEq(usdt.totalSupply(), 2e18);
        assertEq(usdt.balanceOf(alice), 2e18);
    }

    function testBurn2() public {
        usdt.mint(bob, 10e18);
        assertEq(usdt.balanceOf(bob), 10e18);

        usdt.burn(bob, 8e18);

        assertEq(usdt.totalSupply(), 2e18);
        assertEq(usdt.balanceOf(bob), 2e18);
    }

    function testApprove() public {
        assertTrue(usdt.approve(alice, 1e18));
        assertEq(usdt.allowance(address(this), alice), 1e18);
    }

    function testIncreaseAllowance() external {
        assertEq(usdt.allowance(address(this), alice), 0);
        assertTrue(usdt.increaseAllowance(alice, 2e18));
        assertEq(usdt.allowance(address(this), alice), 2e18);
    }

    function testDescreaseAllowance() external {
        testApprove();
        assertTrue(usdt.decreaseAllowance(alice, 0.5e18));
        assertEq(usdt.allowance(address(this), alice), 0.5e18);
    }

    function testTransfer() external {
        testMint();
        vm.startPrank(alice);
        usdt.transfer(bob, 0.5e18);
        assertEq(usdt.balanceOf(bob), 0.5e18);
        assertEq(usdt.balanceOf(alice), 1.5e18);
        vm.stopPrank();
    }

    function testTransferFrom() external {
        testMint();
        vm.prank(alice);
        usdt.approve(address(this), 1e18);
        assertTrue(usdt.transferFrom(alice, bob, 0.7e18));
        assertEq(usdt.allowance(alice, address(this)), 1e18 - 0.7e18);
        assertEq(usdt.balanceOf(alice), 2e18 - 0.7e18);
        assertEq(usdt.balanceOf(bob), 0.7e18);
    }

    function testMintZero() public {
        vm.expectRevert("ERC20: mint to the zero address");
        usdt.mint(address(0), 2e18);
    }

    function testFailMintToZero() external {
        usdt.mint(address(0), 1e18);
    }

    function testFailBurnFromZero() external {
        usdt.burn(address(0), 1e18);
    }

    function testFailBurnInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdt.burn(alice, 3e18);
    }

    function testFailApproveToZeroAddress() external {
        usdt.approve(address(0), 1e18);
    }

    function testFailApproveFromZeroAddress() external {
        vm.prank(address(0));
        usdt.approve(alice, 1e18);
    }

    function testFailTransferToZeroAddress() external {
        testMint();
        vm.prank(alice);
        usdt.transfer(address(0), 1e18);
    }

    function testFailTransferFromZeroAddress() external {
        testBurn();
        vm.prank(address(0));
        usdt.transfer(alice, 1e18);
    }

    function testFailTransferInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdt.transfer(bob, 3e18);
    }

    function testFailTransferFromInsufficientApprove() external {
        testMint();
        vm.prank(alice);
        usdt.approve(address(this), 1e18);
        usdt.transferFrom(alice, bob, 2e18);
    }

    function testFailTransferFromInsufficientBalance() external {
        testMint();
        vm.prank(alice);
        usdt.approve(address(this), type(uint256).max);

        usdt.transferFrom(alice, bob, 3e18);
    }

    function testMint(uint256 amount) public {
        usdt.mint(alice, amount);
        assertEq(usdt.totalSupply(), usdt.balanceOf(alice));
    }

    function testBurn(uint256 amount) public {
        usdt.mint(alice, 10e18);
        if (amount > usdt.balanceOf(alice)) {
            vm.expectRevert("ERC20: burn amount exceeds balance");
            usdt.burn(alice, amount);
            return;
        } else {
            usdt.burn(alice, amount);
        }
        assertEq(usdt.balanceOf(alice), 10e18 - amount);
        assertEq(usdt.totalSupply(), 10e18 - amount);
    }

    function testApprove(uint256 amount) public {
        assertTrue(usdt.approve(alice, amount));
        assertEq(usdt.allowance(address(this), alice), amount);
    }

    function testIncreaseAllowance(uint256 amount) external {
        assertEq(usdt.allowance(address(this), alice), 0);
        assertTrue(usdt.increaseAllowance(alice, amount));
        assertEq(usdt.allowance(address(this), alice), amount);
    }

    function testDecreaseAllowance(uint256 amount) external {
        testApprove(0.5e18);
        if (amount > 0.5e18) {
            vm.expectRevert("ERC20: decreased allowance below zero");
            usdt.decreaseAllowance(alice, amount);
            return ();
        }
        assertTrue(usdt.decreaseAllowance(alice, amount));
        assertEq(usdt.allowance(address(this), alice), 0.5e18 - amount);
    }

    function testTransfer(uint256 amount) external {
        testMint(10e18);
        if (amount > 10e18) {
            vm.startPrank(alice);
            vm.expectRevert("ERC20: transfer amount exceeds balance");
            usdt.transfer(bob, amount);
            return;
        } else {
            vm.prank(alice);
            usdt.transfer(bob, amount);
        }
        assertEq(usdt.balanceOf(bob), amount);
        vm.stopPrank();
    }
}

Output

The text was updated successfully, but these errors were encountered:

PaulRBerg · 2023-01-21T13:07:23Z

Hey @0xAurelou, a friendly suggestion - your issue would be more readable if you put the code in a collapsible Markdown section.

0xAurelou · 2023-01-21T21:31:49Z

Hello @PaulRBerg,
My issue have been updated hope it's better in this way 👍

0xAurelou · 2023-01-26T18:45:52Z

@PaulRBerg No Update or ETA on this issue ?

PaulRBerg · 2023-01-26T18:57:48Z

@0xAurelou I am not an active Foundry maintainer.

0xAurelou · 2023-01-26T19:12:32Z

Sorry my Bad I thought you were.
Cheers

KholdStare · 2023-04-21T19:31:57Z

@onbjerg Seems like a few code coverage bugs are related to more than one contract having a similar interface. I think code coverage gets attributed to the wrong function/contract if they share bytecode or naming? Not sure what it is, but I've seen several issues with very similar symptoms. Any insight?

Thank you

grandizzy · 2024-06-27T08:21:44Z

looks similar with #6875 which was solved in #8214 please reopen if you still see the issue with latest

0xAurelou added the T-bug Type: bug label Jan 20, 2023

0xAurelou changed the title ~~[BUG]~~ [BUG] Code coverage Jan 20, 2023

0xAurelou mentioned this issue Feb 8, 2023

[Bug] code coverage does not work if function is called inside of assertTrue #4306

Closed

2 tasks

grandizzy mentioned this issue Jun 20, 2024

forge coverage does not work for specific contract #6875

Closed

2 tasks

grandizzy closed this as completed Jun 27, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[BUG] Code coverage #4142

[BUG] Code coverage #4142

0xAurelou commented Jan 20, 2023 •

edited

Loading

PaulRBerg commented Jan 21, 2023 •

edited

Loading

0xAurelou commented Jan 21, 2023

0xAurelou commented Jan 26, 2023

PaulRBerg commented Jan 26, 2023

0xAurelou commented Jan 26, 2023

KholdStare commented Apr 21, 2023

grandizzy commented Jun 27, 2024

[BUG] Code coverage #4142

[BUG] Code coverage #4142

Comments

0xAurelou commented Jan 20, 2023 • edited Loading

Component

Have you ensured that all of these are up to date?

What version of Foundry are you on?

What command(s) is the bug in?

Operating System

Describe the bug

Output

PaulRBerg commented Jan 21, 2023 • edited Loading

0xAurelou commented Jan 21, 2023

0xAurelou commented Jan 26, 2023

PaulRBerg commented Jan 26, 2023

0xAurelou commented Jan 26, 2023

KholdStare commented Apr 21, 2023

grandizzy commented Jun 27, 2024

0xAurelou commented Jan 20, 2023 •

edited

Loading

PaulRBerg commented Jan 21, 2023 •

edited

Loading