Edistynyt testaus Foundrylla ja Hardhatilla

pragma solidity ^0.8.0;

import "forge-std/Test.sol";

contract Counter {
    uint public count;

    function increment() public {
        count++;
    }

    function decrement() public {
        require(count > 0, "Count cannot be negative");
        count--;
    }
}

contract CounterTest is Test {
    Counter public counter;

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

    function test_Increment() public {
        counter.increment();
        assertEq(counter.count(), 1, "Count should be 1 after increment");
    }

    function test_Decrement() public {
        counter.increment(); // count is 1
        counter.decrement(); // count is 0
        assertEq(counter.count(), 0, "Count should be 0 after decrement");
    }

    function testFail_DecrementZero() public {
        // This test specifically expects a revert
        counter.decrement();
    }
}

pragma solidity ^0.8.0;

import "forge-std/Test.sol";
import "forge-std/console.sol";

contract MyToken {
    mapping(address => uint) public balances;

    constructor() {
        balances[msg.sender] = 1000;
    }

    function transfer(address to, uint amount) public returns (bool) {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        balances[to] += amount;
        return true;
    }
}

contract Vault {
    MyToken public token;
    mapping(address => uint) public deposits;

    constructor(address _token) {
        token = MyToken(_token);
    }

    function deposit(uint amount) public {
        // Assume token.transferFrom or approval for real world. 
        // Simplified here for demo to show interaction.
        token.transfer(address(this), amount); 
        deposits[msg.sender] += amount;
    }

    function withdraw(uint amount) public {
        require(deposits[msg.sender] >= amount, "Insufficient deposit");
        deposits[msg.sender] -= amount;
        token.transfer(msg.sender, amount); 
    }
}

contract IntegrationTest is Test {
    MyToken public token;
    Vault public vault;

    address public ALICE = makeAddr("alice");

    function setUp() public {
        token = new MyToken();
        vault = new Vault(address(token));

        // Give ALICE some tokens for testing from initial deployer
        vm.startPrank(address(this));
        token.transfer(ALICE, 500); 
        vm.stopPrank();
    }

    function test_AliceDepositsAndWithdraws() public {
        vm.startPrank(ALICE);
        
        uint initialAliceBalance = token.balances(ALICE);
        uint depositAmount = 100;

        // Alice deposits
        token.transfer(address(vault), depositAmount); 
        vault.deposit(depositAmount); 

        assertEq(token.balances(ALICE), initialAliceBalance - depositAmount, "Alice's balance should decrease");
        assertEq(token.balances(address(vault)), depositAmount, "Vault should hold deposit amount");
        assertEq(vault.deposits(ALICE), depositAmount, "Alice's vault deposit should be recorded");

        // Alice withdraws
        vault.withdraw(depositAmount);
        assertEq(token.balances(ALICE), initialAliceBalance, "Alice's balance should be restored");
        assertEq(token.balances(address(vault)), 0, "Vault should be empty");
        assertEq(vault.deposits(ALICE), 0, "Alice's vault deposit should be zero");

        vm.stopPrank();
    }
}

pragma solidity ^0.8.0;

import "forge-std/Test.sol";

contract Calculator {
    function add(uint a, uint b) public pure returns (uint) {
        return a + b;
    }

    function subtract(uint a, uint b) public pure returns (uint) {
        require(a >= b, "Cannot subtract more than available");
        return a - b;
    }
}

contract FuzzTest is Test {
    Calculator public calculator;

    function setUp() public {
        calculator = new Calculator();
    }

    // Fuzz test for addition: check if a + b >= a (unless overflow)
    function testFuzz_Add(uint a, uint b) public {
        // Note: For real-world, use SafeMath or explicit checks for overflows.
        // This test implicitly relies on default Solidity overflow behavior.
        uint sum = calculator.add(a, b);
        // If no overflow, sum should be >= a
        if (sum < a) {
            // Overflow occurred
            assertTrue(a > type(uint).max - b, "Expected overflow");
        } else {
            assertTrue(sum >= a, "Sum should be greater than or equal to a");
        }
    }

    // Fuzz test for subtraction: ensure result is always <= a
    function testFuzz_Subtract(uint a, uint b) public {
        // Only run if a >= b to avoid expected reverts from 'require'
        vm.assume(a >= b);
        uint result = calculator.subtract(a, b);
        assertTrue(result <= a, "Result should be less than or equal to a");
    }
}