Add tests, remove autoset

Author: smiasojed

crates/forge/src/cmd/test/mod.rs

@@ -187,7 +187,6 @@ pub struct TestArgs {
 
     /// Maximum integer value for fuzz tests.
     /// Accepts decimal, hex (0x...), or keywords: "u128", "u64".
-    /// Auto-set to u64::MAX when --polkadot is used (unless explicitly set).
     #[arg(long, env = "FOUNDRY_FUZZ_INT_MAX", value_name = "VALUE")]
     pub fuzz_int_max: Option<String>,
 
@@ -328,18 +327,6 @@ impl TestArgs {
             config.polkadot.polkadot = Some(PolkadotMode::Pvm);
         }
 
-        // Auto-set max_fuzz_int to u64::MAX for Polkadot mode if not explicitly set.
-        // This prevents overflow errors since Polkadot uses:
-        // - u64 for block numbers and timestamps (most restrictive)
-        // - u128 for balances (can still be tested up to u64::MAX)
-        if config.polkadot.polkadot.is_some()
-            && config.fuzz.max_fuzz_int.is_none()
-            && self.fuzz_int_max.is_none()
-        {
-            config.fuzz.max_fuzz_int = Some(U256::from(u64::MAX));
-            tracing::info!("Auto-setting fuzz integer max to u64::MAX for Polkadot compatibility");
-        }
-
         let mut strategy = utils::get_executor_strategy(&config);
 
         // Explicitly enable isolation for gas reports for more correct gas accounting.

crates/forge/tests/it/revive/fuzz_max_int.rs

@@ -0,0 +1,110 @@
+//! Tests for max_fuzz_int configuration limiting fuzz values.
+
+use crate::test_helpers::TEST_DATA_DEFAULT;
+use alloy_primitives::U256;
+use forge::result::{SuiteResult, TestStatus};
+use foundry_test_utils::Filter;
+
+/// Test that max_fuzz_int properly limits unsigned integers to [0, max].
+/// With max_fuzz_int = 255, all uint256 values should be <= 255.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_fuzz_max_int_uint_limited() {
+    let max_value = U256::from(u8::MAX);
+
+    let filter =
+        Filter::new("testFuzzUint256Limited", "FuzzMaxIntTest", ".*/revive/FuzzMaxInt.t.sol");
+    let mut runner = TEST_DATA_DEFAULT.runner_with(|config| {
+        config.fuzz.max_fuzz_int = Some(max_value);
+        config.fuzz.runs = 1000;
+    });
+    let results = runner.test_collect(&filter).unwrap();
+
+    for (_, SuiteResult { test_results, .. }) in results {
+        for (test_name, result) in test_results {
+            assert_eq!(
+                result.status,
+                TestStatus::Success,
+                "Test {} should pass with max_fuzz_int limiting uint256 values to [0, 255].\nReason: {:?}",
+                test_name,
+                result.reason
+            );
+        }
+    }
+}
+
+/// Test that max_fuzz_int properly limits signed integers to [-(max+1), max].
+/// With max_fuzz_int = 255, signed integers should be in range [-256, 255].
+#[tokio::test(flavor = "multi_thread")]
+async fn test_fuzz_max_int_int_limited() {
+    let max_value = U256::from(u8::MAX);
+
+    let filter =
+        Filter::new("testFuzzInt256Limited", "FuzzMaxIntTest", ".*/revive/FuzzMaxInt.t.sol");
+    let mut runner = TEST_DATA_DEFAULT.runner_with(|config| {
+        config.fuzz.max_fuzz_int = Some(max_value);
+        config.fuzz.runs = 1000;
+    });
+    let results = runner.test_collect(&filter).unwrap();
+
+    for (_, SuiteResult { test_results, .. }) in results {
+        for (test_name, result) in test_results {
+            assert_eq!(
+                result.status,
+                TestStatus::Success,
+                "Test {} should pass with max_fuzz_int limiting int256 values to [-256, 255].\nReason: {:?}",
+                test_name,
+                result.reason
+            );
+        }
+    }
+}
+
+/// Test that without max_fuzz_int, uint256 values can exceed 255.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_fuzz_no_limit_uint_exceeds() {
+    let filter =
+        Filter::new("testFuzzUint256Unlimited", "FuzzNoLimitTest", ".*/revive/FuzzMaxInt.t.sol");
+    let mut runner = TEST_DATA_DEFAULT.runner_with(|config| {
+        config.fuzz.max_fuzz_int = None; // No limit
+        config.fuzz.runs = 1000;
+        config.fuzz.seed = Some(U256::from(42u32)); // Fixed seed for reproducibility
+    });
+    let results = runner.test_collect(&filter).unwrap();
+
+    for (_, SuiteResult { test_results, .. }) in results {
+        for (test_name, result) in test_results {
+            assert_eq!(
+                result.status,
+                TestStatus::Failure,
+                "Test {} should FAIL without max_fuzz_int as fuzzer generates values > 255.\nReason: {:?}",
+                test_name,
+                result.reason
+            );
+        }
+    }
+}
+
+/// Test that without max_fuzz_int, int256 values can exceed [-256, 255] range.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_fuzz_no_limit_int_exceeds() {
+    let filter =
+        Filter::new("testFuzzInt256Unlimited", "FuzzNoLimitTest", ".*/revive/FuzzMaxInt.t.sol");
+    let mut runner = TEST_DATA_DEFAULT.runner_with(|config| {
+        config.fuzz.max_fuzz_int = None; // No limit
+        config.fuzz.runs = 1000;
+        config.fuzz.seed = Some(U256::from(42u32)); // Fixed seed for reproducibility
+    });
+    let results = runner.test_collect(&filter).unwrap();
+
+    for (_, SuiteResult { test_results, .. }) in results {
+        for (test_name, result) in test_results {
+            assert_eq!(
+                result.status,
+                TestStatus::Failure,
+                "Test {} should FAIL without max_fuzz_int as fuzzer generates values outside [-256, 255].\nReason: {:?}",
+                test_name,
+                result.reason
+            );
+        }
+    }
+}

crates/forge/tests/it/revive/mod.rs

@@ -10,6 +10,7 @@ pub mod cheat_prank;
 mod cheat_snapshot;
 pub mod cheat_store;
 pub mod cheats_individual;
+pub mod fuzz_max_int;
 pub mod migration;
 pub mod record_accesses;
 pub mod tx_gas_price;

testdata/default/revive/FuzzMaxInt.t.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.18;
+
+import "ds-test/test.sol";
+
+contract FuzzMaxIntTest is DSTest {
+    // Test that unsigned integers are limited to max_fuzz_int.
+    // With max_fuzz_int = 255, all uint256 values should be <= 255.
+    function testFuzzUint256Limited(uint256 val) public {
+        assertTrue(val <= 255, "uint256 should be limited to max_fuzz_int (255)");
+    }
+
+    // Test that signed integers are limited to [-(max+1), max].
+    // With max_fuzz_int = 255, int256 should be in range [-256, 255].
+    function testFuzzInt256Limited(int256 val) public {
+        assertTrue(val >= -256, "int256 should be >= -(max_fuzz_int+1) = -256");
+        assertTrue(val <= 255, "int256 should be <= max_fuzz_int = 255");
+    }
+}
+
+contract FuzzNoLimitTest is DSTest {
+    // This test should fail without max_fuzz_int as fuzzer will generate values > 255.
+    function testFuzzUint256Unlimited(uint256 val) public {
+        assertTrue(val <= 255, "Expected to fail: fuzzer should generate values > 255");
+    }
+
+    // This test should fail without max_fuzz_int as fuzzer will generate values outside [-256, 255].
+    function testFuzzInt256Unlimited(int256 val) public {
+        bool inRange = val >= -256 && val <= 255;
+        assertTrue(inRange, "Expected to fail: fuzzer should generate values outside [-256, 255]");
+    }
+}