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#[derive(Clone, Debug)]
22pub(crate) struct SymbolicRegressionConfig {
23 pub out: Option<PathBuf>,
24 pub overwrite: bool,
25}
26
27#[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}