Let's create a file called Airdrop.t.sol into /test/Erc20Airdrop and let's prepare a basic test

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Test.sol";
import { Token } from "../../contracts/Erc20/Token.sol";

contract AirdropTest is Test {
    Token token;
    uint totalSupply = 100_000;
    function setUp() public {
        // deploy ERC20 token
        token = new Token("MyToken", "MTK", totalSupply);
    }

    function test_token_deployed() public {
        assertEq(token.balanceOf(address(this)), totalSupply);
    }
}

let's run it with forge test --mc AirdropTest

forge test --mc AirdropTest

[⠒] Compiling...
[⠰] Compiling 1 files with 0.8.20
[⠔] Solc 0.8.20 finished in 1.30s
Compiler run successful!

Running 1 test for test/Erc20Airdrop/Airdrop.t.sol:AirdropTest
[FAIL. Reason: assertion failed] test_token_deployed() (gas: 24418)
Test result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 687.20µs
 
Ran 1 test suites: 0 tests passed, 1 failed, 0 skipped (1 total tests)

Failing tests:
Encountered 1 failing test in test/Erc20Airdrop/Airdrop.t.sol:AirdropTest
[FAIL. Reason: assertion failed] test_token_deployed() (gas: 24418)

Encountered a total of 1 failing tests, 0 tests succeeded

Notice how tests are failing.
That's because the totalSupply is being multiplicated by token decimals in constructor.
To fix that, simply change

assertEq(token.balanceOf(address(this)), totalSupply);

into

assertEq(token.balanceOf(address(this)), totalSupply * 10 ** token.decimals());

You can also use totalSupply*1e18 if you prefer.

Let's now test the airdrop function

function test_airdrop() public {
        uint currentBalance = token.balanceOf(address(this));
        uint accounts = 10;
        uint amountToAirdrop = 10000;
        // create a list of addresses and amounts
        address[] memory addresses = new address[](accounts);
        uint[] memory amounts = new uint[](accounts);
        
        // populate lists
        for (uint i = 0; i < accounts; i++) {
            addresses[i] = vm.addr(i+100000);
            amounts[i] = amountToAirdrop / accounts;
        }

        // make the airdrop
        token.airdrop(addresses, amounts);

        // contract should have 10000 less tokens
        assertEq(token.balanceOf(address(this)), currentBalance - amountToAirdrop);
        // each address should have 1000 tokens
        for (uint i = 0; i < accounts; i++) {
            assertEq(token.balanceOf(addresses[i]), amountToAirdrop / accounts);
        }
    }

We save the current balance of the contract, how much accounts we want to airdrop and how much tokens we want to send to each account.
We create two arrays, one for addresses and one for amounts.
We populate those arrays with a for loop.
Then we call the airdrop function.
Finally we check the balance of the contract and the balance of each address.

Let's run the test
forge test --mc AirdropTest

Running 2 tests for test/Erc20Airdrop/Airdrop.t.sol:AirdropTest
[PASS] test_airdrop() (gas: 276684)
[PASS] test_token_deployed() (gas: 11110)
Test result: ok. 2 passed; 0 failed; 0 skipped; finished in 1.32ms
 
Ran 1 test suites: 2 tests passed, 0 failed, 0 skipped (2 total tests)

Now let's prepare the script file

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/Script.sol";
import { TokenAirdrop } from "../../contracts/Erc20/TokenAirdrop.sol";

// used to configure the signer account
contract Base is Script {
    uint256 deployerPrivateKey = vm.envUint("PKEY_ACC1");
    address deployerAddress = vm.addr(deployerPrivateKey);

    modifier broadcast {
        vm.startBroadcast(deployerPrivateKey);
        _;
        vm.stopBroadcast();
    }
}

// define all the tasks of the project here
contract Tasks is Base {
    TokenAirdrop token;

    function deployToken(string memory name, string memory symbol, uint _tokenToMint) public {
        token = new TokenAirdrop(
            name,
            symbol,
            _tokenToMint
        );
    }
}

contract RunScripts is Tasks {
    function run() external broadcast {
    // deploy token
        deployToken("TokenName", "TokenSymbol", 100_000);
    }
}

Here we define:

• deployerPrivateKey as the private key of the account we want to use to deploy the contracts
• deployerAddress as the address of the account we want to use to deploy the contracts
• Tasks as the contract that will contain all the tasks we want to run
• RunScripts as the contract that will run all the tasks

Let's now run the script
forge script .\scripts\Erc20\TokenAirdrop.s.sol:RunScripts

[⠒] Compiling...
[⠊] Compiling 21 files with 0.8.23
[⠰] Solc 0.8.23 finished in 4.20s
Compiler run successful!
Script ran successfully.
Gas used: 649903

If you wish to simulate on-chain transactions pass a RPC URL.