Expression has to be an lvalue.

[ardur77]

While testing the FundMetest.s.sol, I'm getting this error and the error is in the function "testWithdrawFromMultipleFunders".

The FundMeTest.s.sol file is as

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import{Test, console} from "forge-std/Test.sol";
import{FundMe} from "../src/FundMe.sol";
import{DeployFundMe} from "../script/DeployFundMe.s.sol";

contract FundMeTest is Test {
    FundMe fundMe;
    address USER = makeAddr("user");
    uint256 constant SEND_VALUE = 0.1 ether;
    uint256 constant STARTING_BALANCE = 10 ether;

    function setUp() external {
        // fundMe = new FundMe(0x694AA1769357215DE4FAC081bf1f309aDC325306);
        DeployFundMe deployFundMe = new DeployFundMe();
        fundMe = deployFundMe.run();
        vm.deal(USER, STARTING_BALANCE);

    }

    function testMinDollarIsFive() public view{
        assertEq(fundMe.MINIMUM_USD(), 5e18);
    }

    function testOwnerisMsgSender() public view{
        assertEq(fundMe.i_owner(), msg.sender);
    }

    function testPriceFeedVersionIsAccurate() public view{
        (uint256 version) = fundMe.getVersion();
        assertEq(version, 6);
    }

    function testFundFailsWithoutEnoughETH() public {
        vm.expectRevert();
        fundMe.fund();
    }

    function testFundUpdatesFundedDataStructure() public {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();

        uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
        assertEq(amountFunded, SEND_VALUE);
    }

    function testAddsFunderToArrayOfFunders() public {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();

        address funder = fundMe.getFunder(0);
        assertEq(funder, USER);
    }

    modifier funded {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();
        _;
    }

    function testOnlyOwnerCanWithdraw() public funded {
        
        vm.prank(USER);
        vm.expectRevert();
        fundMe.withdraw();
    }

    function testWithdrawWithASingleFunder() public funded {
        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;

        vm.prank(fundMe.getOwner());
        fundMe.withdraw();

        uint256 endingOwnerBalance = fundMe.getOwner().balance;
        uint256 endingFundMeBalance = address(fundMe).balance;
        assertEq(endingFundMeBalance, 0);
        assertEq(startingOwnerBalance + startingFundMeBalance, endingOwnerBalance);
    }

    function testWithdrawFromMultipleFunders() public funded {
        //Arrange
        uint160 numberofFunders = 10;
        uint160 startingFundingIndex = 1;
        for(uint160 i = startingFundingIndex; i< numberofFunders; i++){

            hoax(address(i), SEND_VALUE);
            fundMe.fund{value: SEND_VALUE}();
        }
        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;
        //Act
        vm.startPrank(fundMe.getOwner());
        fundMe.withdraw;
        vm.stopPrank();

        //Assert
        assert(address(fundMe).balance == 0);
        assert(startingFundMeBalance + startingOwnerBalance = fundMe.getOwner().balance);
    }


}   

The error is as below.

Compiler run failed:
Error (4247): Expression has to be an lvalue.
   --> test/FundMetest.t.sol:101:16:
    |
101 |         assert(startingFundMeBalance + startingOwnerBalance = fundMe.getOwner().balance);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Error (9553): Invalid type for argument in function call. Invalid implicit conversion from uint256 to bool requested.
   --> test/FundMetest.t.sol:101:16:
    |
101 |         assert(startingFundMeBalance + startingOwnerBalance = fundMe.getOwner().balance);

[sumit03guha]

it seems that you are missing a = in the equality operator.
assert(x == y) instead of assert(x = y)

assert(startingFundMeBalance + startingOwnerBalance == fundMe.getOwner().balance);

[ardur77]

Oops, thank you but now I'm getting this assertion error.

Ran 1 test for test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFunders() (gas: 599614)
Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 584.79µs (164.58µs CPU time)

Ran 1 test suite in 3.61ms (584.79µs CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFunders() (gas: 599614)
Encountered a total of 1 failing tests, 0 tests succeeded

[sumit03guha]

also you can do the following
use assertEq

assertEq(startingFundMeBalance + startingOwnerBalance , fundMe.getOwner().balance);

[sumit03guha]

• run the test with more verbosity using -vvvv
• use console logs

these will help you identify the bug in the code

[sumit03guha]

i guess the bug lies here
hoax(address(i), SEND_VALUE);

this should be
hoax(address(i), STARTING_USER_BALANCE);

[EngrPips]

Hello @ardur77, Please run the test with more verbosity as @sumit03guha as that will give more insight into the process of the test and like we can catch what is going wrong.

[EngrPips]

Also, try to keep your test structure to one assert per test function that will help you prevent headache.

[ardur77]

@EngrPips surely, I'll try to and thanks a bunch for the helps.

[ardur77]

Sorry, got caught up with some college work but I did what you said and still getting the error i.e. as below.

Ran 1 test for test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFunders() (gas: 599614)
Traces:
  [2796314] FundMeTest::setUp()
    ├─ [1382339] → new DeployFundMe@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
    │   └─ ← [Return] 6794 bytes of code
    ├─ [1371915] DeployFundMe::run()
    │   ├─ [879734] → new HelperConfig@0x104fBc016F4bb334D775a19E8A6510109AC63E00
    │   │   ├─ [0] VM::startBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   ├─ [367647] → new MockV3Aggregator@0x34A1D3fff3958843C43aD80F30b94c510645C316
    │   │   │   └─ ← [Return] 1059 bytes of code
    │   │   ├─ [0] VM::stopBroadcast()
    │   │   │   └─ ← [Return] 
    │   │   └─ ← [Return] 2157 bytes of code
    │   ├─ [358] HelperConfig::activeNetworkConfig() [staticcall]
    │   │   └─ ← [Return] MockV3Aggregator: [0x34A1D3fff3958843C43aD80F30b94c510645C316]
    │   ├─ [0] VM::startBroadcast()
    │   │   └─ ← [Return] 
    │   ├─ [424896] → new FundMe@0x90193C961A926261B756D1E5bb255e67ff9498A1
    │   │   └─ ← [Return] 1900 bytes of code
    │   ├─ [0] VM::stopBroadcast()
    │   │   └─ ← [Return] 
    │   └─ ← [Return] FundMe: [0x90193C961A926261B756D1E5bb255e67ff9498A1]
    ├─ [0] VM::deal(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    └─ ← [Stop] 

  [599614] FundMeTest::testWithdrawFromMultipleFunders()
    ├─ [0] VM::prank(user: [0x6CA6d1e2D5347Bfab1d91e883F1915560e09129D])
    │   └─ ← [Return] 
    ├─ [81346] FundMe::fund{value: 100000000000000000}()
    │   ├─ [8991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ECRecover: [0x0000000000000000000000000000000000000001], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ECRecover: [0x0000000000000000000000000000000000000001])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(SHA-256: [0x0000000000000000000000000000000000000002], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(SHA-256: [0x0000000000000000000000000000000000000002])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(RIPEMD-160: [0x0000000000000000000000000000000000000003], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(RIPEMD-160: [0x0000000000000000000000000000000000000003])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(Identity: [0x0000000000000000000000000000000000000004], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(Identity: [0x0000000000000000000000000000000000000004])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ModExp: [0x0000000000000000000000000000000000000005], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ModExp: [0x0000000000000000000000000000000000000005])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ECAdd: [0x0000000000000000000000000000000000000006], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ECAdd: [0x0000000000000000000000000000000000000006])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ECMul: [0x0000000000000000000000000000000000000007], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ECMul: [0x0000000000000000000000000000000000000007])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(ECPairing: [0x0000000000000000000000000000000000000008], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(ECPairing: [0x0000000000000000000000000000000000000008])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [0] VM::deal(Blake2F: [0x0000000000000000000000000000000000000009], 10000000000000000000 [1e19])
    │   └─ ← [Return] 
    ├─ [0] VM::prank(Blake2F: [0x0000000000000000000000000000000000000009])
    │   └─ ← [Return] 
    ├─ [46946] FundMe::fund{value: 100000000000000000}()
    │   ├─ [991] MockV3Aggregator::latestRoundData() [staticcall]
    │   │   └─ ← [Return] 1, 200000000000 [2e11], 1, 1, 1
    │   └─ ← [Stop] 
    ├─ [2352] FundMe::getOwner() [staticcall]
    │   └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
    ├─ [352] FundMe::getOwner() [staticcall]
    │   └─ ← [Return] DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38]
    ├─ [0] VM::startPrank(DefaultSender: [0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38])
    │   └─ ← [Return] 
    ├─ [0] VM::stopPrank()
    │   └─ ← [Return] 
    └─ ← [Revert] panic: assertion failed (0x01)

Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 2.31ms (172.05µs CPU time)

Ran 1 test suite in 923.11ms (2.31ms CPU time): 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/FundMetest.t.sol:FundMeTest
[FAIL: panic: assertion failed (0x01)] testWithdrawFromMultipleFunders() (gas: 599614)
Encountered a total of 1 failing tests, 0 tests succeeded

Just getting the [Revert[ panic: assertion failed error.

[EngrPips]

Which assertion are you testing for?

[ardur77]

Here's the FundMetest.s.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import{Test, console} from "forge-std/Test.sol";
import{FundMe} from "../src/FundMe.sol";
import{DeployFundMe} from "../script/DeployFundMe.s.sol";

contract FundMeTest is Test {
    FundMe fundMe;
    address USER = makeAddr("user");
    uint256 constant SEND_VALUE = 0.1 ether;
    uint256 constant STARTING_USER_BALANCE = 10 ether;

    function setUp() external {
        // fundMe = new FundMe(0x694AA1769357215DE4FAC081bf1f309aDC325306);
        DeployFundMe deployFundMe = new DeployFundMe();
        fundMe = deployFundMe.run();
        vm.deal(USER, STARTING_USER_BALANCE);

    }

    function testMinDollarIsFive() public view{
        assertEq(fundMe.MINIMUM_USD(), 5e18);
    }

    function testOwnerisMsgSender() public view{
        assertEq(fundMe.i_owner(), msg.sender);
    }

    function testPriceFeedVersionIsAccurate() public view{
        (uint256 version) = fundMe.getVersion();
        assertEq(version, 6);
    }

    function testFundFailsWithoutEnoughETH() public {
        vm.expectRevert();
        fundMe.fund();
    }

    function testFundUpdatesFundedDataStructure() public {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();

        uint256 amountFunded = fundMe.getAddressToAmountFunded(USER);
        assertEq(amountFunded, SEND_VALUE);
    }

    function testAddsFunderToArrayOfFunders() public {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();

        address funder = fundMe.getFunder(0);
        assertEq(funder, USER);
    }

    modifier funded {
        vm.prank(USER);
        fundMe.fund{value: SEND_VALUE}();
        _;
    }

    function testOnlyOwnerCanWithdraw() public funded {
        
        vm.prank(USER);
        vm.expectRevert();
        fundMe.withdraw();
    }

    function testWithdrawWithASingleFunder() public funded {
        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;

        vm.prank(fundMe.getOwner());
        fundMe.withdraw();

        uint256 endingOwnerBalance = fundMe.getOwner().balance;
        uint256 endingFundMeBalance = address(fundMe).balance;
        assertEq(endingFundMeBalance, 0);
        assertEq(startingOwnerBalance + startingFundMeBalance, endingOwnerBalance);
    }

    function testWithdrawFromMultipleFunders() public funded {
        //Arrange
        uint160 numberofFunders = 10;
        uint160 startingFundingIndex = 1;
        for(uint160 i = startingFundingIndex; i< numberofFunders; i++){

            hoax(address(i), STARTING_USER_BALANCE);
            fundMe.fund{value: SEND_VALUE}();
        }
        uint256 startingOwnerBalance = fundMe.getOwner().balance;
        uint256 startingFundMeBalance = address(fundMe).balance;
        //Act
        vm.startPrank(fundMe.getOwner());
        fundMe.withdraw;
        vm.stopPrank();

        //Assert
        assert(address(fundMe).balance == 0);
        assertEq(startingFundMeBalance + startingOwnerBalance, fundMe.getOwner().balance);
    }

}   

[sumit03guha]

fundMe.withdraw; -> fundMe.withdraw();
missing parenthesis

[ardur77]

@sumit03guha thanks a bunch man, that's just silly on my part but highly appreciated. It now runs perfectly.

[EngrPips]

Great heads-up here.