Merge pull request #6073 from ethereum-optimism/refcell/ctb/bytes/styling

fix(ctb): Update Bytes Test Styling

packages/contracts-bedrock/.gas-snapshot

 Bytes_slice_Test:test_slice_acrossMultipleWords_works() (gas: 9413)
 Bytes_slice_Test:test_slice_acrossWords_works() (gas: 1430)
 Bytes_slice_Test:test_slice_fromNonZeroIdx_works() (gas: 17240)
-Bytes_slice_Test:test_slice_fromZeroIdx_works() (gas: 20826)
+Bytes_slice_Test:test_slice_fromZeroIdx_works() (gas: 20804)
 Bytes_toNibbles_Test:test_toNibbles_expectedResult128Bytes_works() (gas: 78882)
 Bytes_toNibbles_Test:test_toNibbles_expectedResult5Bytes_works() (gas: 3992)
 Bytes_toNibbles_Test:test_toNibbles_zeroLengthInput_works() (gas: 823)

packages/contracts-bedrock/contracts/test/Bytes.t.sol

@@ -70,59 +70,6 @@ contract Bytes_slice_Test is Test {
         assertEq(Bytes.slice(input, 31, 34), expected);
     }
 
-    /**
-     * @notice Tests that, when given an input bytes array of length `n`, the `slice` function will
-     *         always revert if `_start + _length > n`.
-     */
-    function testFuzz_slice_outOfBounds_reverts(
-        bytes memory _input,
-        uint256 _start,
-        uint256 _length
-    ) public {
-        // We want a valid start index and a length that will not overflow.
-        vm.assume(_start < _input.length && _length < type(uint256).max - 31);
-        // But, we want an invalid slice length.
-        vm.assume(_start + _length > _input.length);
-
-        vm.expectRevert("slice_outOfBounds");
-        Bytes.slice(_input, _start, _length);
-    }
-
-    /**
-     * @notice Tests that, when given a length `n` that is greater than `type(uint256).max - 31`,
-     *         the `slice` function reverts.
-     */
-    function testFuzz_slice_lengthOverflows_reverts(
-        bytes memory _input,
-        uint256 _start,
-        uint256 _length
-    ) public {
-        // Ensure that the `_length` will overflow if a number >= 31 is added to it.
-        vm.assume(_length > type(uint256).max - 31);
-
-        vm.expectRevert("slice_overflow");
-        Bytes.slice(_input, _start, _length);
-    }
-
-    /**
-     * @notice Tests that, when given a start index `n` that is greater than
-     *         `type(uint256).max - n`, the `slice` function reverts.
-     */
-    function testFuzz_slice_rangeOverflows_reverts(
-        bytes memory _input,
-        uint256 _start,
-        uint256 _length
-    ) public {
-        // Ensure that `_length` is a realistic length of a slice. This is to make sure
-        // we revert on the correct require statement.
-        vm.assume(_length < _input.length);
-        // Ensure that `_start` will overflow if `_length` is added to it.
-        vm.assume(_start > type(uint256).max - _length);
-
-        vm.expectRevert("slice_overflow");
-        Bytes.slice(_input, _start, _length);
-    }
-
     /**
      * @notice Tests that the `slice` function correctly updates the free memory pointer depending
      *         on the length of the slice.
@@ -181,6 +128,61 @@ contract Bytes_slice_Test is Test {
     }
 }
 
+contract Bytes_slice_TestFail is Test {
+    /**
+     * @notice Tests that, when given an input bytes array of length `n`, the `slice` function will
+     *         always revert if `_start + _length > n`.
+     */
+    function testFuzz_slice_outOfBounds_reverts(
+        bytes memory _input,
+        uint256 _start,
+        uint256 _length
+    ) public {
+        // We want a valid start index and a length that will not overflow.
+        vm.assume(_start < _input.length && _length < type(uint256).max - 31);
+        // But, we want an invalid slice length.
+        vm.assume(_start + _length > _input.length);
+
+        vm.expectRevert("slice_outOfBounds");
+        Bytes.slice(_input, _start, _length);
+    }
+
+    /**
+     * @notice Tests that, when given a length `n` that is greater than `type(uint256).max - 31`,
+     *         the `slice` function reverts.
+     */
+    function testFuzz_slice_lengthOverflows_reverts(
+        bytes memory _input,
+        uint256 _start,
+        uint256 _length
+    ) public {
+        // Ensure that the `_length` will overflow if a number >= 31 is added to it.
+        vm.assume(_length > type(uint256).max - 31);
+
+        vm.expectRevert("slice_overflow");
+        Bytes.slice(_input, _start, _length);
+    }
+
+    /**
+     * @notice Tests that, when given a start index `n` that is greater than
+     *         `type(uint256).max - n`, the `slice` function reverts.
+     */
+    function testFuzz_slice_rangeOverflows_reverts(
+        bytes memory _input,
+        uint256 _start,
+        uint256 _length
+    ) public {
+        // Ensure that `_length` is a realistic length of a slice. This is to make sure
+        // we revert on the correct require statement.
+        vm.assume(_length < _input.length);
+        // Ensure that `_start` will overflow if `_length` is added to it.
+        vm.assume(_start > type(uint256).max - _length);
+
+        vm.expectRevert("slice_overflow");
+        Bytes.slice(_input, _start, _length);
+    }
+}
+
 contract Bytes_toNibbles_Test is Test {
     /**
      * @notice Tests that, given an input of 5 bytes, the `toNibbles` function returns an array of