Skip to content

Commit

Permalink
fix: rm legacy bPool tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@wei3erHase
wei3erHase committed Jul 22, 2024
1 parent 0231fc7 commit f1b7abc
Showing 1 changed file with 0 additions and 384 deletions.
384 changes: 0 additions & 384 deletions test/unit/BPool.t.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -358,254 +358,6 @@ abstract contract SwapExactAmountInUtils is BasePoolTest {
}
}

contract BPool_Unit_GetCurrentTokens is BasePoolTest {
function test_Returns_CurrentTokens(uint256 _length) public {
vm.assume(_length > 0);
vm.assume(_length <= MAX_BOUND_TOKENS);
address[] memory _tokensToAdd = _setRandomTokens(_length);

assertEq(bPool.getCurrentTokens(), _tokensToAdd);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getCurrentTokens();
}
}

contract BPool_Unit_GetFinalTokens is BasePoolTest {
function test_Returns_FinalTokens(uint256 _length) public {
vm.assume(_length > 0);
vm.assume(_length <= MAX_BOUND_TOKENS);
address[] memory _tokensToAdd = _setRandomTokens(_length);
_setFinalize(true);

assertEq(bPool.getFinalTokens(), _tokensToAdd);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getFinalTokens();
}

function test_Revert_NotFinalized(uint256 _length) public {
vm.assume(_length > 0);
vm.assume(_length <= MAX_BOUND_TOKENS);
_setRandomTokens(_length);
_setFinalize(false);

vm.expectRevert(IBPool.BPool_PoolNotFinalized.selector);
bPool.getFinalTokens();
}
}

contract BPool_Unit_GetDenormalizedWeight is BasePoolTest {
function test_Returns_DenormalizedWeight(address _token, uint256 _weight) public {
bPool.set__records(_token, IBPool.Record({bound: true, index: 0, denorm: _weight}));

assertEq(bPool.getDenormalizedWeight(_token), _weight);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getDenormalizedWeight(address(0));
}

function test_Revert_NotBound(address _token) public {
vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getDenormalizedWeight(_token);
}
}

contract BPool_Unit_GetTotalDenormalizedWeight is BasePoolTest {
function test_Returns_TotalDenormalizedWeight(uint256 _totalWeight) public {
_setTotalWeight(_totalWeight);

assertEq(bPool.getTotalDenormalizedWeight(), _totalWeight);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getTotalDenormalizedWeight();
}
}

contract BPool_Unit_GetNormalizedWeight is BasePoolTest {
function test_Returns_NormalizedWeight(address _token, uint256 _weight, uint256 _totalWeight) public {
_weight = bound(_weight, MIN_WEIGHT, MAX_WEIGHT);
_totalWeight = bound(_totalWeight, MIN_WEIGHT, MAX_TOTAL_WEIGHT);
vm.assume(_weight < _totalWeight);
_setRecord(_token, IBPool.Record({bound: true, index: 0, denorm: _weight}));
_setTotalWeight(_totalWeight);

assertEq(bPool.getNormalizedWeight(_token), bdiv(_weight, _totalWeight));
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getNormalizedWeight(address(0));
}

function test_Revert_NotBound(address _token) public {
vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getNormalizedWeight(_token);
}
}

contract BPool_Unit_GetBalance is BasePoolTest {
function test_Returns_Balance(address _token, uint256 _balance) public {
assumeNotForgeAddress(_token);

bPool.set__records(_token, IBPool.Record({bound: true, index: 0, denorm: 0}));
_mockPoolBalance(_token, _balance);

assertEq(bPool.getBalance(_token), _balance);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getBalance(address(0));
}

function test_Revert_NotBound(address _token) public {
vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getBalance(_token);
}
}

contract BPool_Unit_GetSwapFee is BasePoolTest {
function test_Returns_SwapFee(uint256 _swapFee) public {
_setSwapFee(_swapFee);

assertEq(bPool.getSwapFee(), _swapFee);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getSwapFee();
}
}

contract BPool_Unit_GetController is BasePoolTest {
function test_Returns_Controller(address _controller) public {
bPool.set__controller(_controller);

assertEq(bPool.getController(), _controller);
}

function test_Revert_Reentrancy() public {
_expectRevertByReentrancy();
bPool.getController();
}
}

contract BPool_Unit_SetSwapFee is BasePoolTest {
modifier happyPath(uint256 _fee) {
vm.assume(_fee >= MIN_FEE);
vm.assume(_fee <= MAX_FEE);
_;
}

function test_Revert_Finalized(uint256 _fee) public happyPath(_fee) {
_setFinalize(true);

vm.expectRevert(IBPool.BPool_PoolIsFinalized.selector);
bPool.setSwapFee(_fee);
}

function test_Revert_NotController(address _controller, address _caller, uint256 _fee) public happyPath(_fee) {
vm.assume(_controller != _caller);
bPool.set__controller(_controller);

vm.expectRevert(IBPool.BPool_CallerIsNotController.selector);
vm.prank(_caller);
bPool.setSwapFee(_fee);
}

function test_Revert_MinFee(uint256 _fee) public {
vm.assume(_fee < MIN_FEE);

vm.expectRevert(IBPool.BPool_FeeBelowMinimum.selector);
bPool.setSwapFee(_fee);
}

function test_Revert_MaxFee(uint256 _fee) public {
vm.assume(_fee > MAX_FEE);

vm.expectRevert(IBPool.BPool_FeeAboveMaximum.selector);
bPool.setSwapFee(_fee);
}

function test_Revert_Reentrancy(uint256 _fee) public happyPath(_fee) {
_expectRevertByReentrancy();
bPool.setSwapFee(_fee);
}

function test_Set_SwapFee(uint256 _fee) public happyPath(_fee) {
bPool.setSwapFee(_fee);

assertEq(bPool.call__swapFee(), _fee);
}

function test_Set_ReentrancyLock(uint256 _fee) public happyPath(_fee) {
_expectSetReentrancyLock();
bPool.setSwapFee(_fee);
}

function test_Emit_LogCall(uint256 _fee) public happyPath(_fee) {
vm.expectEmit();
bytes memory _data = abi.encodeWithSelector(BPool.setSwapFee.selector, _fee);
emit IBPool.LOG_CALL(BPool.setSwapFee.selector, address(this), _data);

bPool.setSwapFee(_fee);
}
}

contract BPool_Unit_SetController is BasePoolTest {
function test_Revert_NotController(address _controller, address _caller, address _newController) public {
vm.assume(_newController != address(0));
vm.assume(_controller != _caller);
bPool.set__controller(_controller);

vm.expectRevert(IBPool.BPool_CallerIsNotController.selector);
vm.prank(_caller);
bPool.setController(_newController);
}

function test_Revert_Reentrancy(address _controller) public {
_expectRevertByReentrancy();
bPool.setController(_controller);
}

function test_Revert_AddressZero() public {
vm.expectRevert(IBPool.BPool_AddressZero.selector);

bPool.setController(address(0));
}

function test_Set_Controller(address _controller) public {
vm.assume(_controller != address(0));
bPool.setController(_controller);

assertEq(bPool.call__controller(), _controller);
}

function test_Emit_LogCall(address _controller) public {
vm.assume(_controller != address(0));
vm.expectEmit();
bytes memory _data = abi.encodeWithSelector(BPool.setController.selector, _controller);
emit IBPool.LOG_CALL(BPool.setController.selector, address(this), _data);

bPool.setController(_controller);
}

function test_Set_ReentrancyLock(address _controller) public {
vm.assume(_controller != address(0));
_expectSetReentrancyLock();
bPool.setController(_controller);
}
}

contract BPool_Unit_Finalize is BasePoolTest {
modifier happyPath(uint256 _tokensLength) {
_tokensLength = bound(_tokensLength, MIN_BOUND_TOKENS, MAX_BOUND_TOKENS);
Expand Down Expand Up @@ -683,142 +435,6 @@ contract BPool_Unit_Finalize is BasePoolTest {
}
}

contract BPool_Unit_GetSpotPrice is BasePoolTest {
struct GetSpotPrice_FuzzScenario {
address tokenIn;
address tokenOut;
uint256 tokenInBalance;
uint256 tokenInDenorm;
uint256 tokenOutBalance;
uint256 tokenOutDenorm;
uint256 swapFee;
}

function _setValues(GetSpotPrice_FuzzScenario memory _fuzz) internal {
_setRecord(_fuzz.tokenIn, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenInDenorm}));
_mockPoolBalance(_fuzz.tokenIn, _fuzz.tokenInBalance);
_setRecord(_fuzz.tokenOut, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenOutDenorm}));
_mockPoolBalance(_fuzz.tokenOut, _fuzz.tokenOutBalance);
_setSwapFee(_fuzz.swapFee);
}

function _assumeHappyPath(GetSpotPrice_FuzzScenario memory _fuzz) internal pure {
assumeNotForgeAddress(_fuzz.tokenIn);
assumeNotForgeAddress(_fuzz.tokenOut);
vm.assume(_fuzz.tokenIn != _fuzz.tokenOut);
_assumeCalcSpotPrice(
_fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.swapFee
);
}

modifier happyPath(GetSpotPrice_FuzzScenario memory _fuzz) {
_assumeHappyPath(_fuzz);
_setValues(_fuzz);
_;
}

function test_Revert_NotBoundTokenIn(
GetSpotPrice_FuzzScenario memory _fuzz,
address _tokenIn
) public happyPath(_fuzz) {
vm.assume(_tokenIn != _fuzz.tokenIn);
vm.assume(_tokenIn != _fuzz.tokenOut);

vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getSpotPrice(_tokenIn, _fuzz.tokenOut);
}

function test_Revert_NotBoundTokenOut(
GetSpotPrice_FuzzScenario memory _fuzz,
address _tokenOut
) public happyPath(_fuzz) {
vm.assume(_tokenOut != _fuzz.tokenIn);
vm.assume(_tokenOut != _fuzz.tokenOut);

vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getSpotPrice(_fuzz.tokenIn, _tokenOut);
}

function test_Returns_SpotPrice(GetSpotPrice_FuzzScenario memory _fuzz) public happyPath(_fuzz) {
uint256 _expectedSpotPrice = calcSpotPrice(
_fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.swapFee
);
uint256 _spotPrice = bPool.getSpotPrice(_fuzz.tokenIn, _fuzz.tokenOut);
assertEq(_spotPrice, _expectedSpotPrice);
}

function test_Revert_Reentrancy(GetSpotPrice_FuzzScenario memory _fuzz) public happyPath(_fuzz) {
_expectRevertByReentrancy();
bPool.getSpotPrice(_fuzz.tokenIn, _fuzz.tokenOut);
}
}

contract BPool_Unit_GetSpotPriceSansFee is BasePoolTest {
struct GetSpotPriceSansFee_FuzzScenario {
address tokenIn;
address tokenOut;
uint256 tokenInBalance;
uint256 tokenInDenorm;
uint256 tokenOutBalance;
uint256 tokenOutDenorm;
}

function _setValues(GetSpotPriceSansFee_FuzzScenario memory _fuzz) internal {
_setRecord(_fuzz.tokenIn, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenInDenorm}));
_mockPoolBalance(_fuzz.tokenIn, _fuzz.tokenInBalance);
_setRecord(_fuzz.tokenOut, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenOutDenorm}));
_mockPoolBalance(_fuzz.tokenOut, _fuzz.tokenOutBalance);
_setSwapFee(0);
}

function _assumeHappyPath(GetSpotPriceSansFee_FuzzScenario memory _fuzz) internal pure {
assumeNotForgeAddress(_fuzz.tokenIn);
assumeNotForgeAddress(_fuzz.tokenOut);
vm.assume(_fuzz.tokenIn != _fuzz.tokenOut);
_assumeCalcSpotPrice(_fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, 0);
}

modifier happyPath(GetSpotPriceSansFee_FuzzScenario memory _fuzz) {
_assumeHappyPath(_fuzz);
_setValues(_fuzz);
_;
}

function test_Revert_NotBoundTokenIn(
GetSpotPriceSansFee_FuzzScenario memory _fuzz,
address _tokenIn
) public happyPath(_fuzz) {
vm.assume(_tokenIn != _fuzz.tokenIn);
vm.assume(_tokenIn != _fuzz.tokenOut);

vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getSpotPriceSansFee(_tokenIn, _fuzz.tokenOut);
}

function test_Revert_NotBoundTokenOut(
GetSpotPriceSansFee_FuzzScenario memory _fuzz,
address _tokenOut
) public happyPath(_fuzz) {
vm.assume(_tokenOut != _fuzz.tokenIn);
vm.assume(_tokenOut != _fuzz.tokenOut);

vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
bPool.getSpotPriceSansFee(_fuzz.tokenIn, _tokenOut);
}

function test_Returns_SpotPrice(GetSpotPriceSansFee_FuzzScenario memory _fuzz) public happyPath(_fuzz) {
uint256 _expectedSpotPrice =
calcSpotPrice(_fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, 0);
uint256 _spotPrice = bPool.getSpotPriceSansFee(_fuzz.tokenIn, _fuzz.tokenOut);
assertEq(_spotPrice, _expectedSpotPrice);
}

function test_Revert_Reentrancy(GetSpotPriceSansFee_FuzzScenario memory _fuzz) public happyPath(_fuzz) {
_expectRevertByReentrancy();
bPool.getSpotPriceSansFee(_fuzz.tokenIn, _fuzz.tokenOut);
}
}

contract BPool_Unit_JoinswapExternAmountIn is BasePoolTest {
address tokenIn;

Expand Down

0 comments on commit f1b7abc

Please sign in to comment.