fix(forge): enable fail fast flag

grandizzy · grandizzy · commit 566fd49d8471 · 2025-08-18T13:38:20.000+03:00
diff --git a/crates/evm/evm/src/executors/fuzz/mod.rs b/crates/evm/evm/src/executors/fuzz/mod.rs
@@ -1,4 +1,6 @@
-use crate::executors::{DURATION_BETWEEN_METRICS_REPORT, Executor, FuzzTestTimer, RawCallResult};
+use crate::executors::{
+    DURATION_BETWEEN_METRICS_REPORT, Executor, FailFast, FuzzTestTimer, RawCallResult,
+};
 use alloy_dyn_abi::JsonAbiExt;
 use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes, Log, U256, map::HashMap};
@@ -90,6 +92,7 @@ impl FuzzedExecutor {
     /// test case.
     ///
     /// Returns a list of all the consumed gas and calldata of every fuzz case.
+    #[allow(clippy::too_many_arguments)]
     pub fn fuzz(
         &mut self,
         func: &Function,
@@ -98,6 +101,7 @@ impl FuzzedExecutor {
         address: Address,
         rd: &RevertDecoder,
         progress: Option<&ProgressBar>,
+        fail_fast: &FailFast,
     ) -> Result<FuzzTestResult> {
         // Stores the fuzz test execution data.
         let mut test_data = FuzzTestData::default();
@@ -128,6 +132,10 @@ impl FuzzedExecutor {
         let mut last_metrics_report = Instant::now();
         let max_runs = self.config.runs;
         let continue_campaign = |runs: u32| {
+            if fail_fast.should_stop() {
+                return false;
+            }
+
             if timer.is_enabled() { !timer.is_timed_out() } else { runs < max_runs }
         };
 
diff --git a/crates/evm/evm/src/executors/invariant/mod.rs b/crates/evm/evm/src/executors/invariant/mod.rs
@@ -49,7 +49,7 @@ use serde_json::json;
 
 mod shrink;
 use crate::executors::{
-    DURATION_BETWEEN_METRICS_REPORT, EvmError, FuzzTestTimer, corpus::CorpusManager,
+    DURATION_BETWEEN_METRICS_REPORT, EvmError, FailFast, FuzzTestTimer, corpus::CorpusManager,
 };
 pub use shrink::check_sequence;
 
@@ -327,6 +327,7 @@ impl<'a> InvariantExecutor<'a> {
         fuzz_fixtures: &FuzzFixtures,
         deployed_libs: &[Address],
         progress: Option<&ProgressBar>,
+        fail_fast: &FailFast,
     ) -> Result<InvariantFuzzTestResult> {
         // Throw an error to abort test run if the invariant function accepts input params
         if !invariant_contract.invariant_function.inputs.is_empty() {
@@ -341,6 +342,10 @@ impl<'a> InvariantExecutor<'a> {
         let timer = FuzzTestTimer::new(self.config.timeout);
         let mut last_metrics_report = Instant::now();
         let continue_campaign = |runs: u32| {
+            if fail_fast.should_stop() {
+                return false;
+            }
+
             if timer.is_enabled() { !timer.is_timed_out() } else { runs < self.config.runs }
         };
 
diff --git a/crates/evm/evm/src/executors/mod.rs b/crates/evm/evm/src/executors/mod.rs
@@ -44,6 +44,10 @@ use revm::{
 };
 use std::{
     borrow::Cow,
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+    },
     time::{Duration, Instant},
 };
 
@@ -1109,3 +1113,33 @@ impl FuzzTestTimer {
         self.inner.is_some_and(|(start, duration)| start.elapsed() > duration)
     }
 }
+
+/// Helper struct to enable fail fast behavior: when one test fails, all other tests stop early.
+pub struct FailFast {
+    /// Shared atomic flag set to `true` when a failure occurs.
+    /// None if fail-fast is disabled.
+    inner: Option<Arc<AtomicBool>>,
+}
+
+impl FailFast {
+    pub fn new(fail_fast: bool) -> Self {
+        Self { inner: fail_fast.then_some(Arc::new(AtomicBool::new(false))) }
+    }
+
+    /// Returns `true` if fail-fast is enabled.
+    pub fn is_enabled(&self) -> bool {
+        self.inner.is_some()
+    }
+
+    /// Sets the failure flag. Used by other tests to stop early.
+    pub fn record_fail(&self) {
+        if let Some(fail_fast) = &self.inner {
+            fail_fast.store(true, Ordering::Relaxed);
+        }
+    }
+
+    /// Whether a failure has been recorded and test should stop.
+    pub fn should_stop(&self) -> bool {
+        self.inner.as_ref().map(|flag| flag.load(Ordering::Relaxed)).unwrap_or(false)
+    }
+}
diff --git a/crates/forge/src/cmd/test/mod.rs b/crates/forge/src/cmd/test/mod.rs
@@ -509,9 +509,10 @@ impl TestArgs {
         let (tx, rx) = channel::<(String, SuiteResult)>();
         let timer = Instant::now();
         let show_progress = config.show_progress;
+        let fail_fast = self.fail_fast;
         let handle = tokio::task::spawn_blocking({
             let filter = filter.clone();
-            move || runner.test(&filter, tx, show_progress)
+            move || runner.test(&filter, tx, show_progress, fail_fast)
         });
 
         // Set up trace identifiers.
diff --git a/crates/forge/src/multi_runner.rs b/crates/forge/src/multi_runner.rs
@@ -18,7 +18,7 @@ use foundry_evm::{
     Env,
     backend::Backend,
     decode::RevertDecoder,
-    executors::{Executor, ExecutorBuilder},
+    executors::{Executor, ExecutorBuilder, FailFast},
     fork::CreateFork,
     inspectors::CheatsConfig,
     opts::EvmOpts,
@@ -153,7 +153,7 @@ impl MultiContractRunner {
         filter: &dyn TestFilter,
     ) -> Result<impl Iterator<Item = (String, SuiteResult)>> {
         let (tx, rx) = mpsc::channel();
-        self.test(filter, tx, false)?;
+        self.test(filter, tx, false, false)?;
         Ok(rx.into_iter())
     }
 
@@ -168,6 +168,7 @@ impl MultiContractRunner {
         filter: &dyn TestFilter,
         tx: mpsc::Sender<(String, SuiteResult)>,
         show_progress: bool,
+        fail_fast: bool,
     ) -> Result<()> {
         let tokio_handle = tokio::runtime::Handle::current();
         trace!("running all tests");
@@ -185,6 +186,8 @@ impl MultiContractRunner {
             find_time,
         );
 
+        let fail_fast = FailFast::new(fail_fast);
+
         if show_progress {
             let tests_progress = TestsProgress::new(contracts.len(), rayon::current_num_threads());
             // Collect test suite results to stream at the end of test run.
@@ -201,6 +204,7 @@ impl MultiContractRunner {
                         filter,
                         &tokio_handle,
                         Some(&tests_progress),
+                        &fail_fast,
                     );
 
                     tests_progress
@@ -220,14 +224,16 @@ impl MultiContractRunner {
         } else {
             contracts.par_iter().for_each(|&(id, contract)| {
                 let _guard = tokio_handle.enter();
-                let result = self.run_test_suite(id, contract, &db, filter, &tokio_handle, None);
+                let result =
+                    self.run_test_suite(id, contract, &db, filter, &tokio_handle, None, &fail_fast);
                 let _ = tx.send((id.identifier(), result));
             })
         }
 
         Ok(())
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn run_test_suite(
         &self,
         artifact_id: &ArtifactId,
@@ -236,6 +242,7 @@ impl MultiContractRunner {
         filter: &dyn TestFilter,
         tokio_handle: &tokio::runtime::Handle,
         progress: Option<&TestsProgress>,
+        fail_fast: &FailFast,
     ) -> SuiteResult {
         let identifier = artifact_id.identifier();
         let mut span_name = identifier.as_str();
@@ -259,7 +266,7 @@ impl MultiContractRunner {
             span,
             self,
         );
-        let r = runner.run_tests(filter);
+        let r = runner.run_tests(filter, fail_fast);
 
         debug!(duration=?r.duration, "executed all tests in contract");
 
diff --git a/crates/forge/src/runner.rs b/crates/forge/src/runner.rs
@@ -18,7 +18,7 @@ use foundry_evm::{
     constants::CALLER,
     decode::RevertDecoder,
     executors::{
-        CallResult, EvmError, Executor, ITest, RawCallResult,
+        CallResult, EvmError, Executor, FailFast, ITest, RawCallResult,
         fuzz::FuzzedExecutor,
         invariant::{
             InvariantExecutor, InvariantFuzzError, check_sequence, replay_error, replay_run,
@@ -279,7 +279,7 @@ impl<'a> ContractRunner<'a> {
     }
 
     /// Runs all tests for a contract whose names match the provided regular expression
-    pub fn run_tests(mut self, filter: &dyn TestFilter) -> SuiteResult {
+    pub fn run_tests(mut self, filter: &dyn TestFilter, fail_fast: &FailFast) -> SuiteResult {
         let start = Instant::now();
         let mut warnings = Vec::new();
 
@@ -404,6 +404,11 @@ impl<'a> ContractRunner<'a> {
         let test_results = functions
             .par_iter()
             .map(|&func| {
+                // Early exit if we're running with fail-fast and a test already failed.
+                if fail_fast.should_stop() {
+                    return (func.signature(), TestResult::setup_result(setup.clone()));
+                }
+
                 let start = Instant::now();
 
                 let _guard = self.tokio_handle.enter();
@@ -429,9 +434,15 @@ impl<'a> ContractRunner<'a> {
                     kind,
                     call_after_invariant,
                     identified_contracts.as_ref(),
+                    fail_fast,
                 );
                 res.duration = start.elapsed();
 
+                // Set fail fast flag if current test failed.
+                if res.status.is_failure() {
+                    fail_fast.record_fail();
+                }
+
                 (sig, res)
             })
             .collect::<BTreeMap<_, _>>();
@@ -501,6 +512,7 @@ impl<'a> FunctionRunner<'a> {
         kind: TestFunctionKind,
         call_after_invariant: bool,
         identified_contracts: Option<&ContractsByAddress>,
+        fail_fast: &FailFast,
     ) -> TestResult {
         if let Err(e) = self.apply_function_inline_config(func) {
             self.result.single_fail(Some(e.to_string()));
@@ -509,15 +521,16 @@ impl<'a> FunctionRunner<'a> {
 
         match kind {
             TestFunctionKind::UnitTest { .. } => self.run_unit_test(func),
-            TestFunctionKind::FuzzTest { .. } => self.run_fuzz_test(func),
-            TestFunctionKind::TableTest => self.run_table_test(func),
+            TestFunctionKind::FuzzTest { .. } => self.run_fuzz_test(func, fail_fast),
+            TestFunctionKind::TableTest => self.run_table_test(func, fail_fast),
             TestFunctionKind::InvariantTest => {
                 let test_bytecode = &self.cr.contract.bytecode;
                 self.run_invariant_test(
                     func,
                     call_after_invariant,
                     identified_contracts.unwrap(),
                     test_bytecode,
+                    fail_fast,
                 )
             }
             _ => unreachable!(),
@@ -573,7 +586,7 @@ impl<'a> FunctionRunner<'a> {
     /// - `uint256[] public fixtureAmount = [2, 5]`
     /// - `bool[] public fixtureSwap = [true, false]` The `table_test` is then called with the pair
     ///   of args `(2, true)` and `(5, false)`.
-    fn run_table_test(mut self, func: &Function) -> TestResult {
+    fn run_table_test(mut self, func: &Function, fail_fast: &FailFast) -> TestResult {
         // Prepare unit test execution.
         if self.prepare_test(func).is_err() {
             return self.result;
@@ -629,6 +642,10 @@ impl<'a> FunctionRunner<'a> {
         );
 
         for i in 0..fixtures_len {
+            if fail_fast.should_stop() {
+                return self.result;
+            }
+
             // Increment progress bar.
             if let Some(progress) = progress.as_ref() {
                 progress.inc(1);
@@ -686,6 +703,7 @@ impl<'a> FunctionRunner<'a> {
         call_after_invariant: bool,
         identified_contracts: &ContractsByAddress,
         test_bytecode: &Bytes,
+        fail_fast: &FailFast,
     ) -> TestResult {
         // First, run the test normally to see if it needs to be skipped.
         if let Err(EvmError::Skip(reason)) = self.executor.call(
@@ -800,6 +818,7 @@ impl<'a> FunctionRunner<'a> {
             &self.setup.fuzz_fixtures,
             &self.setup.deployed_libs,
             progress.as_ref(),
+            fail_fast,
         ) {
             Ok(x) => x,
             Err(e) => {
@@ -910,7 +929,7 @@ impl<'a> FunctionRunner<'a> {
     /// (therefore the fuzz test will use the modified state).
     /// State modifications of before test txes and fuzz test are discarded after test ends,
     /// similar to `eth_call`.
-    fn run_fuzz_test(mut self, func: &Function) -> TestResult {
+    fn run_fuzz_test(mut self, func: &Function, fail_fast: &FailFast) -> TestResult {
         // Prepare fuzz test execution.
         if self.prepare_test(func).is_err() {
             return self.result;
@@ -950,6 +969,7 @@ impl<'a> FunctionRunner<'a> {
             self.address,
             &self.cr.mcr.revert_decoder,
             progress.as_ref(),
+            fail_fast,
         ) {
             Ok(x) => x,
             Err(e) => {
diff --git a/crates/forge/tests/cli/config.rs b/crates/forge/tests/cli/config.rs
@@ -1878,3 +1878,47 @@ forgetest_init!(test_exclude_lints_config, |prj, cmd| {
     });
     cmd.args(["lint"]).assert_success().stdout_eq(str![""]);
 });
+
+// <https://github.com/foundry-rs/foundry/issues/6529>
+forgetest_init!(test_fail_fast_config, |prj, cmd| {
+    prj.update_config(|config| {
+        // Set large timeout for fuzzed tests so test campaign won't stop if fail fast not passed.
+        config.fuzz.timeout = Some(3600);
+        config.invariant.timeout = Some(3600);
+    });
+    prj.add_test(
+        "AnotherCounterTest.sol",
+        r#"
+import {Test} from "forge-std/Test.sol";
+
+contract InvariantHandler is Test {
+    function fuzz_selector(uint256 x) public {
+    }
+}
+
+contract AnotherCounterTest is Test {
+    uint256[] public fixtureAmount = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+    function setUp() public {
+        new InvariantHandler();
+    }
+    // This failure should stop all other tests.
+    function test_Failure() public pure {
+        require(false);
+    }
+
+    function testFuzz_SetNumber(uint256 x) public {
+    }
+
+    function invariant_SetNumber() public {
+    }
+
+    function table_SetNumber(uint256 amount) public {
+        require(amount < 100);
+    }
+}
+"#,
+    )
+    .unwrap();
+    cmd.args(["test", "--fail-fast"]).assert_failure();
+});
