1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

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

import {Love} from "../src/Love.sol";
import {Test} from "forge-std/Test.sol";

contract LoveTest is Test {
    Love public love;

    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    event LoveSent(address indexed from, address indexed to, uint256 amount);

    function setUp() public {
        love = new Love();
    }

    function test_Send() public {
        vm.prank(alice);
        love.send(bob, 1);

        assertEq(love.sent(alice, bob), 1);
        assertEq(love.received(bob), 1);
    }

    function test_SendAccumulates() public {
        vm.startPrank(alice);
        love.send(bob, 2);
        love.send(bob, 3);
        vm.stopPrank();

        assertEq(love.sent(alice, bob), 5);
        assertEq(love.received(bob), 5);
    }

    function test_SendEmitsEvent() public {
        vm.expectEmit(true, true, false, true);
        emit LoveSent(alice, bob, 7);

        vm.prank(alice);
        love.send(bob, 7);
    }

    function test_RevertWhen_SendingToSelf() public {
        vm.prank(alice);
        vm.expectRevert(Love.SelfLove.selector);
        love.send(alice, 1);
    }

    function test_RevertWhen_AmountIsZero() public {
        vm.prank(alice);
        vm.expectRevert(Love.ZeroAmount.selector);
        love.send(bob, 0);
    }

    function testFuzz_Send(address from, address to, uint256 amount) public {
        vm.assume(from != to);
        amount = bound(amount, 1, type(uint256).max);

        vm.prank(from);
        love.send(to, amount);

        assertEq(love.sent(from, to), amount);
        assertEq(love.received(to), amount);
    }
}