diff --git a/test/unit/BCoWPool.t.sol b/test/unit/BCoWPool.t.sol
index 7c7e566c..0a73ea41 100644
--- a/test/unit/BCoWPool.t.sol
+++ b/test/unit/BCoWPool.t.sol
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.25;
 
-import {BasePoolTest, SwapExactAmountInUtils} from './BPool.t.sol';
+import {BasePoolTest} from './BPool.t.sol';
 import {IERC20} from '@cowprotocol/interfaces/IERC20.sol';
 import {GPv2Order} from '@cowprotocol/libraries/GPv2Order.sol';
 import {IERC1271} from '@openzeppelin/contracts/interfaces/IERC1271.sol';
@@ -142,147 +142,6 @@ contract BCoWPool_Unit_Commit is BaseCoWPoolTest {
   }
 }
 
-contract BCoWPool_Unit_Verify is BaseCoWPoolTest, SwapExactAmountInUtils {
-  function setUp() public virtual override(BaseCoWPoolTest, BasePoolTest) {
-    BaseCoWPoolTest.setUp();
-  }
-
-  function _assumeHappyPath(SwapExactAmountIn_FuzzScenario memory _fuzz) internal pure override {
-    // safe bound assumptions
-    _fuzz.tokenInDenorm = bound(_fuzz.tokenInDenorm, MIN_WEIGHT, MAX_WEIGHT);
-    _fuzz.tokenOutDenorm = bound(_fuzz.tokenOutDenorm, MIN_WEIGHT, MAX_WEIGHT);
-    // LP fee when swapping via CoW will always be zero
-    _fuzz.swapFee = 0;
-
-    // min - max - calcSpotPrice (spotPriceBefore)
-    _fuzz.tokenInBalance = bound(_fuzz.tokenInBalance, MIN_BALANCE, type(uint256).max / _fuzz.tokenInDenorm);
-    _fuzz.tokenOutBalance = bound(_fuzz.tokenOutBalance, MIN_BALANCE, type(uint256).max / _fuzz.tokenOutDenorm);
-
-    // MAX_IN_RATIO
-    vm.assume(_fuzz.tokenAmountIn <= bmul(_fuzz.tokenInBalance, MAX_IN_RATIO));
-
-    _assumeCalcOutGivenIn(_fuzz.tokenInBalance, _fuzz.tokenAmountIn, _fuzz.swapFee);
-    uint256 _tokenAmountOut = calcOutGivenIn(
-      _fuzz.tokenInBalance,
-      _fuzz.tokenInDenorm,
-      _fuzz.tokenOutBalance,
-      _fuzz.tokenOutDenorm,
-      _fuzz.tokenAmountIn,
-      _fuzz.swapFee
-    );
-    vm.assume(_tokenAmountOut > BONE);
-  }
-
-  modifier assumeNotBoundToken(address _token) {
-    for (uint256 i = 0; i < TOKENS_AMOUNT; i++) {
-      vm.assume(tokens[i] != _token);
-    }
-    _;
-  }
-
-  function test_Revert_NonBoundBuyToken(address _otherToken) public assumeNotBoundToken(_otherToken) {
-    GPv2Order.Data memory order = correctOrder;
-    order.buyToken = IERC20(_otherToken);
-    vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_NonBoundSellToken(address _otherToken) public assumeNotBoundToken(_otherToken) {
-    GPv2Order.Data memory order = correctOrder;
-    order.sellToken = IERC20(_otherToken);
-    vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_ReceiverIsNotBCoWPool(address _receiver) public {
-    vm.assume(_receiver != GPv2Order.RECEIVER_SAME_AS_OWNER);
-    GPv2Order.Data memory order = correctOrder;
-    order.receiver = _receiver;
-    vm.expectRevert(IBCoWPool.BCoWPool_ReceiverIsNotBCoWPool.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_LargeDurationOrder(uint256 _timeOffset) public {
-    _timeOffset = bound(_timeOffset, MAX_ORDER_DURATION + 1, type(uint32).max - block.timestamp);
-    GPv2Order.Data memory order = correctOrder;
-    order.validTo = uint32(block.timestamp + _timeOffset);
-    vm.expectRevert(IBCoWPool.BCoWPool_OrderValidityTooLong.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_NonZeroFee(uint256 _fee) public {
-    _fee = bound(_fee, 1, type(uint256).max);
-    GPv2Order.Data memory order = correctOrder;
-    order.feeAmount = _fee;
-    vm.expectRevert(IBCoWPool.BCoWPool_FeeMustBeZero.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_InvalidOrderKind(bytes32 _orderKind) public {
-    vm.assume(_orderKind != GPv2Order.KIND_SELL);
-    GPv2Order.Data memory order = correctOrder;
-    order.kind = _orderKind;
-    vm.expectRevert(IBCoWPool.BCoWPool_InvalidOperation.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_InvalidBuyBalanceKind(bytes32 _balanceKind) public {
-    vm.assume(_balanceKind != GPv2Order.BALANCE_ERC20);
-    GPv2Order.Data memory order = correctOrder;
-    order.buyTokenBalance = _balanceKind;
-    vm.expectRevert(IBCoWPool.BCoWPool_InvalidBalanceMarker.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_InvalidSellBalanceKind(bytes32 _balanceKind) public {
-    vm.assume(_balanceKind != GPv2Order.BALANCE_ERC20);
-    GPv2Order.Data memory order = correctOrder;
-    order.sellTokenBalance = _balanceKind;
-    vm.expectRevert(IBCoWPool.BCoWPool_InvalidBalanceMarker.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_TokenAmountInAboveMaxIn(
-    SwapExactAmountIn_FuzzScenario memory _fuzz,
-    uint256 _offset
-  ) public happyPath(_fuzz) {
-    _offset = bound(_offset, 1, type(uint256).max - _fuzz.tokenInBalance);
-    uint256 _tokenAmountIn = bmul(_fuzz.tokenInBalance, MAX_IN_RATIO) + _offset;
-    GPv2Order.Data memory order = correctOrder;
-    order.buyAmount = _tokenAmountIn;
-
-    vm.expectRevert(IBPool.BPool_TokenAmountInAboveMaxRatio.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Revert_InsufficientReturn(
-    SwapExactAmountIn_FuzzScenario memory _fuzz,
-    uint256 _offset
-  ) public happyPath(_fuzz) {
-    uint256 _tokenAmountOut = calcOutGivenIn(
-      _fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.tokenAmountIn, 0
-    );
-    _offset = bound(_offset, 1, _tokenAmountOut);
-    GPv2Order.Data memory order = correctOrder;
-    order.buyAmount = _fuzz.tokenAmountIn;
-    order.sellAmount = _tokenAmountOut + _offset;
-
-    vm.expectRevert(IBPool.BPool_TokenAmountOutBelowMinOut.selector);
-    bCoWPool.verify(order);
-  }
-
-  function test_Success_HappyPath(SwapExactAmountIn_FuzzScenario memory _fuzz) public happyPath(_fuzz) {
-    uint256 _tokenAmountOut = calcOutGivenIn(
-      _fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.tokenAmountIn, 0
-    );
-    GPv2Order.Data memory order = correctOrder;
-    order.buyAmount = _fuzz.tokenAmountIn;
-    order.sellAmount = _tokenAmountOut;
-
-    bCoWPool.verify(order);
-  }
-}
-
 contract BCoWPool_Unit_IsValidSignature is BaseCoWPoolTest {
   function setUp() public virtual override {
     super.setUp();
diff --git a/test/unit/BCoWPool/BCoWPoolBase.t.sol b/test/unit/BCoWPool/BCoWPoolBase.t.sol
new file mode 100644
index 00000000..3418e59e
--- /dev/null
+++ b/test/unit/BCoWPool/BCoWPoolBase.t.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {BPoolBase} from '../BPool/BPoolBase.sol';
+import {BCoWConst} from 'contracts/BCoWConst.sol';
+import {BNum} from 'contracts/BNum.sol';
+
+import {ISettlement} from 'interfaces/ISettlement.sol';
+import {MockBCoWPool} from 'test/manual-smock/MockBCoWPool.sol';
+
+contract BCoWPoolBase is BPoolBase, BCoWConst, BNum {
+  bytes32 public appData = bytes32('appData');
+  address public cowSolutionSettler = makeAddr('cowSolutionSettler');
+  bytes32 public domainSeparator = bytes32(bytes2(0xf00b));
+  address public vaultRelayer = makeAddr('vaultRelayer');
+  address public tokenIn;
+  address public tokenOut;
+  MockBCoWPool bCoWPool;
+
+  function setUp() public virtual override {
+    super.setUp();
+    tokenIn = tokens[0];
+    tokenOut = tokens[1];
+    vm.mockCall(cowSolutionSettler, abi.encodePacked(ISettlement.domainSeparator.selector), abi.encode(domainSeparator));
+    vm.mockCall(cowSolutionSettler, abi.encodePacked(ISettlement.vaultRelayer.selector), abi.encode(vaultRelayer));
+    bCoWPool = new MockBCoWPool(cowSolutionSettler, appData);
+  }
+}
diff --git a/test/unit/BCoWPool/BCoWPool_Verify.t.sol b/test/unit/BCoWPool/BCoWPool_Verify.t.sol
new file mode 100644
index 00000000..3af73f50
--- /dev/null
+++ b/test/unit/BCoWPool/BCoWPool_Verify.t.sol
@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.25;
+
+import {IERC20} from '@cowprotocol/interfaces/IERC20.sol';
+import {GPv2Order} from '@cowprotocol/libraries/GPv2Order.sol';
+
+import {BCoWPoolBase} from './BCoWPoolBase.t.sol';
+import {IBCoWPool} from 'interfaces/IBCoWPool.sol';
+import {IBPool} from 'interfaces/IBPool.sol';
+
+contract BCoWPoolVerify is BCoWPoolBase {
+  // Valid scenario:
+  uint256 public tokenAmountIn = 1e18;
+  uint256 public tokenInBalance = 100e18;
+  uint256 public tokenOutBalance = 80e18;
+  // pool is expected to keep 4X the value of tokenIn than tokenOut
+  uint256 public tokenInWeight = 4e18;
+  uint256 public tokenOutWeight = 1e18;
+  // from bmath: (with fee zero) 80*(1-(100/(100+1))^(4))
+  uint256 public expectedAmountOut = 3.12157244137469736e18;
+  GPv2Order.Data validOrder;
+
+  function setUp() public virtual override {
+    super.setUp();
+    bCoWPool.set__tokens(tokens);
+    bCoWPool.set__records(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
+    bCoWPool.set__records(tokenOut, IBPool.Record({bound: true, index: 1, denorm: tokenOutWeight}));
+    vm.mockCall(tokenIn, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenInBalance)));
+    vm.mockCall(tokenOut, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenOutBalance)));
+
+    validOrder = GPv2Order.Data({
+      sellToken: IERC20(tokenOut),
+      buyToken: IERC20(tokenIn),
+      receiver: GPv2Order.RECEIVER_SAME_AS_OWNER,
+      sellAmount: expectedAmountOut,
+      buyAmount: tokenAmountIn,
+      validTo: uint32(block.timestamp + 1 minutes),
+      appData: appData,
+      feeAmount: 0,
+      kind: GPv2Order.KIND_SELL,
+      partiallyFillable: false,
+      sellTokenBalance: GPv2Order.BALANCE_ERC20,
+      buyTokenBalance: GPv2Order.BALANCE_ERC20
+    });
+  }
+
+  function test_RevertWhen_BuyTokenIsNotBound() external {
+    validOrder.buyToken = IERC20(makeAddr('unknown token'));
+    // it should revert
+    vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_SellTokenIsNotBound() external {
+    validOrder.sellToken = IERC20(makeAddr('unknown token'));
+    // it should revert
+    vm.expectRevert(IBPool.BPool_TokenNotBound.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_OrderReceiverFlagIsNotSameAsOwner() external {
+    validOrder.receiver = makeAddr('somebodyElse');
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_ReceiverIsNotBCoWPool.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_OrderValidityIsTooLong(uint256 _timeOffset) external {
+    _timeOffset = bound(_timeOffset, MAX_ORDER_DURATION + 1, type(uint32).max - block.timestamp);
+    validOrder.validTo = uint32(block.timestamp + _timeOffset);
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_OrderValidityTooLong.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_FeeAmountIsNotZero(uint256 _fee) external {
+    _fee = bound(_fee, 1, type(uint256).max);
+    validOrder.feeAmount = _fee;
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_FeeMustBeZero.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_OrderKindIsNotKIND_SELL(bytes32 _orderKind) external {
+    vm.assume(_orderKind != GPv2Order.KIND_SELL);
+    validOrder.kind = _orderKind;
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_InvalidOperation.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_BuyTokenBalanceFlagIsNotERC20Balances(bytes32 _balanceKind) external {
+    vm.assume(_balanceKind != GPv2Order.BALANCE_ERC20);
+    validOrder.buyTokenBalance = _balanceKind;
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_InvalidBalanceMarker.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_SellTokenBalanceFlagIsNotERC20Balances(bytes32 _balanceKind) external {
+    vm.assume(_balanceKind != GPv2Order.BALANCE_ERC20);
+    validOrder.sellTokenBalance = _balanceKind;
+    // it should revert
+    vm.expectRevert(IBCoWPool.BCoWPool_InvalidBalanceMarker.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_OrderBuyAmountExceedsMaxRatio(uint256 _buyAmount) external {
+    _buyAmount = bound(_buyAmount, bmul(tokenInBalance, MAX_IN_RATIO) + 1, type(uint256).max);
+    validOrder.buyAmount = _buyAmount;
+    // it should revert
+    vm.expectRevert(IBPool.BPool_TokenAmountInAboveMaxRatio.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_RevertWhen_CalculatedTokenAmountOutIsLessThanOrderSellAmount() external {
+    validOrder.sellAmount += 1;
+    // it should revert
+    vm.expectRevert(IBPool.BPool_TokenAmountOutBelowMinOut.selector);
+    bCoWPool.verify(validOrder);
+  }
+
+  function test_WhenPreconditionsAreMet(uint256 _sellAmount) external {
+    _sellAmount = bound(_sellAmount, 0, validOrder.sellAmount);
+    validOrder.sellAmount = _sellAmount;
+    // it should query the balance of the buy token
+    vm.expectCall(tokenIn, abi.encodeCall(IERC20.balanceOf, (address(bCoWPool))));
+    // it should query the balance of the sell token
+    vm.expectCall(tokenOut, abi.encodeCall(IERC20.balanceOf, (address(bCoWPool))));
+    bCoWPool.verify(validOrder);
+  }
+}
diff --git a/test/unit/BCoWPool/BCoWPool_Verify.tree b/test/unit/BCoWPool/BCoWPool_Verify.tree
new file mode 100644
index 00000000..56187a2a
--- /dev/null
+++ b/test/unit/BCoWPool/BCoWPool_Verify.tree
@@ -0,0 +1,24 @@
+BCoWPool::Verify
+├── when buyToken is not bound
+│   └── it should revert
+├── when sellToken is not bound
+│   └── it should revert
+├── when order receiver flag is not same as owner
+│   └── it should revert
+├── when order validity is too long
+│   └── it should revert
+├── when fee amount is not zero
+│   └── it should revert
+├── when order kind is not KIND_SELL
+│   └── it should revert
+├── when buy token balance flag is not ERC20 balances
+│   └── it should revert
+├── when sell token balance flag is not ERC20 balances
+│   └── it should revert
+├── when order buy amount exceeds max ratio
+│   └── it should revert
+├── when calculated token amount out is less than order sell amount
+│   └── it should revert
+└── when preconditions are met
+    ├── it should query the balance of the buy token
+    └── it should query the balance of the sell token
diff --git a/test/unit/BPool.t.sol b/test/unit/BPool.t.sol
index f9828571..7e80c886 100644
--- a/test/unit/BPool.t.sol
+++ b/test/unit/BPool.t.sol
@@ -34,9 +34,9 @@ abstract contract BasePoolTest is Test, BConst, Utils, BMath {
   function _setRandomTokens(uint256 _length) internal returns (address[] memory _tokensToAdd) {
     _tokensToAdd = _getDeterministicTokenArray(_length);
     for (uint256 i = 0; i < _length; i++) {
-      _setRecord(_tokensToAdd[i], IBPool.Record({bound: true, index: i, denorm: 0}));
+      bPool.set__records(_tokensToAdd[i], IBPool.Record({bound: true, index: i, denorm: 0}));
     }
-    _setTokens(_tokensToAdd);
+    bPool.set__tokens(_tokensToAdd);
   }
 
   function _mockTransfer(address _token) internal {
@@ -53,14 +53,6 @@ abstract contract BasePoolTest is Test, BConst, Utils, BMath {
     vm.mockCall(_token, abi.encodeWithSelector(IERC20.balanceOf.selector, address(bPool)), abi.encode(_balance));
   }
 
-  function _setTokens(address[] memory _tokens) internal {
-    bPool.set__tokens(_tokens);
-  }
-
-  function _setRecord(address _token, IBPool.Record memory _record) internal {
-    bPool.set__records(_token, _record);
-  }
-
   function _setSwapFee(uint256 _swapFee) internal {
     bPool.set__swapFee(_swapFee);
   }
@@ -253,111 +245,6 @@ abstract contract BasePoolTest is Test, BConst, Utils, BMath {
   }
 }
 
-abstract contract SwapExactAmountInUtils is BasePoolTest {
-  address tokenIn;
-  address tokenOut;
-
-  struct SwapExactAmountIn_FuzzScenario {
-    uint256 tokenAmountIn;
-    uint256 tokenInBalance;
-    uint256 tokenInDenorm;
-    uint256 tokenOutBalance;
-    uint256 tokenOutDenorm;
-    uint256 swapFee;
-  }
-
-  function _setValues(SwapExactAmountIn_FuzzScenario memory _fuzz) internal {
-    tokenIn = tokens[0];
-    tokenOut = tokens[1];
-
-    // Create mocks for tokenIn and tokenOut (only use the first 2 tokens)
-    _mockTransferFrom(tokenIn);
-    _mockTransfer(tokenOut);
-
-    // Set balances
-    _setRecord(
-      tokenIn,
-      IBPool.Record({
-        bound: true,
-        index: 0, // NOTE: irrelevant for this method
-        denorm: _fuzz.tokenInDenorm
-      })
-    );
-    _mockPoolBalance(tokenIn, _fuzz.tokenInBalance);
-
-    _setRecord(
-      tokenOut,
-      IBPool.Record({
-        bound: true,
-        index: 0, // NOTE: irrelevant for this method
-        denorm: _fuzz.tokenOutDenorm
-      })
-    );
-    _mockPoolBalance(tokenOut, _fuzz.tokenOutBalance);
-
-    // Set swapFee
-    _setSwapFee(_fuzz.swapFee);
-    // Set finalize
-    _setFinalize(true);
-  }
-
-  function _assumeHappyPath(SwapExactAmountIn_FuzzScenario memory _fuzz) internal view virtual {
-    // safe bound assumptions
-    _fuzz.tokenInDenorm = bound(_fuzz.tokenInDenorm, MIN_WEIGHT, MAX_WEIGHT);
-    _fuzz.tokenOutDenorm = bound(_fuzz.tokenOutDenorm, MIN_WEIGHT, MAX_WEIGHT);
-    _fuzz.swapFee = bound(_fuzz.swapFee, MIN_FEE, MAX_FEE);
-
-    // min - max - calcSpotPrice (spotPriceBefore)
-    _fuzz.tokenInBalance = bound(_fuzz.tokenInBalance, MIN_BALANCE, type(uint256).max / _fuzz.tokenInDenorm);
-    _fuzz.tokenOutBalance = bound(_fuzz.tokenOutBalance, MIN_BALANCE, type(uint256).max / _fuzz.tokenOutDenorm);
-
-    // max - calcSpotPrice (spotPriceAfter)
-    vm.assume(_fuzz.tokenAmountIn < type(uint256).max - _fuzz.tokenInBalance);
-    vm.assume(_fuzz.tokenInBalance + _fuzz.tokenAmountIn < type(uint256).max / _fuzz.tokenInDenorm);
-
-    // internal calculation for calcSpotPrice (spotPriceBefore)
-    _assumeCalcSpotPrice(
-      _fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.swapFee
-    );
-
-    // MAX_IN_RATIO
-    vm.assume(_fuzz.tokenAmountIn <= bmul(_fuzz.tokenInBalance, MAX_IN_RATIO));
-
-    // L338 BPool.sol
-    uint256 _spotPriceBefore = calcSpotPrice(
-      _fuzz.tokenInBalance, _fuzz.tokenInDenorm, _fuzz.tokenOutBalance, _fuzz.tokenOutDenorm, _fuzz.swapFee
-    );
-
-    _assumeCalcOutGivenIn(_fuzz.tokenInBalance, _fuzz.tokenAmountIn, _fuzz.swapFee);
-    uint256 _tokenAmountOut = calcOutGivenIn(
-      _fuzz.tokenInBalance,
-      _fuzz.tokenInDenorm,
-      _fuzz.tokenOutBalance,
-      _fuzz.tokenOutDenorm,
-      _fuzz.tokenAmountIn,
-      _fuzz.swapFee
-    );
-    vm.assume(_tokenAmountOut > BONE);
-
-    // internal calculation for calcSpotPrice (spotPriceAfter)
-    _assumeCalcSpotPrice(
-      _fuzz.tokenInBalance + _fuzz.tokenAmountIn,
-      _fuzz.tokenInDenorm,
-      _fuzz.tokenOutBalance - _tokenAmountOut,
-      _fuzz.tokenOutDenorm,
-      _fuzz.swapFee
-    );
-
-    vm.assume(bmul(_spotPriceBefore, _tokenAmountOut) <= _fuzz.tokenAmountIn);
-  }
-
-  modifier happyPath(SwapExactAmountIn_FuzzScenario memory _fuzz) {
-    _assumeHappyPath(_fuzz);
-    _setValues(_fuzz);
-    _;
-  }
-}
-
 contract BPool_Unit_GetCurrentTokens is BasePoolTest {
   function test_Returns_CurrentTokens(uint256 _length) public {
     vm.assume(_length > 0);
@@ -435,7 +322,7 @@ contract BPool_Unit_GetNormalizedWeight is BasePoolTest {
     _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}));
+    bPool.set__records(_token, IBPool.Record({bound: true, index: 0, denorm: _weight}));
     _setTotalWeight(_totalWeight);
 
     assertEq(bPool.getNormalizedWeight(_token), bdiv(_weight, _totalWeight));
@@ -695,9 +582,9 @@ contract BPool_Unit_GetSpotPrice is BasePoolTest {
   }
 
   function _setValues(GetSpotPrice_FuzzScenario memory _fuzz) internal {
-    _setRecord(_fuzz.tokenIn, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenInDenorm}));
+    bPool.set__records(_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}));
+    bPool.set__records(_fuzz.tokenOut, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenOutDenorm}));
     _mockPoolBalance(_fuzz.tokenOut, _fuzz.tokenOutBalance);
     _setSwapFee(_fuzz.swapFee);
   }
@@ -764,9 +651,9 @@ contract BPool_Unit_GetSpotPriceSansFee is BasePoolTest {
   }
 
   function _setValues(GetSpotPriceSansFee_FuzzScenario memory _fuzz) internal {
-    _setRecord(_fuzz.tokenIn, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenInDenorm}));
+    bPool.set__records(_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}));
+    bPool.set__records(_fuzz.tokenOut, IBPool.Record({bound: true, index: 0, denorm: _fuzz.tokenOutDenorm}));
     _mockPoolBalance(_fuzz.tokenOut, _fuzz.tokenOutBalance);
     _setSwapFee(0);
   }
@@ -838,7 +725,7 @@ contract BPool_Unit_JoinswapPoolAmountOut is BasePoolTest {
     _mockTransferFrom(tokenIn);
 
     // Set balances
-    _setRecord(
+    bPool.set__records(
       tokenIn,
       IBPool.Record({
         bound: true,
@@ -1070,7 +957,7 @@ contract BPool_Unit_ExitswapExternAmountOut is BasePoolTest {
     _mockTransfer(tokenOut);
 
     // Set balances
-    _setRecord(
+    bPool.set__records(
       tokenOut,
       IBPool.Record({
         bound: true,
diff --git a/test/unit/BPool/BPool.t.sol b/test/unit/BPool/BPool.t.sol
index b3bebdee..264fef02 100644
--- a/test/unit/BPool/BPool.t.sol
+++ b/test/unit/BPool/BPool.t.sol
@@ -33,13 +33,13 @@ contract BPool is BPoolBase {
   }
 
   function test_IsBoundWhenTokenIsBound(address _token) external {
-    _setRecord(_token, IBPool.Record({bound: true, index: 0, denorm: 0}));
+    bPool.set__records(_token, IBPool.Record({bound: true, index: 0, denorm: 0}));
     // it returns true
     assertTrue(bPool.isBound(_token));
   }
 
   function test_IsBoundWhenTokenIsNOTBound(address _token) external {
-    _setRecord(_token, IBPool.Record({bound: false, index: 0, denorm: 0}));
+    bPool.set__records(_token, IBPool.Record({bound: false, index: 0, denorm: 0}));
     // it returns false
     assertFalse(bPool.isBound(_token));
   }
diff --git a/test/unit/BPool/BPoolBase.sol b/test/unit/BPool/BPoolBase.sol
index 113ddffd..36851e2c 100644
--- a/test/unit/BPool/BPoolBase.sol
+++ b/test/unit/BPool/BPoolBase.sol
@@ -21,16 +21,8 @@ contract BPoolBase is Test, BConst, Utils {
   function _setRandomTokens(uint256 _length) internal returns (address[] memory _tokensToAdd) {
     _tokensToAdd = _getDeterministicTokenArray(_length);
     for (uint256 i = 0; i < _length; i++) {
-      _setRecord(_tokensToAdd[i], IBPool.Record({bound: true, index: i, denorm: 0}));
+      bPool.set__records(_tokensToAdd[i], IBPool.Record({bound: true, index: i, denorm: 0}));
     }
-    _setTokens(_tokensToAdd);
-  }
-
-  function _setTokens(address[] memory _tokens) internal {
-    bPool.set__tokens(_tokens);
-  }
-
-  function _setRecord(address _token, IBPool.Record memory _record) internal {
-    bPool.set__records(_token, _record);
+    bPool.set__tokens(_tokensToAdd);
   }
 }
diff --git a/test/unit/BPool/BPool_Bind.t.sol b/test/unit/BPool/BPool_Bind.t.sol
index b3570b0b..c811dfb2 100644
--- a/test/unit/BPool/BPool_Bind.t.sol
+++ b/test/unit/BPool/BPool_Bind.t.sol
@@ -38,7 +38,7 @@ contract BPoolBind is BPoolBase {
   }
 
   function test_RevertWhen_TokenIsAlreadyBound() external whenCallerIsController {
-    _setRecord(tokens[0], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
+    bPool.set__records(tokens[0], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
     // it should revert
     vm.expectRevert(IBPool.BPool_TokenAlreadyBound.selector);
     bPool.bind(tokens[0], tokenBindBalance, tokenWeight);
diff --git a/test/unit/BPool/BPool_ExitPool.t.sol b/test/unit/BPool/BPool_ExitPool.t.sol
index fac066ce..858cbef1 100644
--- a/test/unit/BPool/BPool_ExitPool.t.sol
+++ b/test/unit/BPool/BPool_ExitPool.t.sol
@@ -31,8 +31,8 @@ contract BPoolExitPool is BPoolBase, BNum {
     bPool.call__mintPoolShare(INIT_POOL_SUPPLY);
     bPool.set__tokens(_tokensToMemory());
     // token weights are not used for all-token exits
-    _setRecord(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
-    _setRecord(tokens[1], IBPool.Record({bound: true, index: 1, denorm: 0}));
+    bPool.set__records(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
+    bPool.set__records(tokens[1], IBPool.Record({bound: true, index: 1, denorm: 0}));
     // underlying balances are used instead
     vm.mockCall(tokens[0], abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(token0Balance)));
     vm.mockCall(tokens[1], abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(token1Balance)));
diff --git a/test/unit/BPool/BPool_ExitswapPoolAmountIn.t.sol b/test/unit/BPool/BPool_ExitswapPoolAmountIn.t.sol
index 2650fddf..8032cdf7 100644
--- a/test/unit/BPool/BPool_ExitswapPoolAmountIn.t.sol
+++ b/test/unit/BPool/BPool_ExitswapPoolAmountIn.t.sol
@@ -22,7 +22,7 @@ contract BPoolExitSwapPoolAmountIn is BPoolBase, BMath {
   function setUp() public virtual override {
     super.setUp();
     tokenOut = tokens[1];
-    _setRecord(tokenOut, IBPool.Record({bound: true, index: 0, denorm: tokenOutWeight}));
+    bPool.set__records(tokenOut, IBPool.Record({bound: true, index: 0, denorm: tokenOutWeight}));
     bPool.set__tokens(tokens);
     bPool.set__totalWeight(totalWeight);
     bPool.set__finalized(true);
diff --git a/test/unit/BPool/BPool_JoinPool.t.sol b/test/unit/BPool/BPool_JoinPool.t.sol
index 1f501275..eeb01efe 100644
--- a/test/unit/BPool/BPool_JoinPool.t.sol
+++ b/test/unit/BPool/BPool_JoinPool.t.sol
@@ -27,8 +27,8 @@ contract BPoolJoinPool is BPoolBase {
     bPool.call__mintPoolShare(INIT_POOL_SUPPLY);
     bPool.set__tokens(_tokensToMemory());
     // token weights are not used for all-token joins
-    _setRecord(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
-    _setRecord(tokens[1], IBPool.Record({bound: true, index: 1, denorm: 0}));
+    bPool.set__records(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
+    bPool.set__records(tokens[1], IBPool.Record({bound: true, index: 1, denorm: 0}));
     // underlying balances are used instead
     vm.mockCall(tokens[0], abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(token0Balance)));
     vm.mockCall(tokens[1], abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(token1Balance)));
diff --git a/test/unit/BPool/BPool_JoinswapExternAmountIn.t.sol b/test/unit/BPool/BPool_JoinswapExternAmountIn.t.sol
index 04981553..afa67556 100644
--- a/test/unit/BPool/BPool_JoinswapExternAmountIn.t.sol
+++ b/test/unit/BPool/BPool_JoinswapExternAmountIn.t.sol
@@ -29,7 +29,7 @@ contract BPoolJoinswapExternAmountIn is BPoolBase, BNum {
     bPool.call__mintPoolShare(INIT_POOL_SUPPLY);
     bPool.set__tokens(_tokensToMemory());
     bPool.set__totalWeight(totalWeight);
-    _setRecord(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
+    bPool.set__records(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
     vm.mockCall(tokenIn, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenInBalance)));
   }
 
diff --git a/test/unit/BPool/BPool_SwapExactAmountIn.t.sol b/test/unit/BPool/BPool_SwapExactAmountIn.t.sol
index 709b3461..9537bf7f 100644
--- a/test/unit/BPool/BPool_SwapExactAmountIn.t.sol
+++ b/test/unit/BPool/BPool_SwapExactAmountIn.t.sol
@@ -35,8 +35,8 @@ contract BPoolSwapExactAmountIn is BPoolBase, BNum {
     tokenOut = tokens[1];
     bPool.set__finalized(true);
     bPool.set__tokens(tokens);
-    _setRecord(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
-    _setRecord(tokenOut, IBPool.Record({bound: true, index: 1, denorm: tokenOutWeight}));
+    bPool.set__records(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
+    bPool.set__records(tokenOut, IBPool.Record({bound: true, index: 1, denorm: tokenOutWeight}));
 
     vm.mockCall(tokenIn, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenInBalance)));
     vm.mockCall(tokenOut, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenOutBalance)));
diff --git a/test/unit/BPool/BPool_SwapExactAmountOut.t.sol b/test/unit/BPool/BPool_SwapExactAmountOut.t.sol
index f648b9a9..85e168b0 100644
--- a/test/unit/BPool/BPool_SwapExactAmountOut.t.sol
+++ b/test/unit/BPool/BPool_SwapExactAmountOut.t.sol
@@ -36,8 +36,8 @@ contract BPoolSwapExactAmountOut is BPoolBase, BNum {
     tokenOut = tokens[1];
     bPool.set__finalized(true);
     bPool.set__tokens(tokens);
-    _setRecord(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
-    _setRecord(tokenOut, IBPool.Record({bound: true, index: 1, denorm: tokenOutWeight}));
+    bPool.set__records(tokenIn, IBPool.Record({bound: true, index: 0, denorm: tokenInWeight}));
+    bPool.set__records(tokenOut, IBPool.Record({bound: true, index: 1, denorm: tokenOutWeight}));
 
     vm.mockCall(tokenIn, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenInBalance)));
     vm.mockCall(tokenOut, abi.encodePacked(IERC20.balanceOf.selector), abi.encode(uint256(tokenOutBalance)));
diff --git a/test/unit/BPool/BPool_Unbind.t.sol b/test/unit/BPool/BPool_Unbind.t.sol
index 8741b776..c0c0f008 100644
--- a/test/unit/BPool/BPool_Unbind.t.sol
+++ b/test/unit/BPool/BPool_Unbind.t.sol
@@ -44,7 +44,7 @@ contract BPoolUnbind is BPoolBase {
   }
 
   function test_RevertWhen_PoolIsFinalized() external whenCallerIsController {
-    _setRecord(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
+    bPool.set__records(tokens[0], IBPool.Record({bound: true, index: 0, denorm: 0}));
     bPool.set__finalized(true);
     // it should revert
     vm.expectRevert(IBPool.BPool_PoolIsFinalized.selector);
@@ -52,7 +52,7 @@ contract BPoolUnbind is BPoolBase {
   }
 
   modifier whenTokenCanBeUnbound() {
-    _setRecord(tokens[0], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
+    bPool.set__records(tokens[0], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
     bPool.set__totalWeight(totalWeight);
     address[] memory tokens = new address[](1);
     tokens[0] = tokens[0];
@@ -83,7 +83,7 @@ contract BPoolUnbind is BPoolBase {
   }
 
   function test_WhenTokenIsNOTLastOnTheTokensArray() external whenCallerIsController whenTokenCanBeUnbound {
-    _setRecord(tokens[1], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
+    bPool.set__records(tokens[1], IBPool.Record({bound: true, index: 0, denorm: tokenWeight}));
     bPool.set__tokens(_tokensToMemory());
     bPool.unbind(tokens[0]);
     // it removes the token record