@bananapus/core-v6 0.0.1

package/test/units/static/JBRulesets/TestUpcomingRulesetOf.sol

@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBRulesetsSetup} from "./JBRulesetsSetup.sol";
+
+contract TestUpcomingOf_Local is JBRulesetsSetup {
+    // Necessary params
+    JBRulesetMetadata private _metadata;
+    JBRulesetMetadata private _metadataWithApprovalHook;
+    IJBRulesetApprovalHook private _mockApprovalHook = IJBRulesetApprovalHook(makeAddr("hook"));
+    uint256 _packedMetadata;
+    uint256 _packedWithApprovalHook;
+    uint256 _projectId = 1;
+    uint256 _duration = 3 days;
+    uint256 _weight = 0;
+    uint256 _weightCutPercent = 450_000_000;
+    uint48 _mustStartAt = 0;
+    uint256 _hookDuration = 1 days;
+    IJBRulesetApprovalHook private _noHook = IJBRulesetApprovalHook(address(0));
+
+    function setUp() public {
+        super.rulesetsSetup();
+
+        // Params for tests
+        _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        // Params for tests
+        _metadataWithApprovalHook = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+        _packedWithApprovalHook = JBRulesetMetadataResolver.packRulesetMetadata(_metadataWithApprovalHook);
+    }
+
+    function test_WhenLatestRulesetIdEQZero() external view {
+        // it will return an empty ruleset
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, 0);
+    }
+
+    modifier whenUpcomingRulesetIdDNEQZero() {
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // mock call to hook duration
+        mockExpect(
+            address(_mockApprovalHook), abi.encodeCall(IJBRulesetApprovalHook.DURATION, ()), abi.encode(_hookDuration)
+        );
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp + 1,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+        _;
+    }
+
+    function test_GivenStatusEQApprovedOrApprovalExpectedOrEmpty() external whenUpcomingRulesetIdDNEQZero {
+        // it will return that ruleset
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.ApprovalExpected)
+        );
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, block.timestamp + 1); // timestamp + 1 = second queued, since the preceeding ruleset is
+        // in
+    }
+
+    function test_GivenStatusDNEQApprovedOrApprovalExpectedOrEmpty() external whenUpcomingRulesetIdDNEQZero {
+        // it will return the ruleset upcoming was based on
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.Active)
+        );
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, block.timestamp); // first queued, since the preceeding ruleset approval hook is still
+        // "Active"
+    }
+
+    function test_GivenTheLatestRulesetStartsInTheFuture() external {
+        // it will return the ruleset that latestRuleset is based on, which is zero in this case, which defaults to an
+        // approval status of "Empty"
+
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp + 10 days, // starts in the future
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: uint48(block.timestamp + 10 days)
+        });
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, block.timestamp);
+    }
+
+    function test_WhenLatestRulesetHasDurationEqZero() external {
+        // it will return an empty ruleset
+
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            0, // duration zero
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: 0,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        // mock call to hook duration
+        mockExpect(
+            address(_mockApprovalHook), abi.encodeCall(IJBRulesetApprovalHook.DURATION, ()), abi.encode(_hookDuration)
+        );
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp + 1, // incremented by one since queued in the same block and we cant have duplicate ids
+            _projectId,
+            0, // duration zero
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp + 10 days,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: 0,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: uint48(block.timestamp + 10 days)
+        });
+
+        vm.warp(block.timestamp + 11 days);
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, 0);
+    }
+
+    function test_GivenApprovalStatusIsApprovedOrEmpty() external whenUpcomingRulesetIdDNEQZero {
+        // it will return a simulatedCycledRulesetBasedOn
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.Approved)
+        );
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, block.timestamp + 1); // timestamp + 1 = second queued
+    }
+
+    function test_GivenTheRulesetsApprovalFailedAndItsBasedOnDurationDNEQZero() external whenUpcomingRulesetIdDNEQZero {
+        // it will return the simulatedCycledRulesetBasedOn it was based on
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.Failed)
+        );
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, block.timestamp); // first timestamp = first queued
+    }
+
+    // duplicate covered above in a single case
+    function test_GivenTheRulesetsApprovalFailedAndItsBasedOnDurationEQZero() external {
+        // it will return an empty ruleset
+
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            0, // duration zero
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: 0,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        // mock call to hook duration
+        mockExpect(
+            address(_mockApprovalHook), abi.encodeCall(IJBRulesetApprovalHook.DURATION, ()), abi.encode(_hookDuration)
+        );
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp + 1, // incremented by one since queued in the same block and we cant have duplicate ids
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp + 10 days,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: uint48(block.timestamp + 10 days)
+        });
+
+        // it will return the simulatedCycledRulesetBasedOn it was based on
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.ApprovalExpected)
+        );
+
+        vm.warp(block.timestamp + 11 days);
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, 0);
+    }
+
+    // Not sure how to reach the last line of this function..
+    function test_baseRulesetDurationDNEQZero() external {
+        // it will simulate a ruleset basedOn
+
+        uint256 ogTimestamp = block.timestamp;
+
+        // put code at hook address
+        vm.etch(address(_mockApprovalHook), abi.encode(1));
+
+        // mock call to hook interface support
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IERC165.supportsInterface, (type(IJBRulesetApprovalHook).interfaceId)),
+            abi.encode(true)
+        );
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _mockApprovalHook,
+            _packedWithApprovalHook,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        // mock call to hook duration
+        mockExpect(
+            address(_mockApprovalHook), abi.encodeCall(IJBRulesetApprovalHook.DURATION, ()), abi.encode(_hookDuration)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _mockApprovalHook,
+            metadata: _packedWithApprovalHook,
+            mustStartAtOrAfter: 0
+        });
+
+        vm.warp(block.timestamp + 3 days);
+
+        uint256 _latestQueuedId = _rulesets.latestRulesetIdOf(_projectId);
+        JBRuleset memory _queuedRuleset = _rulesets.getRulesetOf(_projectId, _latestQueuedId);
+
+        // mock call to hook approvalStatusOf
+        mockExpect(
+            address(_mockApprovalHook),
+            abi.encodeCall(IJBRulesetApprovalHook.approvalStatusOf, (_projectId, _queuedRuleset)),
+            abi.encode(JBApprovalStatus.Failed)
+        );
+
+        JBRuleset memory _upcoming = _rulesets.upcomingOf(_projectId);
+        assertEq(_upcoming.id, ogTimestamp); // original id
+    }
+}

package/test/units/static/JBRulesets/TestUpdateRulesetWeightCache.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+import {JBRulesetsSetup} from "./JBRulesetsSetup.sol";
+
+contract TestUpdateRulesetWeightCache_Local is JBRulesetsSetup {
+    // Necessary params
+    JBRulesetMetadata private _metadata;
+    uint256 _packedMetadata;
+    uint256 _projectId = 1;
+    uint256 _duration = 3 days;
+    uint256 _weight = 0;
+    uint256 _weightCutPercent = 450_000_000;
+    uint48 _mustStartAt = 0;
+    uint256 _hookDuration = 1 days;
+    IJBRulesetApprovalHook private _noHook = IJBRulesetApprovalHook(address(0));
+
+    function setUp() public {
+        super.rulesetsSetup();
+
+        // Params for tests
+        _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        _packedMetadata = JBRulesetMetadataResolver.packRulesetMetadata(_metadata);
+    }
+
+    function test_WhenLatestRulesetOfProjectDurationOrWeightCutPercentEQZero() external {
+        // it will return without updating
+
+        _rulesets.updateRulesetWeightCache(_projectId);
+    }
+
+    function test_WhenLatestRulesetHasProperDurationAndWeightCutPercent() external {
+        // it will store a new derivedWeightFrom and weightCutMultiple in storage
+
+        // Setup: queueFor will call onlyControllerOf modifier -> Directory.controllerOf to see if caller has proper
+        // permissions, encode & mock that.
+        bytes memory _encodedCall = abi.encodeCall(IJBDirectory.controllerOf, (1));
+        bytes memory _willReturn = abi.encode(address(this));
+
+        mockExpect(address(directory), _encodedCall, _willReturn);
+
+        // Setup: expect ruleset event (RulesetQueued) is emitted
+        vm.expectEmit();
+        emit IJBRulesets.RulesetQueued(
+            block.timestamp,
+            _projectId,
+            _duration,
+            _weight,
+            _weightCutPercent,
+            _noHook,
+            _packedMetadata,
+            block.timestamp,
+            address(this)
+        );
+
+        // Send: Call from this contract as it's been mock authorized above.
+        _rulesets.queueFor({
+            projectId: _projectId,
+            duration: _duration,
+            weight: _weight,
+            weightCutPercent: _weightCutPercent,
+            approvalHook: _noHook,
+            metadata: _packedMetadata,
+            mustStartAtOrAfter: _mustStartAt
+        });
+
+        _rulesets.updateRulesetWeightCache(_projectId);
+    }
+}

package/test/units/static/JBSplits/JBSplitsSetup.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import /* {*} from */ "../../../helpers/TestBaseWorkflow.sol";
+
+/*
+Contract that deploys a target contract with other mock contracts to satisfy the constructor.
+Tests relative to this contract will be dependent on mock calls/emits and stdStorage.
+*/
+contract JBSplitsSetup is JBTest {
+    address _owner = makeAddr("owner");
+
+    // Mocks
+    IJBDirectory public directory = IJBDirectory(makeAddr("directory"));
+
+    // Target Contract
+    IJBSplits public _splits;
+
+    function splitsSetup() public virtual {
+        // Instantiate the contract being tested
+        _splits = new JBSplits(directory);
+    }
+}