Add Tests for maxUsableTick and minUsableTick Functions

src/test/TickMathTest.sol

@@ -39,4 +39,12 @@ contract TickMathTest {
     function MAX_TICK() external pure returns (int24) {
         return TickMath.MAX_TICK;
     }
+
+    function maxUsableTick(int24 tickSpacing) external pure returns (int24) {
+        return TickMath.maxUsableTick(tickSpacing);
+    }
+
+    function minUsableTick(int24 tickSpacing) external pure returns (int24) {
+        return TickMath.minUsableTick(tickSpacing);
+    }
 }

test/TickMath.t.sol

@@ -21,6 +21,11 @@ contract TickMathTestTest is Test, JavascriptFfi {
     uint160[] getSqrtRatioAtTickFuzzResults;
     int24[] getTickAtSqrtRatioFuzzResults;
 
+    struct FeeTier {
+        uint256 fee;
+        int24 tickSpacing;
+    }
+
     TickMathTest tickMath;
 
     function setUp() public {
@@ -44,6 +49,68 @@ contract TickMathTestTest is Test, JavascriptFfi {
         assertEq(maxTick, MAX_TICK);
     }
 
+    function test_maxUsableTick_SpecificFeeTiers() public {
+        // The size of tick spacing is relative to the fee tier.
+        // The tick spacing is double the size of the fee tier.
+        // For example, a tick for 0.30% fee tier pool will be 0.60% in size.
+        // The 0.01% fee tier has a size of 0.01%.
+        FeeTier[] memory feeTiers = new FeeTier[](5);
+        feeTiers[0] = FeeTier({fee: 1, tickSpacing: 1}); // 0.01% fee tier
+        feeTiers[1] = FeeTier({fee: 5, tickSpacing: 10}); // 0.05% fee tier
+        feeTiers[2] = FeeTier({fee: 30, tickSpacing: 60}); // 0.30% fee tier
+        feeTiers[3] = FeeTier({fee: 100, tickSpacing: 200}); // 1% fee tier
+        feeTiers[4] = FeeTier({fee: 500, tickSpacing: 1000}); // very high fee tier
+
+        for (uint256 i = 0; i < feeTiers.length; i++) {
+            FeeTier memory tier = feeTiers[i];
+            int24 expectedMaxTick = (MAX_TICK / tier.tickSpacing) * tier.tickSpacing;
+            assertEq(tickMath.maxUsableTick(tier.tickSpacing), expectedMaxTick);
+        }
+    }
+
+    function test_minUsableTick_SpecificFeeTiers() public {
+        // The size of tick spacing is relative to the fee tier.
+        // The tick spacing is double the size of the fee tier.
+        // For example, a tick for 0.30% fee tier pool will be 0.60% in size.
+        // The 0.01% fee tier has a size of 0.01%.
+        FeeTier[] memory feeTiers = new FeeTier[](5);
+        feeTiers[0] = FeeTier({fee: 1, tickSpacing: 1}); // 0.01% fee tier
+        feeTiers[1] = FeeTier({fee: 5, tickSpacing: 10}); // 0.05% fee tier
+        feeTiers[2] = FeeTier({fee: 30, tickSpacing: 60}); // 0.30% fee tier
+        feeTiers[3] = FeeTier({fee: 100, tickSpacing: 200}); // 1% fee tier
+        feeTiers[4] = FeeTier({fee: 500, tickSpacing: 1000}); // very high fee tier
+
+        for (uint256 i = 0; i < feeTiers.length; i++) {
+            FeeTier memory tier = feeTiers[i];
+            int24 expectedMinTick = (MIN_TICK / tier.tickSpacing) * tier.tickSpacing;
+            assertEq(tickMath.minUsableTick(tier.tickSpacing), expectedMinTick);
+        }
+    }
+
+    function testFuzz_maxUsableTick(int24 tickSpacing) public {
+        vm.assume(tickSpacing > 0 && tickSpacing <= MAX_TICK && tickSpacing >= MIN_TICK);
+
+        int24 expectedMaxTick = (MAX_TICK / tickSpacing) * tickSpacing;
+        assertEq(tickMath.maxUsableTick(tickSpacing), expectedMaxTick);
+    }
+
+    function testFuzz_minUsableTick(int24 tickSpacing) public {
+        vm.assume(tickSpacing > 0 && tickSpacing <= MAX_TICK && tickSpacing >= MIN_TICK);
+
+        int24 expectedMinTick = (MIN_TICK / tickSpacing) * tickSpacing;
+        assertEq(tickMath.minUsableTick(tickSpacing), expectedMinTick);
+    }
+
+    function test_maxUsableTick_revertsForZero() public {
+        vm.expectRevert();
+        tickMath.maxUsableTick(0);
+    }
+
+    function test_minUsableTick_revertsForZero() public {
+        vm.expectRevert();
+        tickMath.minUsableTick(0);
+    }
+
     function test_getSqrtRatioAtTick_throwsForTooLow() public {
         vm.expectRevert(TickMath.InvalidTick.selector);
         tickMath.getSqrtRatioAtTick(MIN_TICK - 1);