native string utils cheatcodes

crates/cheatcodes/spec/src/vm.rs

@@ -1077,6 +1077,22 @@ interface Vm {
     #[cheatcode(group = String)]
     function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
 
+    /// Converts the given `string` value to Lowercase.
+    #[cheatcode(group = String)]
+    function toLowercase(string calldata inputString) external pure returns (string memory outputString);
+    /// Converts the given `string` value to Uppercase.
+    #[cheatcode(group = String)]
+    function toUppercase(string calldata inputString) external pure returns (string memory outputString);
+    /// Trims leading and trailing whitespace from the given `string` value.
+    #[cheatcode(group = String)]
+    function trim(string calldata inputString) external pure returns (string memory outputString);
+    /// Replaces occurrences of `from` in the given `string` with `to`.
+    #[cheatcode(group = String)]
+    function replace(string calldata inputString, string calldata from, string calldata to) external pure returns (string memory outputString);
+    /// Splits the given `string` into an array of strings divided by the `delimiter`.
+    #[cheatcode(group = String)]
+    function split(string calldata inputString, string calldata delimiter) external pure returns (string[] memory outputStrings);
+
     // ======== JSON Parsing and Manipulation ========
 
     // -------- Reading --------

crates/cheatcodes/src/string.rs

@@ -94,6 +94,47 @@ impl Cheatcode for parseBoolCall {
     }
 }
 
+// toLowercase
+impl Cheatcode for toLowercaseCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { inputString } = self;
+        Ok(inputString.to_lowercase().abi_encode())
+    }
+}
+
+// toUppercase
+impl Cheatcode for toUppercaseCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { inputString } = self;
+        Ok(inputString.to_uppercase().abi_encode())
+    }
+}
+
+// trim
+impl Cheatcode for trimCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { inputString } = self;
+        Ok(inputString.trim().abi_encode())
+    }
+}
+
+// Replace
+impl Cheatcode for replaceCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { inputString, from, to } = self;
+        Ok(inputString.replace(from, to).abi_encode())
+    }
+}
+
+// Split
+impl Cheatcode for splitCall {
+    fn apply(&self, _state: &mut Cheatcodes) -> Result {
+        let Self { inputString, delimiter } = self;
+        let parts: Vec<&str> = inputString.split(delimiter).collect();
+        Ok(parts.abi_encode())
+    }
+}
+
 pub(super) fn parse(s: &str, ty: &DynSolType) -> Result {
     parse_value(s, ty).map(|v| v.abi_encode())
 }

testdata/cheats/StringUtils.t.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity 0.8.18;
+
+import "ds-test/test.sol";
+import "./Vm.sol";
+
+contract StringManipulationTest is DSTest {
+    Vm constant vm = Vm(HEVM_ADDRESS);
+
+    function testToLowercase() public {
+        string memory original = "Hello World";
+        string memory lowercased = vm.toLowercase(original);
+        assertEq("hello world", lowercased);
+    }
+
+    function testToUppercase() public {
+        string memory original = "Hello World";
+        string memory uppercased = vm.toUppercase(original);
+        assertEq("HELLO WORLD", uppercased);
+    }
+
+    function testTrim() public {
+        string memory original = "   Hello World   ";
+        string memory trimmed = vm.trim(original);
+        assertEq("Hello World", trimmed);
+    }
+
+    function testReplace() public {
+        string memory original = "Hello World";
+        string memory replaced = vm.replace(original, "World", "Reth");
+        assertEq("Hello Reth", replaced);
+    }
+
+    function testSplit() public {
+        string memory original = "Hello,World,Reth";
+        string[] memory splitResult = vm.split(original, ",");
+        assertEq(3, splitResult.length);
+        assertEq("Hello", splitResult[0]);
+        assertEq("World", splitResult[1]);
+        assertEq("Reth", splitResult[2]);
+    }
+}