help me to solve this error "EvmError: OutOfFund" in foundry

[vishwa7dcap786]

**this is the contract **

// SPDX-Lisence-Identifier: MIT

pragma solidity 0.8.20;

import {ReentrancyGuard} from "@openzeppelin-contracts/security/ReentrancyGuard.sol";

contract sampleContract is ReentrancyGuard {
//Errors

error depositeAmount_CantBeZero();
error WithdrawAmount_CantBeZero();
error userAcount_SecretKeyIsNotCorrect();
error secretKey_AlreadyCreated();
error userAcount_UsersUnforgetableIsNotCorrect();

//Stable Variables

address[] public users;
mapping(address user => uint256 amount) private userBalance;
mapping(address user => bytes32 secretKey) private userSecretKey;
mapping(address user => bytes32 unforgetable) private theUnforgetableToResetSecretKet;

//Events

event Deposited(address user, uint256 amount, uint256 timeStamp);
event Withdrawn(address user, uint256 amount, uint256 timeStamp);

//Modifiers

modifier secretKeyChecker(string memory secretKey) {
    bytes32 sKey = userSecretKey[msg.sender];
    bytes32 sKEY = keccak256(abi.encodePacked(secretKey));

    if (sKEY != sKey) {
        revert userAcount_SecretKeyIsNotCorrect();
    }

    _;
}

modifier checkSkeyAlreadyCreated(address user) {
    bytes32 sKEY = userSecretKey[user];
    if (sKEY != 0) {
        revert secretKey_AlreadyCreated();
    }
    _;
}

modifier checkUnforgetable(string memory usersUnforgetable) {
    bytes32 sKey = theUnforgetableToResetSecretKet[msg.sender];
    bytes32 sKEY = keccak256(abi.encodePacked(usersUnforgetable));

    if (sKEY != sKey) {
        revert userAcount_UsersUnforgetableIsNotCorrect();
    }
    _;
}
//External Functions

function withdrawAmount(uint256 amountToWithdraw, string memory secretKey) external nonReentrant {
    _withdrawAmount(amountToWithdraw, secretKey);
}

function depositAmount(string memory secretKey) public payable nonReentrant secretKeyChecker(secretKey) {
    if (msg.value == 0) {
        revert depositeAmount_CantBeZero();
    }

    users.push(msg.sender);
    userBalance[msg.sender] += msg.value;
    emit Deposited(msg.sender, msg.value, block.timestamp);
}

//Private Functions

function _withdrawAmount(uint256 amountToWithdraw, string memory secretKey) private secretKeyChecker(secretKey) {
    address user = msg.sender;

    if (amountToWithdraw == 0) {
        revert WithdrawAmount_CantBeZero();
    }
    emit Withdrawn(user, amountToWithdraw, block.timestamp);

    userBalance[user] -= amountToWithdraw;
    payable(msg.sender).transfer(address(this).balance);
}

//Public and View Functions

function storeYourSecretKey(string memory secretKey, string memory yourUnforgetableForFutureKeyReset)
    public
    checkSkeyAlreadyCreated(msg.sender)
{
    userSecretKey[msg.sender] = keccak256(abi.encodePacked(secretKey));
    theUnforgetableToResetSecretKet[msg.sender] = keccak256(abi.encodePacked(yourUnforgetableForFutureKeyReset));
}

function resetSecretKey(string memory newSecretKey, string memory yourUnforgetableToResetKey)
    public
    checkUnforgetable(yourUnforgetableToResetKey)
    returns (bool)
{
    userSecretKey[msg.sender] = keccak256(abi.encodePacked(newSecretKey));
    return true;
}

function getUserBalance(address user) public view returns (uint256 balance) {
    balance = userBalance[user];
    return balance;
}

function getNoOfUser() public view returns (uint256) {
    return users.length;
}

function getTotalAmountInContract() public view returns (uint256) {
    uint256 totalBalance;
    for (uint256 i = 0; i < users.length; i++) {
        totalBalance += userBalance[users[i]];
    }
    return totalBalance;
}

}

this is the unit test
// SPDX-Lisence-Identifier

pragma solidity 0.8.20;

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

contract sampleTest is Test {
DeploySample Deployer;
sampleContract sample;
address public constant USER = address(3);

function setUp() public {
    Deployer = new DeploySample();
    (sample) = Deployer.run();
}

function testdeposit() public {
    vm.startPrank(USER);
    console.log(address(USER).balance);
    sample.storeYourSecretKey("secret", "abcd");
    (bool success, bytes memory data) =
        address(sample).call{value: 1, gas: 2000000}(abi.encodeWithSignature("depositAmount(string)", "secret"));
    vm.stopPrank();

    assertEq(sample.getUserBalance(USER), 1);
}

}

---

error
Running 1 test for test/sampleTest.sol:sampleTest
[FAIL. Reason: Assertion failed.] testdeposit() (gas: 80402)
Logs:
0
Error: a == b not satisfied [uint]
Left: 0
Right: 1

Traces:
[1208181] sampleTest::setUp()
├─ [610263] → new DeploySample@0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f
│ └─ ← 2827 bytes of code
├─ [520373] DeploySample::run()
│ ├─ [0] VM::startBroadcast()
│ │ └─ ← ()
│ ├─ [484405] → new sampleContract@0x90193C961A926261B756D1E5bb255e67ff9498A1
│ │ └─ ← 2309 bytes of code
│ ├─ [0] VM::stopBroadcast()
│ │ └─ ← ()
│ └─ ← sampleContract: [0x90193C961A926261B756D1E5bb255e67ff9498A1]
└─ ← ()

[80402] sampleTest::testdeposit()
├─ [0] VM::startPrank(0x0000000000000000000000000000000000000003)
│ └─ ← ()
├─ [0] console::f5b1bba9(0000000000000000000000000000000000000000000000000000000000000000) [staticcall]
│ └─ ← ()
├─ [46057] sampleContract::storeYourSecretKey(secret, abcd)
│ └─ ← ()
├─ [0] sampleContract::depositAmount{value: 1}(secret)
│ └─ ← "EvmError: OutOfFund"
├─ [0] VM::stopPrank()
│ └─ ← ()
├─ [2569] sampleContract::getUserBalance(0x0000000000000000000000000000000000000003) [staticcall]
│ └─ ← 0
├─ emit log(: Error: a == b not satisfied [uint])
├─ emit log_named_uint(key: Left, val: 0)
├─ emit log_named_uint(key: Right, val: 1)
├─ [0] VM::store(VM: [0x7109709ECfa91a80626fF3989D68f67F5b1DD12D], 0x6661696c65640000000000000000000000000000000000000000000000000000, 0x0000000000000000000000000000000000000000000000000000000000000001)
│ └─ ← ()
└─ ← ()

Test result: FAILED. 0 passed; 1 failed; finished in 5.28ms

Failing tests:
Encountered 1 failing test in test/sampleTest.sol:sampleTest
[FAIL. Reason: Assertion failed.] testdeposit() (gas: 80402)

Encountered a total of 1 failing tests, 0 tests succeeded

i have tried to log the balance of the USER address . it logs out as zero amount.

how to solve this issue

[theirrationalone]

Actually we need some initial USER balance as we need an USER for transactions to sign & send...

Cheatcode: vm.deal(USER, 1 ether)

• where USER is an address

Try this:

function setUp() public {
    Deployer = new DeploySample();
    (sample) = Deployer.run();
    vm.deal(USER, balance);    // balance: 1 ether Or 1000000000000000000
}