Skip to main content

forge/
symbolic_regression.rs

1use crate::result::{
2    SYMBOLIC_COUNTEREXAMPLE_ARTIFACT_SCHEMA, SYMBOLIC_COUNTEREXAMPLE_ARTIFACT_SCHEMA_VERSION,
3    SuiteResult, SymbolicArtifactRef, SymbolicCounterexampleArtifact,
4    SymbolicCounterexampleArtifactKind, SymbolicRegressionRef, SymbolicReplayStatus,
5};
6use alloy_primitives::{U256, hex};
7use eyre::{Result, bail};
8use foundry_common::{TestFunctionExt, contracts::ContractsByArtifact, fs, sh_warn};
9use foundry_config::Config;
10use foundry_evm::constants::CALLER;
11use foundry_evm_symbolic::SYMBOLIC_VM_COMPAT_ADDRESS;
12use std::{
13    collections::{HashMap, HashSet},
14    fmt::Write,
15    path::{Component, Path, PathBuf},
16};
17
18pub(crate) const SYMBOLIC_REGRESSION_MARKER: &str = "__foundry_symbolic_regression_marker";
19
20/// Configuration for emitting Solidity regression tests from symbolic counterexamples.
21#[derive(Clone, Debug)]
22pub(crate) struct SymbolicRegressionConfig {
23    pub out: Option<PathBuf>,
24    pub overwrite: bool,
25}
26
27/// Solidity regression file emitted from a symbolic counterexample artifact.
28#[derive(Clone, Debug)]
29pub(crate) struct SymbolicRegression {
30    pub artifact: PathBuf,
31    pub path: PathBuf,
32}
33
34struct PlannedSymbolicRegression {
35    regression: SymbolicRegression,
36    contents: String,
37    test: String,
38}
39
40pub(crate) fn emit_symbolic_regressions(
41    config: &Config,
42    regression: &SymbolicRegressionConfig,
43    known_contracts: &ContractsByArtifact,
44    results: &[SymbolicArtifactRef],
45) -> Result<Vec<SymbolicRegression>> {
46    let mut planned = Vec::new();
47    let mut seen_tests = HashSet::new();
48    for artifact_ref in results {
49        let artifact = load_artifact(&artifact_ref.path)?;
50        let (_, contract) = artifact_source_and_contract(&artifact_ref.path, &artifact)?;
51        if contract.ends_with("_SymbolicRegression") {
52            continue;
53        }
54        let key = (
55            artifact.test.contract.clone(),
56            artifact.test.test.clone(),
57            match artifact.kind {
58                SymbolicCounterexampleArtifactKind::SingleCall => "single_call",
59                SymbolicCounterexampleArtifactKind::Sequence => "sequence",
60            },
61        );
62        let suffix = if seen_tests.insert(key) {
63            None
64        } else if let Some(suffix) = handler_regression_suffix(&artifact_ref.path) {
65            Some(suffix)
66        } else {
67            continue;
68        };
69        planned.push(plan_symbolic_regression(
70            config,
71            regression,
72            &artifact_ref.path,
73            &artifact,
74            known_contracts,
75            suffix.as_deref(),
76        )?);
77    }
78
79    ensure_unique_regression_paths(&planned)?;
80
81    let mut emitted = Vec::new();
82    for plan in planned {
83        if let Some(regression) = write_symbolic_regression(regression, plan)? {
84            emitted.push(regression);
85        }
86    }
87    Ok(emitted)
88}
89
90fn artifact_source_and_contract<'a>(
91    artifact_path: &Path,
92    artifact: &'a SymbolicCounterexampleArtifact,
93) -> Result<(&'a str, &'a str)> {
94    let Some((source, contract)) = artifact.test.contract.rsplit_once(':') else {
95        bail!(
96            "symbolic counterexample artifact {} test.contract must be `path:Contract`, got `{}`",
97            artifact_path.display(),
98            artifact.test.contract
99        );
100    };
101    if source.is_empty() || contract.is_empty() {
102        bail!(
103            "symbolic counterexample artifact {} test.contract must be `path:Contract`, got `{}`",
104            artifact_path.display(),
105            artifact.test.contract
106        );
107    }
108    Ok((source, contract))
109}
110
111pub(crate) fn collect_symbolic_artifacts_from_suites<'a>(
112    suites: impl IntoIterator<Item = &'a SuiteResult>,
113) -> Vec<SymbolicArtifactRef> {
114    let mut artifacts = Vec::new();
115    for suite in suites {
116        for result in suite.test_results.values() {
117            for artifact in &result.counterexample_artifacts {
118                if !artifacts.contains(artifact) {
119                    artifacts.push(artifact.clone());
120                }
121            }
122        }
123    }
124    artifacts
125}
126
127pub(crate) fn attach_symbolic_regressions_to_suites<'a>(
128    suites: impl IntoIterator<Item = &'a mut SuiteResult>,
129    regressions: &[SymbolicRegression],
130) {
131    for suite in suites {
132        for result in suite.test_results.values_mut() {
133            for artifact in &result.counterexample_artifacts {
134                for regression in regressions {
135                    if artifact.path == regression.artifact
136                        && !result
137                            .symbolic_regressions
138                            .iter()
139                            .any(|existing| existing.path == regression.path)
140                    {
141                        result.symbolic_regressions.push(SymbolicRegressionRef {
142                            artifact: regression.artifact.clone(),
143                            path: regression.path.clone(),
144                        });
145                    }
146                }
147            }
148        }
149    }
150}
151
152fn load_artifact(path: &Path) -> Result<SymbolicCounterexampleArtifact> {
153    let value = fs::read_json_file::<serde_json::Value>(path)?;
154    let schema_version =
155        value.get("schema_version").and_then(serde_json::Value::as_u64).ok_or_else(|| {
156            eyre::eyre!(
157                "symbolic counterexample artifact {} is missing numeric schema_version",
158                path.display()
159            )
160        })?;
161    if schema_version != u64::from(SYMBOLIC_COUNTEREXAMPLE_ARTIFACT_SCHEMA_VERSION) {
162        bail!(
163            "unsupported symbolic counterexample artifact schema version {} in {}",
164            schema_version,
165            path.display()
166        );
167    }
168    let schema = value.get("schema").and_then(serde_json::Value::as_str).ok_or_else(|| {
169        eyre::eyre!("symbolic counterexample artifact {} is missing string schema", path.display())
170    })?;
171    if schema != SYMBOLIC_COUNTEREXAMPLE_ARTIFACT_SCHEMA {
172        bail!(
173            "unsupported symbolic counterexample artifact schema `{}` in {}",
174            schema,
175            path.display()
176        );
177    }
178    let artifact = serde_json::from_value::<SymbolicCounterexampleArtifact>(value)?;
179    if artifact.replay.status != SymbolicReplayStatus::Confirmed {
180        bail!(
181            "symbolic counterexample artifact {} replay status must be confirmed, got {:?}",
182            path.display(),
183            artifact.replay.status
184        );
185    }
186    if artifact.calls.is_empty() {
187        bail!("symbolic counterexample artifact {} has no calls", path.display());
188    }
189    Ok(artifact)
190}
191
192fn plan_symbolic_regression(
193    config: &Config,
194    regression: &SymbolicRegressionConfig,
195    artifact_path: &Path,
196    artifact: &SymbolicCounterexampleArtifact,
197    known_contracts: &ContractsByArtifact,
198    suffix: Option<&str>,
199) -> Result<PlannedSymbolicRegression> {
200    let (source, contract) = artifact_source_and_contract(artifact_path, artifact)?;
201
202    let test_name =
203        artifact.test.test.split_once('(').map_or(artifact.test.test.as_str(), |(name, _)| name);
204    let contract_ident = sanitize_identifier(contract);
205    let test_ident = sanitize_identifier(test_name);
206    let generated_contract = suffix.map_or_else(
207        || format!("{contract_ident}_{test_ident}_SymbolicRegression"),
208        |suffix| format!("{contract_ident}_{test_ident}_{suffix}_SymbolicRegression"),
209    );
210    let vm_interface = format!("{generated_contract}_Vm");
211    let generated_test = format!("test_regression_{test_ident}_symbolic");
212    let default_path = config.test.join("regressions").join(format!("{generated_contract}.t.sol"));
213    let path = regression.out.as_ref().map_or(default_path, |out| {
214        let out_is_file = if out.exists() {
215            !out.is_dir()
216        } else {
217            out.extension().is_some_and(|ext| ext == std::ffi::OsStr::new("sol"))
218        };
219        if out_is_file { out.clone() } else { out.join(format!("{generated_contract}.t.sol")) }
220    });
221
222    if let Some(parent) = path.parent() {
223        fs::create_dir_all(parent)?;
224    }
225
226    let import_path =
227        relative_solidity_import(path.parent().unwrap_or(&config.root), &config.root.join(source));
228    let mut contents = String::new();
229    writeln!(contents, "// SPDX-License-Identifier: UNLICENSED")?;
230    writeln!(contents, "pragma solidity >=0.8.0;")?;
231    writeln!(contents)?;
232    writeln!(contents, "import \"{import_path}\";")?;
233    writeln!(contents)?;
234    writeln!(contents, "interface {vm_interface} {{")?;
235    writeln!(contents, "    function deal(address who, uint256 newBalance) external;")?;
236    if artifact.calls.iter().any(|call| !call.svm_returns.is_empty()) {
237        writeln!(
238            contents,
239            "    function mockCalls(address callee, bytes calldata data, bytes[] calldata returnData) external;"
240        )?;
241    }
242    writeln!(contents, "    function prank(address msgSender) external;")?;
243    writeln!(contents, "    function roll(uint256 newHeight) external;")?;
244    writeln!(contents, "    function warp(uint256 newTimestamp) external;")?;
245    if !artifact.storage.is_empty() {
246        writeln!(
247            contents,
248            "    function store(address target, bytes32 slot, bytes32 value) external;"
249        )?;
250    }
251    writeln!(contents, "}}")?;
252    writeln!(contents)?;
253    writeln!(contents, "contract {generated_contract} is {contract} {{")?;
254    writeln!(
255        contents,
256        "    {vm_interface} private constant __foundrySymbolicVm = {vm_interface}(address(uint160(uint256(keccak256(\"hevm cheat code\")))));"
257    )?;
258    writeln!(contents)?;
259    writeln!(
260        contents,
261        "    function {SYMBOLIC_REGRESSION_MARKER}() external pure returns (bytes32) {{"
262    )?;
263    writeln!(contents, "        return keccak256(\"foundry.symbolic.regression\");")?;
264    writeln!(contents, "    }}")?;
265    writeln!(contents)?;
266    writeln!(contents, "    function {generated_test}() public payable {{")?;
267    for assignment in &artifact.storage {
268        writeln!(
269            contents,
270            "        __foundrySymbolicVm.store({}, bytes32(uint256({})), bytes32(uint256({})));",
271            assignment.address,
272            u256_literal(assignment.slot),
273            u256_literal(assignment.value)
274        )?;
275    }
276    match artifact.kind {
277        SymbolicCounterexampleArtifactKind::SingleCall => {
278            let call = artifact.calls.first().expect("single-call artifact has at least one call");
279            write_call(&mut contents, call, "address(this)", true, None)?;
280        }
281        SymbolicCounterexampleArtifactKind::Sequence => {
282            let call_after_invariant = call_after_invariant(known_contracts, artifact)?;
283            for (index, call) in artifact.calls.iter().enumerate() {
284                write_call(
285                    &mut contents,
286                    call,
287                    &format!("address({})", call.target),
288                    artifact.replay_semantics.fail_on_revert,
289                    Some(index),
290                )?;
291            }
292            writeln!(contents, "        __foundrySymbolicVm.prank({CALLER});")?;
293            writeln!(
294                contents,
295                "        __foundrySymbolicRegressionCall(address(this), hex\"{}\", 0, true);",
296                hex::encode(selector_from_signature(&artifact.test.test))
297            )?;
298            if call_after_invariant {
299                writeln!(contents, "        __foundrySymbolicVm.prank({CALLER});")?;
300                writeln!(
301                    contents,
302                    "        __foundrySymbolicRegressionCall(address(this), hex\"{}\", 0, true);",
303                    hex::encode(selector_from_signature("afterInvariant()"))
304                )?;
305            }
306        }
307    }
308    writeln!(contents, "    }}")?;
309    writeln!(contents)?;
310    writeln!(
311        contents,
312        "    function __foundrySymbolicRegressionCall(address target, bytes memory data, uint256 value, bool bubbleFailure) internal returns (bool) {{"
313    )?;
314    writeln!(contents, "        if (target != address(this)) {{")?;
315    writeln!(contents, "            uint256 codeSize;")?;
316    writeln!(contents, "            assembly {{ codeSize := extcodesize(target) }}")?;
317    writeln!(
318        contents,
319        "            require(codeSize != 0, \"symbolic regression target has no code\");"
320    )?;
321    writeln!(contents, "        }}")?;
322    writeln!(contents, "        (bool ok, bytes memory ret) = target.call{{value: value}}(data);")?;
323    writeln!(contents, "        if (!ok && bubbleFailure) {{")?;
324    writeln!(contents, "            assembly {{")?;
325    writeln!(contents, "                revert(add(ret, 0x20), mload(ret))")?;
326    writeln!(contents, "            }}")?;
327    writeln!(contents, "        }}")?;
328    writeln!(contents, "        return ok;")?;
329    writeln!(contents, "    }}")?;
330    writeln!(contents, "}}")?;
331
332    Ok(PlannedSymbolicRegression {
333        regression: SymbolicRegression { artifact: artifact_path.to_path_buf(), path },
334        contents,
335        test: format!("{}::{}", artifact.test.contract, artifact.test.test),
336    })
337}
338
339fn ensure_unique_regression_paths(planned: &[PlannedSymbolicRegression]) -> Result<()> {
340    let mut seen = HashMap::<&Path, &PlannedSymbolicRegression>::new();
341    for plan in planned {
342        if let Some(previous) = seen.insert(&plan.regression.path, plan) {
343            bail!(
344                "multiple symbolic regressions resolve to {}; {} and {} cannot share one output file",
345                plan.regression.path.display(),
346                previous.test,
347                plan.test
348            );
349        }
350    }
351    Ok(())
352}
353
354fn write_symbolic_regression(
355    regression: &SymbolicRegressionConfig,
356    plan: PlannedSymbolicRegression,
357) -> Result<Option<SymbolicRegression>> {
358    let SymbolicRegression { artifact, path } = &plan.regression;
359    if path.exists() && !regression.overwrite {
360        if std::fs::read_to_string(path).is_ok_and(|existing| existing == plan.contents) {
361            return Ok(Some(plan.regression));
362        }
363        sh_warn!(
364            "Regression test {} already exists; skipping {} (pass --regression-overwrite to replace it)",
365            path.display(),
366            artifact.display()
367        )?;
368        return Ok(None);
369    }
370
371    std::fs::write(path, plan.contents)?;
372    Ok(Some(plan.regression))
373}
374
375fn write_call(
376    out: &mut String,
377    call: &crate::result::SymbolicCounterexampleCall,
378    target: &str,
379    bubble_failure: bool,
380    sequence_call_index: Option<usize>,
381) -> Result<()> {
382    if let Some(warp) = call.warp {
383        writeln!(
384            out,
385            "        __foundrySymbolicVm.warp(block.timestamp + {});",
386            u256_literal(warp)
387        )?;
388    }
389    if let Some(roll) = call.roll {
390        writeln!(out, "        __foundrySymbolicVm.roll(block.number + {});", u256_literal(roll))?;
391    }
392    if let Some(value) = call.value
393        && !value.is_zero()
394    {
395        if let Some(index) = sequence_call_index {
396            writeln!(
397                out,
398                "        uint256 __foundrySymbolicValue{index} = {} <= address({}).balance ? {} : address({}).balance;",
399                u256_literal(value),
400                call.sender,
401                u256_literal(value),
402                call.sender
403            )?;
404            writeln!(
405                out,
406                "        if (__foundrySymbolicValue{index} != 0 && {} != address(this)) {{",
407                call.sender
408            )?;
409            writeln!(
410                out,
411                "            __foundrySymbolicVm.deal(address(this), address(this).balance + __foundrySymbolicValue{index});"
412            )?;
413            writeln!(
414                out,
415                "            __foundrySymbolicVm.deal({}, address({}).balance - __foundrySymbolicValue{index});",
416                call.sender, call.sender
417            )?;
418            writeln!(out, "        }}")?;
419        } else {
420            writeln!(
421                out,
422                "        __foundrySymbolicVm.deal(address(this), {});",
423                u256_literal(value)
424            )?;
425            writeln!(
426                out,
427                "        __foundrySymbolicVm.deal({}, {});",
428                call.sender,
429                u256_literal(value)
430            )?;
431        }
432    }
433    if !call.svm_returns.is_empty() {
434        writeln!(out, "        {{")?;
435        writeln!(
436            out,
437            "            bytes[] memory svmReturns = new bytes[]({});",
438            call.svm_returns.len()
439        )?;
440        for (index, data) in call.svm_returns.iter().enumerate() {
441            writeln!(out, "            svmReturns[{index}] = hex\"{}\";", hex::encode(data))?;
442        }
443        writeln!(
444            out,
445            "            __foundrySymbolicVm.mockCalls({SYMBOLIC_VM_COMPAT_ADDRESS}, \"\", svmReturns);"
446        )?;
447        writeln!(out, "        }}")?;
448    }
449    writeln!(out, "        __foundrySymbolicVm.prank({});", call.sender)?;
450    let value = sequence_call_index
451        .filter(|_| call.value.is_some_and(|value| !value.is_zero()))
452        .map_or_else(
453            || call.value.map_or_else(|| "0".to_string(), u256_literal),
454            |index| format!("__foundrySymbolicValue{index}"),
455        );
456    if let Some(index) = sequence_call_index {
457        writeln!(
458            out,
459            "        bool __foundrySymbolicOk{index} = __foundrySymbolicRegressionCall({target}, hex\"{}\", {}, {});",
460            hex::encode(call.calldata.as_ref()),
461            value,
462            if bubble_failure { "true" } else { "false" }
463        )?;
464        if call.value.is_some_and(|value| !value.is_zero()) {
465            writeln!(
466                out,
467                "        if (__foundrySymbolicValue{index} != 0 && {} != address(this)) {{",
468                call.sender
469            )?;
470            writeln!(out, "            if (!__foundrySymbolicOk{index}) {{")?;
471            writeln!(
472                out,
473                "                __foundrySymbolicVm.deal({}, address({}).balance + __foundrySymbolicValue{index});",
474                call.sender, call.sender
475            )?;
476            writeln!(
477                out,
478                "                __foundrySymbolicVm.deal(address(this), address(this).balance - __foundrySymbolicValue{index});"
479            )?;
480            writeln!(out, "            }}")?;
481            writeln!(out, "        }}")?;
482        }
483    } else {
484        writeln!(
485            out,
486            "        __foundrySymbolicRegressionCall({target}, hex\"{}\", {}, {});",
487            hex::encode(call.calldata.as_ref()),
488            value,
489            if bubble_failure { "true" } else { "false" }
490        )?;
491    }
492    Ok(())
493}
494
495fn selector_from_signature(signature: &str) -> [u8; 4] {
496    let hash = alloy_primitives::keccak256(signature.as_bytes());
497    [hash[0], hash[1], hash[2], hash[3]]
498}
499
500fn u256_literal(value: U256) -> String {
501    if value <= U256::from(u128::MAX) { value.to_string() } else { format!("{value:#x}") }
502}
503
504fn sanitize_identifier(value: &str) -> String {
505    let mut ident = String::with_capacity(value.len());
506    for ch in value.chars() {
507        if ch.is_ascii_alphanumeric() || ch == '_' {
508            ident.push(ch);
509        } else {
510            ident.push('_');
511        }
512    }
513    if ident.is_empty() || ident.as_bytes()[0].is_ascii_digit() {
514        ident.insert(0, '_');
515    }
516    ident
517}
518
519fn handler_regression_suffix(path: &Path) -> Option<String> {
520    let stem = path.file_stem()?.to_string_lossy();
521    stem.starts_with("handler-").then(|| sanitize_identifier(&stem))
522}
523
524fn call_after_invariant(
525    known_contracts: &ContractsByArtifact,
526    artifact: &SymbolicCounterexampleArtifact,
527) -> Result<bool> {
528    let Some((_, contract)) =
529        known_contracts.find_by_name_or_identifier(&artifact.test.contract)?
530    else {
531        return Ok(false);
532    };
533    let mut after_invariant_fns =
534        contract.abi.functions().filter(|func| func.name.is_after_invariant());
535    let Some(after_invariant) = after_invariant_fns.next() else {
536        return Ok(false);
537    };
538    Ok(after_invariant.name == "afterInvariant" && after_invariant_fns.next().is_none())
539}
540
541fn relative_solidity_import(from_dir: &Path, to_file: &Path) -> String {
542    let from = std::fs::canonicalize(from_dir).unwrap_or_else(|_| from_dir.to_path_buf());
543    let to = std::fs::canonicalize(to_file).unwrap_or_else(|_| to_file.to_path_buf());
544    let from = normalized_components(&from);
545    let to = normalized_components(&to);
546    let shared = from.iter().zip(&to).take_while(|(left, right)| left == right).count();
547    let mut parts = Vec::new();
548    parts.extend(std::iter::repeat_n("..".to_string(), from.len().saturating_sub(shared)));
549    parts.extend(to[shared..].iter().cloned());
550    if parts.is_empty() {
551        ".".to_string()
552    } else {
553        let path = parts.join("/");
554        if path.starts_with('.') { path } else { format!("./{path}") }
555    }
556}
557
558fn normalized_components(path: &Path) -> Vec<String> {
559    path.components()
560        .filter_map(|component| match component {
561            Component::Normal(value) => Some(value.to_string_lossy().to_string()),
562            Component::ParentDir => Some("..".to_string()),
563            Component::CurDir => None,
564            Component::RootDir | Component::Prefix(_) => {
565                Some(component.as_os_str().to_string_lossy().to_string())
566            }
567        })
568        .collect()
569}
570
571#[cfg(test)]
572mod tests {
573    use super::*;
574    use crate::result::{
575        SymbolicCallTrace, SymbolicCounterexample, SymbolicCounterexampleReplaySemantics,
576        SymbolicCounterexampleTestIdentity, SymbolicReplayMetadata, SymbolicResult,
577    };
578    use alloy_primitives::{Address, Bytes};
579    use foundry_config::SymbolicConfig;
580    use foundry_evm_symbolic::SymbolicStats;
581
582    fn config(root: &Path) -> Config {
583        Config { root: root.to_path_buf(), test: root.join("test"), ..Default::default() }
584    }
585
586    fn artifact(
587        kind: SymbolicCounterexampleArtifactKind,
588        calls: Vec<crate::result::SymbolicCounterexampleCall>,
589    ) -> SymbolicCounterexampleArtifact {
590        let call = calls.first().expect("artifact has at least one call");
591        let symbolic = SymbolicResult::fail_counterexample(
592            &SymbolicConfig::default(),
593            SymbolicStats::default(),
594            SymbolicCallTrace::none(),
595            SymbolicCounterexample {
596                calldata: call.calldata.clone(),
597                args: None,
598                raw_args: None,
599                value: call.value,
600                svm_returns: Vec::new(),
601            },
602        );
603        let mut artifact = SymbolicCounterexampleArtifact::new(
604            kind,
605            SymbolicCounterexampleTestIdentity {
606                contract: "test/Regression.t.sol:Regression".to_string(),
607                test: "invariant_value()".to_string(),
608            },
609            &symbolic,
610            SymbolicCounterexampleReplaySemantics { fail_on_revert: false },
611            calls,
612        );
613        artifact.replay = SymbolicReplayMetadata::confirmed();
614        artifact
615    }
616
617    fn value_call(target: Address) -> crate::result::SymbolicCounterexampleCall {
618        crate::result::SymbolicCounterexampleCall {
619            warp: None,
620            roll: None,
621            sender: Address::repeat_byte(0xb0),
622            target,
623            calldata: Bytes::from_static(&[0x12, 0x34, 0x56, 0x78]),
624            value: Some(U256::from(10)),
625            contract_name: None,
626            function_name: None,
627            signature: None,
628            args: None,
629            raw_args: None,
630            svm_returns: Vec::new(),
631        }
632    }
633
634    fn plan(
635        kind: SymbolicCounterexampleArtifactKind,
636        calls: Vec<crate::result::SymbolicCounterexampleCall>,
637    ) -> String {
638        let temp = tempfile::tempdir().unwrap();
639        let source = temp.path().join("test/Regression.t.sol");
640        fs::create_dir_all(source.parent().unwrap()).unwrap();
641        std::fs::write(&source, "contract Regression {}").unwrap();
642
643        let artifact_path = temp.path().join("cache/artifact.json");
644        let artifact = artifact(kind, calls);
645        plan_symbolic_regression(
646            &config(temp.path()),
647            &SymbolicRegressionConfig { out: None, overwrite: false },
648            &artifact_path,
649            &artifact,
650            &ContractsByArtifact::default(),
651            None,
652        )
653        .unwrap()
654        .contents
655    }
656
657    #[test]
658    fn sequence_regression_clamps_and_debits_sender_balance() {
659        let contents = plan(
660            SymbolicCounterexampleArtifactKind::Sequence,
661            vec![value_call(Address::repeat_byte(0x7f)), value_call(Address::repeat_byte(0x8f))],
662        );
663        let lowercase = contents.to_lowercase();
664
665        assert!(lowercase.contains(
666            "uint256 __foundrysymbolicvalue0 = 10 <= address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance ? 10 : address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance;"
667        ));
668        assert!(lowercase.contains(
669            "uint256 __foundrysymbolicvalue1 = 10 <= address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance ? 10 : address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance;"
670        ));
671        assert!(contents.contains("if (__foundrySymbolicValue0 != 0"));
672        assert!(contents.contains("if (__foundrySymbolicValue1 != 0"));
673        assert!(contents.contains(
674            "__foundrySymbolicVm.deal(address(this), address(this).balance + __foundrySymbolicValue0);"
675        ));
676        assert!(contents.contains("bool __foundrySymbolicOk0 = __foundrySymbolicRegressionCall"));
677        assert!(contents.contains("if (!__foundrySymbolicOk0) {"));
678        assert!(lowercase.contains(
679            "__foundrysymbolicvm.deal(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0, address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance - __foundrysymbolicvalue0);"
680        ));
681        assert!(lowercase.contains(
682            "__foundrysymbolicvm.deal(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0, address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance - __foundrysymbolicvalue1);"
683        ));
684        assert!(lowercase.contains(
685            "__foundrysymbolicvm.deal(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0, address(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0).balance + __foundrysymbolicvalue0);"
686        ));
687        assert!(contents.contains(
688            "__foundrySymbolicVm.deal(address(this), address(this).balance - __foundrySymbolicValue0);"
689        ));
690        assert!(lowercase.contains(
691            "__foundrysymbolicregressioncall(address(0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f), hex\"12345678\", __foundrysymbolicvalue0, false);"
692        ));
693        assert!(lowercase.contains(
694            "__foundrysymbolicregressioncall(address(0x8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f8f), hex\"12345678\", __foundrysymbolicvalue1, false);"
695        ));
696        assert!(
697            !lowercase.contains(
698                "__foundrysymbolicvm.deal(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0, 10);"
699            )
700        );
701    }
702
703    #[test]
704    fn single_call_regression_preserves_exact_value_funding() {
705        let contents = plan(
706            SymbolicCounterexampleArtifactKind::SingleCall,
707            vec![value_call(Address::repeat_byte(0x7f))],
708        );
709        let lowercase = contents.to_lowercase();
710
711        assert!(contents.contains("__foundrySymbolicVm.deal(address(this), 10);"));
712        assert!(
713            lowercase.contains(
714                "__foundrysymbolicvm.deal(0xb0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0, 10);"
715            )
716        );
717        assert!(contents.contains(
718            "__foundrySymbolicRegressionCall(address(this), hex\"12345678\", 10, true);"
719        ));
720        assert!(!contents.contains("bool __foundrySymbolicOk0 ="));
721    }
722
723    #[test]
724    fn relative_solidity_import_canonicalizes_symlinked_absolute_paths() {
725        let tmp = Path::new("/tmp");
726        let Ok(canonical_tmp) = std::fs::canonicalize(tmp) else { return };
727        if canonical_tmp == tmp {
728            return;
729        }
730
731        let root =
732            tmp.join(format!("foundry-symbolic-regression-import-test-{}", std::process::id()));
733        let _ = std::fs::remove_dir_all(&root);
734        let from_dir = root.join("test");
735        std::fs::create_dir_all(&from_dir).unwrap();
736        let to_file = from_dir.join("Original.t.sol");
737        std::fs::write(&to_file, "contract Original {}").unwrap();
738        let canonical_to_file = std::fs::canonicalize(&to_file).unwrap();
739
740        let import = relative_solidity_import(&from_dir, &canonical_to_file);
741
742        let _ = std::fs::remove_dir_all(&root);
743        assert_eq!(import, "./Original.t.sol");
744    }
745}