use std::{
fs,
path::{Path, PathBuf},
process::Command,
};
use sha2::{Digest, Sha256};
fn buildc() -> Command {
let mut cmd = Command::new(env!("CARGO_BIN_EXE_buildc"));
cmd.env("BUILDLANG_STDLIB", repo_root().join("stdlib"));
cmd
}
fn repo_root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.parent()
.expect("compiler manifest should have a repository parent")
.to_path_buf()
}
fn quickstart_example(name: &str) -> PathBuf {
repo_root().join("examples").join("quickstart").join(name)
}
fn c_backend_ready() -> bool {
let output = buildc().arg("doctor").output().expect("run buildc doctor");
let stdout = String::from_utf8_lossy(&output.stdout);
stdout.contains("Ready for practical C-backend examples: yes")
}
fn receipt_from_stdout(output: &std::process::Output) -> serde_json::Value {
serde_json::from_slice(&output.stdout).unwrap_or_else(|err| {
panic!(
"stdout should be JSON receipt: {err}\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
)
})
}
fn sha256_hex(bytes: &[u8]) -> String {
let digest = Sha256::digest(bytes);
let mut hex = String::with_capacity(digest.len() * 2);
for byte in digest {
use std::fmt::Write as _;
write!(&mut hex, "{byte:02x}").expect("write digest hex");
}
hex
}
fn write_temp_policy(label: &str, json: &str) -> PathBuf {
let policy = std::env::temp_dir().join(format!(
"buildlang_check_policy_{}_{}.json",
label,
std::process::id()
));
fs::write(&policy, json)
.unwrap_or_else(|err| panic!("write policy fixture {}: {}", policy.display(), err));
policy
}
fn input_digest_hex(receipt: &serde_json::Value, role: &str, source_suffix: &str) -> String {
let records = receipt["input_digests"]
.as_array()
.expect("input_digests should be an array");
let record = records
.iter()
.find(|record| {
record["role"] == role
&& record["source"]
.as_str()
.is_some_and(|source| source.ends_with(source_suffix))
})
.unwrap_or_else(|| {
panic!("missing input digest role={role:?} suffix={source_suffix:?} in {records:#?}")
});
assert_eq!(record["digest"]["algorithm"], "sha256");
let hex = record["digest"]["hex"]
.as_str()
.expect("input digest hex should be a string");
assert_eq!(hex.len(), 64);
hex.to_string()
}
fn input_graph_digest_hex(receipt: &serde_json::Value) -> String {
assert_eq!(receipt["input_graph_digest"]["algorithm"], "sha256");
let hex = receipt["input_graph_digest"]["hex"]
.as_str()
.expect("input graph digest hex should be a string");
assert_eq!(hex.len(), 64);
hex.to_string()
}
fn verification_check<'a>(report: &'a serde_json::Value, name: &str) -> &'a serde_json::Value {
report["checks"]
.as_array()
.expect("verification checks should be an array")
.iter()
.find(|check| check["name"] == name)
.unwrap_or_else(|| panic!("missing verification check {name:?} in {report:#?}"))
}
fn copy_dir_recursive(source: &Path, destination: &Path) {
fs::create_dir_all(destination).unwrap_or_else(|err| {
panic!(
"create destination directory {}: {}",
destination.display(),
err
)
});
for entry in fs::read_dir(source)
.unwrap_or_else(|err| panic!("read source directory {}: {}", source.display(), err))
{
let entry = entry.expect("read directory entry");
let entry_path = entry.path();
let destination_path = destination.join(entry.file_name());
if entry
.file_type()
.unwrap_or_else(|err| panic!("read file type for {}: {}", entry_path.display(), err))
.is_dir()
{
copy_dir_recursive(&entry_path, &destination_path);
} else {
fs::copy(&entry_path, &destination_path).unwrap_or_else(|err| {
panic!(
"copy {} to {}: {}",
entry_path.display(),
destination_path.display(),
err
)
});
}
}
}
fn temp_semantic_corpus(label: &str) -> PathBuf {
let destination = std::env::temp_dir().join(format!(
"buildlang_semantic_corpus_{}_{}",
label,
std::process::id()
));
let _ = fs::remove_dir_all(&destination);
copy_dir_recursive(&repo_root().join("semantic-corpus"), &destination);
destination
}
fn write_substrate_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("substrate-semantic-corpus-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read substrate receipt"))
.expect("parse substrate receipt");
let receipt = transform(receipt);
let rendered =
serde_json::to_string_pretty(&receipt).expect("render modified substrate receipt");
fs::write(&receipt_path, format!("{rendered}\n")).expect("write modified substrate receipt");
}
fn write_mir_representation_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("mir-representation-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read MIR representation receipt"))
.expect("parse MIR representation receipt");
let receipt = transform(receipt);
let rendered =
serde_json::to_string_pretty(&receipt).expect("render modified MIR representation receipt");
fs::write(&receipt_path, format!("{rendered}\n"))
.expect("write modified MIR representation receipt");
}
fn write_memory_layout_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("memory-layout-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read memory layout receipt"))
.expect("parse memory layout receipt");
let receipt = transform(receipt);
let rendered =
serde_json::to_string_pretty(&receipt).expect("render modified memory layout receipt");
fs::write(&receipt_path, format!("{rendered}\n"))
.expect("write modified memory layout receipt");
}
fn write_symbol_graph_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("symbol-graph-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read symbol graph receipt"))
.expect("parse symbol graph receipt");
let rendered = serde_json::to_string_pretty(&transform(receipt))
.expect("render modified symbol graph receipt");
fs::write(&receipt_path, format!("{rendered}\n")).expect("write modified symbol graph receipt");
}
fn write_module_graph_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("module-graph-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read module graph receipt"))
.expect("parse module graph receipt");
let rendered = serde_json::to_string_pretty(&transform(receipt))
.expect("render modified module graph receipt");
fs::write(&receipt_path, format!("{rendered}\n")).expect("write modified module graph receipt");
}
fn write_lsp_dispatch_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("lsp-dispatch-2026-06-18.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read LSP dispatch receipt"))
.expect("parse LSP dispatch receipt");
let rendered = serde_json::to_string_pretty(&transform(receipt))
.expect("render modified LSP dispatch receipt");
fs::write(&receipt_path, format!("{rendered}\n")).expect("write modified LSP receipt");
}
fn assert_corpus_verify_rejects(corpus_root: &Path, expected_stderr: &str) {
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(corpus_root)
.output()
.expect("run buildc corpus verify against symbol graph fixture");
let _ = fs::remove_dir_all(corpus_root);
assert!(!output.status.success(), "fixture should fail");
assert!(
String::from_utf8_lossy(&output.stderr).contains(expected_stderr),
"stderr should contain {expected_stderr:?}:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn help_lists_doctor_command() {
let output = buildc().arg("--help").output().expect("run buildc --help");
assert!(
output.status.success(),
"buildc --help should exit successfully"
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("doctor"),
"help should list doctor command:\n{}",
stdout
);
}
#[test]
fn doctor_reports_adoption_readiness_summary() {
let output = buildc().arg("doctor").output().expect("run buildc doctor");
assert!(
output.status.success(),
"buildc doctor should exit successfully; stderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
assert!(
output.stderr.is_empty(),
"buildc doctor should report diagnostics on stdout only:\n{}",
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
for expected in [
"BuildLang Doctor",
"buildc:",
"C backend:",
"stdlib:",
"registry:",
"Backend maturity:",
"Substrate evidence:",
"receipt ok",
"buildlang-substrate-receipt/v0",
"corpus ok",
"9 semantic program(s)",
"c anchor",
"rust subset",
"spirv unverified",
"memory partial",
"6 verified surface(s), 3 known gap(s)",
"repr MIR",
"c primary",
"rust experimental",
] {
assert!(
stdout.contains(expected),
"doctor output should contain {expected:?}:\n{}",
stdout
);
}
}
#[test]
fn help_lists_corpus_command() {
let output = buildc().arg("--help").output().expect("run buildc --help");
assert!(
output.status.success(),
"buildc --help should exit successfully"
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
stdout.contains("corpus"),
"help should list corpus command:\n{}",
stdout
);
}
#[test]
fn check_reports_capability_effect_for_ambient_file_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_capability_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { read_file("ops.txt"); }"#)
.expect("write capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"ambient file call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("read_file"),
"diagnostic should name triggering ambient call:\n{}",
stderr
);
}
#[test]
fn check_reports_capability_effect_for_qualified_ambient_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_qualified_capability_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { io::read_file("ops.txt"); }"#)
.expect("write qualified capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"qualified ambient file call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("io::read_file"),
"diagnostic should name qualified ambient call:\n{}",
stderr
);
}
#[test]
fn check_reports_capability_effect_for_gpu_runtime_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_gpu_capability_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { build_vk_init(); }"#).expect("write gpu capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"GPU runtime call should fail without Gpu effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Gpu"),
"diagnostic should name Gpu effect:\n{}",
stderr
);
assert!(
stderr.contains("build_vk_init"),
"diagnostic should name triggering GPU helper:\n{}",
stderr
);
}
#[test]
fn check_rejects_workgroup_barrier_without_gpu_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_workgroup_barrier_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { workgroupBarrier(); }"#)
.expect("write workgroup barrier fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"workgroupBarrier() should fail the effect check without a ~Gpu declaration"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Gpu"),
"diagnostic should name the Gpu effect:\n{}",
stderr
);
assert!(
stderr.contains("workgroupBarrier"),
"diagnostic should name the triggering workgroupBarrier intrinsic:\n{}",
stderr
);
}
#[test]
fn check_rejects_workgroup_array_without_gpu_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_workgroup_array_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { let s = workgroupArray(64); }"#)
.expect("write workgroup array fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"workgroupArray() should fail the effect check without a ~Gpu declaration"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Gpu"),
"diagnostic should name the Gpu effect:\n{}",
stderr
);
assert!(
stderr.contains("workgroupArray"),
"diagnostic should name the triggering workgroupArray intrinsic:\n{}",
stderr
);
}
#[test]
fn check_receipt_stdout_records_passing_capabilities() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_pass_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write passing receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"passing receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt: serde_json::Value =
serde_json::from_slice(&output.stdout).expect("stdout should be JSON receipt");
assert_eq!(receipt["schema"], "buildlang-check-receipt/v1");
assert_eq!(receipt["status"], "passed");
assert_eq!(receipt["compiler"], "buildc");
assert_eq!(receipt["compiler_version"], env!("CARGO_PKG_VERSION"));
assert_eq!(receipt["language_version"], "1.0.0");
assert_eq!(receipt["source_digest"]["algorithm"], "sha256");
let digest = receipt["source_digest"]["hex"]
.as_str()
.expect("source digest hex string");
assert_eq!(digest.len(), 64);
assert!(
digest
.chars()
.all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase()),
"digest should be lowercase hex: {digest}"
);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Console"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Console"],
serde_json::json!(["println!"])
);
assert!(receipt["diagnostics"].as_array().unwrap().is_empty());
}
#[test]
fn check_reports_capability_effect_for_include_str_macro() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_include_str_capability_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"fn main() { let embedded = include_str!("ops.txt"); }"#,
)
.expect("write include_str macro capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"include_str! should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("include_str!"),
"diagnostic should name triggering include_str macro:\n{}",
stderr
);
}
#[test]
fn check_reports_capability_effect_for_ambient_call_inside_macro_argument() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_macro_arg_capability_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"fn main() ~ Console { println!("{}", read_file("ops.txt")); }"#,
)
.expect("write macro argument capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"macro argument ambient file call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("read_file"),
"diagnostic should name triggering macro argument ambient call:\n{}",
stderr
);
}
#[test]
fn check_reports_capability_effect_for_macro_argument_call_in_external_module() {
let dir = std::env::temp_dir().join(format!(
"buildlang_module_macro_arg_capability_gate_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create module macro argument fixture dir");
let entry = dir.join("main.bld");
let module = dir.join("ops.bld");
fs::write(
&entry,
r#"mod ops;
fn main() {}
"#,
)
.expect("write module macro argument entry fixture");
fs::write(
&module,
r#"fn leak() ~ Console {
println!("{}", read_file("ops.txt"));
}
"#,
)
.expect("write module macro argument module fixture");
let output = buildc()
.arg("check")
.arg(&entry)
.output()
.expect("run buildc check");
let _ = fs::remove_dir_all(&dir);
assert!(
!output.status.success(),
"external module macro argument ambient file call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("read_file"),
"diagnostic should name triggering module macro argument ambient call:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_env_macro_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_env_macro_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"fn main() ~ Environment { let token_name = env!("TOKEN"); }"#,
)
.expect("write env macro receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.env("TOKEN", "fixture-value")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"stdout:
{}
stderr:
{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Environment"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Environment"],
serde_json::json!(["env!"])
);
}
#[test]
fn check_receipt_records_macro_argument_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_macro_arg_capability_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"fn main() ~ Console + FileSystem { println!("{}", read_file("ops.txt")); }"#,
)
.expect("write macro argument capability receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"macro argument capability receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Console", "FileSystem"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Console"],
serde_json::json!(["println!"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["FileSystem"],
serde_json::json!(["read_file"])
);
}
#[test]
fn check_receipt_records_macro_argument_capability_source_in_external_module() {
let dir = std::env::temp_dir().join(format!(
"buildlang_check_receipt_module_macro_arg_capability_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create module macro argument receipt fixture dir");
let entry = dir.join("main.bld");
let module = dir.join("ops.bld");
fs::write(
&entry,
r#"mod ops;
fn main() {}
"#,
)
.expect("write module macro argument receipt entry fixture");
fs::write(
&module,
r#"fn leak() ~ Console + FileSystem {
println!("{}", read_file("ops.txt"));
}
"#,
)
.expect("write module macro argument receipt module fixture");
let output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_dir_all(&dir);
assert!(
output.status.success(),
"external module macro argument capability receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["ops_leak"],
serde_json::json!(["Console", "FileSystem"])
);
assert_eq!(
receipt["observed_capabilities"]["ops_leak"]["Console"],
serde_json::json!(["println!"])
);
assert_eq!(
receipt["observed_capabilities"]["ops_leak"]["FileSystem"],
serde_json::json!(["read_file"])
);
}
#[test]
fn check_receipt_records_gpu_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_gpu_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() ~ Gpu { build_vk_init(); }"#)
.expect("write gpu receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"GPU receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Gpu"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Gpu"],
serde_json::json!(["build_vk_init"])
);
}
#[test]
fn check_receipt_records_graphics_runtime_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_graphics_runtime_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
extern "C" {
fn build_gfx_init(width: i32, height: i32, title: &str) -> i32;
}
fn main() ~ Gpu {
build_gfx_init(800, 600, "BuildLang Triangle");
}
"#,
)
.expect("write graphics runtime receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"graphics runtime receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Gpu"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Gpu"],
serde_json::json!(["build_gfx_init"])
);
}
#[test]
fn check_receipt_records_qualified_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_qualified_capability_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"fn main() ~ FileSystem { io::read_file("ops.txt"); }"#,
)
.expect("write qualified capability receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"qualified capability receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]["FileSystem"],
serde_json::json!(["io::read_file"])
);
}
#[test]
fn check_receipt_records_foreign_call_as_direct_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_foreign_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
extern "C" { fn touch(); }
fn main() ~ Foreign {
touch();
}
"#,
)
.expect("write foreign receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"foreign receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Foreign"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Foreign"],
serde_json::json!(["touch"])
);
assert_eq!(
receipt["propagated_effects"]["main"]
.as_object()
.expect("main propagated effects")
.len(),
0
);
}
#[test]
fn check_receipt_records_foreign_static_as_direct_capability_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_foreign_static_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
extern "C" { static BUILD_ERRNO: i32; }
fn main() ~ Foreign {
let code = BUILD_ERRNO;
}
"#,
)
.expect("write foreign static receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"foreign static receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Foreign"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Foreign"],
serde_json::json!(["BUILD_ERRNO"])
);
assert_eq!(
receipt["propagated_effects"]["main"]
.as_object()
.expect("main propagated effects")
.len(),
0
);
}
#[test]
fn check_reports_foreign_call_inside_macro_argument() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_macro_arg_foreign_call_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
extern "C" { fn touch(); }
fn main() ~ Console {
println!("{}", touch());
}
"#,
)
.expect("write macro argument foreign call fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"macro argument foreign call should fail without Foreign effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Foreign"),
"diagnostic should name Foreign effect:\n{}",
stderr
);
assert!(
stderr.contains("touch"),
"diagnostic should name triggering foreign call:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_foreign_static_inside_macro_argument() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_macro_arg_foreign_static_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
extern "C" { static BUILD_ERRNO: i32; }
fn main() ~ Console + Foreign {
println!("{}", BUILD_ERRNO);
}
"#,
)
.expect("write macro argument foreign static receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"macro argument foreign static receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Console", "Foreign"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Console"],
serde_json::json!(["println!"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]["Foreign"],
serde_json::json!(["BUILD_ERRNO"])
);
}
#[test]
fn check_receipt_records_propagated_effects_separately() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_propagated_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write propagated receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["load_config"]["FileSystem"],
serde_json::json!(["read_file"])
);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["load_config"]
.as_object()
.expect("load_config propagated effects")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config"])
);
}
#[test]
fn check_reports_effect_for_effectful_method_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_method_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Config;
impl Config {
fn load(self) ~ FileSystem {
read_file("ops.txt");
}
}
fn main() {
let config = Config;
config.load();
}
"#,
)
.expect("write effectful method fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful method call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("load"),
"diagnostic should name triggering method:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_method_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_method_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Config;
impl Config {
fn load(self) ~ FileSystem {
read_file("ops.txt");
}
}
fn main() ~ FileSystem {
let config = Config;
config.load();
}
"#,
)
.expect("write effectful method receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"effectful method receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["load"]["FileSystem"],
serde_json::json!(["read_file"])
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["Config.load"])
);
}
#[test]
fn check_reports_effect_for_effectful_associated_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_associated_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Config;
impl Config {
fn load() ~ FileSystem {
read_file("ops.txt");
}
}
fn main() {
Config::load();
}
"#,
)
.expect("write effectful associated function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful associated function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("Config::load"),
"diagnostic should name triggering associated function:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_associated_function_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_associated_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Config;
impl Config {
fn load() ~ FileSystem {
read_file("ops.txt");
}
}
fn main() ~ FileSystem {
Config::load();
}
"#,
)
.expect("write effectful associated function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"effectful associated function receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["load"]["FileSystem"],
serde_json::json!(["read_file"])
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["Config::load"])
);
}
#[test]
fn check_reports_effect_for_effectful_trait_object_method_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_trait_object_method_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
trait Loader {
fn load(self) ~ FileSystem;
}
fn run(loader: dyn Loader) {
loader.load();
}
"#,
)
.expect("write effectful trait object method fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful dyn trait method call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("Loader.load"),
"diagnostic should name triggering trait object method:\n{}",
stderr
);
}
#[test]
fn check_reports_effect_for_effectful_callback_parameter() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_callback_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: fn() with FileSystem) {
loader();
}
"#,
)
.expect("write effectful callback fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful callback should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loader"),
"diagnostic should name callback source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_callback_parameter_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_callback_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: fn() with FileSystem) ~ FileSystem {
loader();
}
"#,
)
.expect("write effectful callback receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"effectful callback receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["run"]
.as_object()
.expect("run observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["run"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_receipt_records_effectful_returning_callback_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_returning_callback_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: (fn() -> str) with FileSystem) -> str ~ FileSystem {
loader()
}
"#,
)
.expect("write returning effectful callback receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"returning effectful callback receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["propagated_effects"]["run"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_receipt_records_effectful_callback_argument_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_callback_arg_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: fn() with FileSystem) ~ FileSystem {
loader();
}
fn load_config() ~ FileSystem {
read_file("config.toml");
}
fn main() ~ FileSystem {
run(load_config);
}
"#,
)
.expect("write effectful callback argument receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"effectful callback argument receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["run"]["FileSystem"],
serde_json::json!(["loader"])
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "run"])
);
}
#[test]
fn check_reports_effect_for_effectful_callback_argument_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_callback_arg_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: fn() with FileSystem) ~ FileSystem {
loader();
}
fn load_config() ~ FileSystem {
read_file("config.toml");
}
fn main() {
run(load_config);
}
"#,
)
.expect("write effectful callback argument gate fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful callback argument should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("run"),
"diagnostic should name wrapper source:\n{}",
stderr
);
assert!(
stderr.contains("load_config"),
"diagnostic should name callback argument source:\n{}",
stderr
);
}
#[test]
fn check_rejects_effectful_callback_erasure_into_pure_signature() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_callback_erasure_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn run(loader: fn(str) -> str) {
loader("ops.txt");
}
fn main() {
run(read_file);
}
"#,
)
.expect("write effectful callback erasure fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful callback should not be accepted by a pure callback signature"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name erased FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("fn(str) -> str"),
"diagnostic should show the pure callback boundary:\n{}",
stderr
);
}
#[test]
fn check_reports_effect_for_ambient_function_alias_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_ambient_alias_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let loader = read_file;
loader("ops.txt");
}
"#,
)
.expect("write ambient alias fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"ambient helper alias call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loader"),
"diagnostic should name alias call source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_ambient_function_alias_as_propagated_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_ambient_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
let loader = read_file;
loader("ops.txt");
}
"#,
)
.expect("write ambient alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"ambient alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_receipt_clears_stale_sources_for_shadowed_ambient_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_shadowed_ambient_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn main() ~ FileSystem {
let loader = load_config;
let loader = read_file;
loader("ops.txt");
}
"#,
)
.expect("write shadowed ambient alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"shadowed ambient alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_receipt_rebinds_assigned_effectful_function_alias_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_effectful_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("config.toml");
}
fn load_secret() ~ FileSystem {
read_file("secret.toml");
}
fn main() ~ FileSystem {
let mut loader = load_config;
loader = load_secret;
loader();
}
"#,
)
.expect("write assigned effectful alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"assigned effectful alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "loader"])
);
}
#[test]
fn check_receipt_rebinds_assigned_effectful_struct_field_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_effectful_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut ops = Ops { loader: load_config };
ops.loader = load_secret;
(ops.loader)("ops.txt");
}
"#,
)
.expect("write assigned effectful field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"assigned effectful field receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_rebinds_assigned_effectful_struct_object_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_effectful_struct_object_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut ops = Ops { loader: load_config };
let defaults = Ops { loader: load_secret };
ops = defaults;
(ops.loader)("ops.txt");
}
"#,
)
.expect("write assigned effectful struct object receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"assigned effectful struct object receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_rebinds_assigned_effectful_tuple_field_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_effectful_tuple_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut loaders = (load_config,);
loaders.0 = load_secret;
(loaders.0)("ops.txt");
}
"#,
)
.expect("write assigned effectful tuple field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"assigned effectful tuple field receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "loaders.0"])
);
}
#[test]
fn check_receipt_rebinds_assigned_effectful_index_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_effectful_index_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut loaders = [load_config];
loaders[0] = load_secret;
(loaders[0])("ops.txt");
}
"#,
)
.expect("write assigned effectful index receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"assigned effectful index receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "loaders[0]"])
);
}
#[test]
fn check_receipt_records_repeated_effectful_index_source_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_repeated_effectful_index_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let loaders = [load_config; 2];
(loaders[1])("ops.txt");
}
"#,
)
.expect("write repeated effectful index receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"repeated indexed effect receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "loaders[1]"])
);
}
#[test]
fn check_receipt_clears_stale_sources_for_assigned_ambient_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_assigned_ambient_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut loader = load_config;
loader = read_file;
loader("ops.txt");
}
"#,
)
.expect("write assigned ambient alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"assigned ambient alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_effectful_closure_literal_is_pure_until_called() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_closure_literal_pure_until_called_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let loader = |path: str| read_file(path);
}
"#,
)
.expect("write effectful closure literal fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"defining an effectful closure should not perform its effect\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_effectful_tuple_struct_constructor_is_pure_until_called() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_tuple_struct_constructor_pure_until_called_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Slot((fn() -> str) with FileSystem);
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn main() {
let slot = Slot(load_config);
}
"#,
)
.expect("write effectful tuple struct constructor fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"storing an effectful callback in a tuple struct should stay pure until call\nstdout:\n{}\nstderr:\n{} (rejected by the C backend gate)",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]
.as_object()
.expect("main propagated effects")
.len(),
0
);
}
#[test]
fn check_emits_distinct_argv_slots_for_multi_arg_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_multi_arg_effect_marshal_{}.bld",
std::process::id()
));
let out_c = std::env::temp_dir().join(format!(
"buildlang_multi_arg_effect_marshal_{}.c",
std::process::id()
));
fs::write(
&fixture,
r#"
effect Coord {
fn point(x: i32, y: i32, z: i32) -> (),
}
fn emit() ~ Coord {
perform Coord.point(10, 20, 30);
}
fn main() ~ Console {
handle {
emit()
} with {
Coord.point(x, y, z) => {
println!("x={} y={} z={}", x, y, z);
},
}
}
"#,
)
.expect("write multi-arg effect fixture");
let output = buildc()
.arg(&fixture)
.arg("-o")
.arg(&out_c)
.output()
.expect("run buildc to emit C");
assert!(
output.status.success(),
"multi-arg effect program should compile to C\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let code = fs::read_to_string(&out_c).expect("read emitted C");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&out_c);
for idx in 0..3 {
let needle = format!("handler_data)[{}]", idx);
assert!(
code.contains(&needle),
"handler parameter {} should read its own argv slot `{}`; \
emitted C:\n{}",
idx,
needle,
code
);
}
}
#[test]
fn check_vec_string_literal_uses_str_push_helper() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_vec_str_literal_{}.bld",
std::process::id()
));
let out_c = std::env::temp_dir().join(format!(
"buildlang_vec_str_literal_{}.c",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ Console {
let words = vec!["alpha", "beta", "gamma"];
println!("count={}", words.len());
println!("a={}", words.get(0));
}
"#,
)
.expect("write vec string-literal fixture");
let output = buildc()
.arg(&fixture)
.arg("-o")
.arg(&out_c)
.output()
.expect("run buildc to emit C");
assert!(
output.status.success(),
"vec string-literal program should compile to C\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let code = fs::read_to_string(&out_c).expect("read emitted C");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&out_c);
assert!(
code.contains("build_hvec_push_str(_"),
"vec![\"..\"] should push string elements through the str helper; \
emitted C:\n{}",
code
);
assert!(
!code.contains("build_hvec_push_i32(_"),
"vec![\"..\"] must not push string elements through the i32 helper; \
emitted C:\n{}",
code
);
}
#[test]
fn check_reports_effect_for_effectful_closure_alias_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_closure_alias_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let loader = |path: str| read_file(path);
loader("ops.txt");
}
"#,
)
.expect("write effectful closure alias fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"calling an effectful closure should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loader"),
"diagnostic should name closure alias source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_closure_alias_as_propagated_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_effectful_closure_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
let loader = |path: str| read_file(path);
loader("ops.txt");
}
"#,
)
.expect("write effectful closure alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"effectful closure alias receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loader"])
);
}
#[test]
fn check_reports_effect_for_immediate_effectful_closure_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_immediate_effectful_closure_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
(|path: str| read_file(path))("ops.txt");
}
"#,
)
.expect("write immediate effectful closure fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"immediate effectful closure call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("<closure>"),
"diagnostic should name anonymous closure source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_immediate_effectful_closure_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_immediate_effectful_closure_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
(|path: str| read_file(path))("ops.txt");
}
"#,
)
.expect("write immediate effectful closure receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"immediate effectful closure receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["<closure>"])
);
}
#[test]
fn check_effectful_async_block_is_pure_until_awaited() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_effectful_async_block_pure_until_awaited_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let task = async { read_file("ops.txt") };
}
"#,
)
.expect("write effectful async block fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"constructing an effectful async block should not perform its effect\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_reports_effect_for_awaited_effectful_async_block() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_awaited_effectful_async_block_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let task = async { read_file("ops.txt") };
task.await;
}
"#,
)
.expect("write awaited effectful async block fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"awaited effectful async block should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("task"),
"diagnostic should name awaited async source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_awaited_async_block_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_awaited_async_block_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
let task = async { read_file("ops.txt") };
task.await;
}
"#,
)
.expect("write awaited async block receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"awaited async block receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["task", "task <- read_file"])
);
}
#[test]
fn check_rejects_await_operator_on_selected_effectful_function_value() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_await_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let loader = if use_secret { load_secret } else { load_config };
loader.await;
}
"#,
)
.expect("write await selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"await operator on selected effectful function value should be rejected"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("await"),
"diagnostic should name the await operator:\n{}",
stderr
);
assert!(
stderr.contains("fn()"),
"diagnostic should name the invalid function operand:\n{}",
stderr
);
}
#[test]
fn check_selected_async_block_is_pure_until_awaited() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_selected_async_block_pure_until_awaited_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let use_secret = true;
let task = if use_secret {
async { read_file("ops.txt") }
} else {
async { getenv("TOKEN") }
};
}
"#,
)
.expect("write selected async block fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"selecting an effectful async block should not perform its effect\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_reports_effects_for_awaited_selected_async_block() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_awaited_selected_async_block_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let use_secret = true;
let task = if use_secret {
async { read_file("ops.txt") }
} else {
async { getenv("TOKEN") }
};
task.await;
}
"#,
)
.expect("write awaited selected async block fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"awaited selected async block should fail without declared effects"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("Environment"),
"diagnostic should name Environment effect:\n{}",
stderr
);
assert!(
stderr.contains("task"),
"diagnostic should name awaited selected async source:\n{}",
stderr
);
assert!(
stderr.contains("read_file"),
"diagnostic should name selected async FileSystem origin:\n{}",
stderr
);
assert!(
stderr.contains("getenv"),
"diagnostic should name selected async Environment origin:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_awaited_selected_async_block_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_awaited_selected_async_block_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem + Environment {
let use_secret = true;
let task = if use_secret {
async { read_file("ops.txt") }
} else {
async { getenv("TOKEN") }
};
task.await;
}
"#,
)
.expect("write awaited selected async block receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"awaited selected async block receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["task", "task <- read_file"])
);
assert_eq!(
receipt["propagated_effects"]["main"]["Environment"],
serde_json::json!(["task", "task <- getenv"])
);
}
#[test]
fn check_reports_effects_for_awaited_match_selected_async_block() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_awaited_match_selected_async_block_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let mode = 1;
let task = match mode {
0 => async { read_file("ops.txt") },
_ => async { getenv("TOKEN") },
};
task.await;
}
"#,
)
.expect("write awaited match selected async block fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"awaited match selected async block should fail without declared effects"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("Environment"),
"diagnostic should name Environment effect:\n{}",
stderr
);
assert!(
stderr.contains("task"),
"diagnostic should name awaited match selected async source:\n{}",
stderr
);
assert!(
stderr.contains("read_file"),
"diagnostic should name match-selected async FileSystem origin:\n{}",
stderr
);
assert!(
stderr.contains("getenv"),
"diagnostic should name match-selected async Environment origin:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_awaited_match_selected_async_block_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_awaited_match_selected_async_block_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem + Environment {
let mode = 1;
let task = match mode {
0 => async { read_file("ops.txt") },
_ => async { getenv("TOKEN") },
};
task.await;
}
"#,
)
.expect("write awaited match selected async block receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"awaited match selected async block receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["task", "task <- read_file"])
);
assert_eq!(
receipt["propagated_effects"]["main"]["Environment"],
serde_json::json!(["task", "task <- getenv"])
);
}
#[test]
fn check_reports_effect_for_effectful_struct_field_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_struct_field_effect_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn main() {
let ops = Ops { loader: read_file };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write struct field effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful struct field call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("ops.loader"),
"diagnostic should name field call source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_struct_field_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_struct_field_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn main() ~ FileSystem {
let ops = Ops { loader: read_file };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write struct field effect receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"struct field effect receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["ops.loader"])
);
}
#[test]
fn check_receipt_records_struct_update_effectful_field_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_struct_update_effectful_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let defaults = Ops { loader: load_config };
let ops = Ops { ..defaults };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write struct update effectful field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"struct update field effect receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_nested_struct_update_effectful_field_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_nested_struct_update_effectful_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let defaults = Outer { ops: Ops { loader: load_config } };
let outer = Outer { ..defaults };
(outer.ops.loader)("ops.txt");
}
"#,
)
.expect("write nested struct update effectful field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"nested struct update effect receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "outer.ops.loader"])
);
}
#[test]
fn check_receipt_records_destructured_nested_struct_update_effectful_field_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_destructured_nested_struct_update_effectful_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let defaults = Outer { ops: Ops { loader: load_config } };
let outer = Outer { ..defaults };
let Outer { ops } = outer;
(ops.loader)("ops.txt");
}
"#,
)
.expect("write destructured nested struct update effectful field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"destructured nested struct update effect receipt check passes the check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "passed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_struct_update_expression_destructured_effectful_field_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_struct_update_expression_destructured_effectful_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let defaults = Outer { ops: Ops { loader: load_config } };
let Outer { ops } = Outer { ..defaults };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write struct update expression destructured effectful field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"struct update expression destructured effect receipt check passes the check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "passed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_struct_update_expression_explicit_field_destructured_origin() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_struct_update_expression_explicit_field_destructured_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let defaults = Outer { ops: Ops { loader: load_config } };
let replacement = Ops { loader: load_config };
let Outer { ops } = Outer { ops: replacement, ..defaults };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write struct update expression explicit field destructured receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"struct update expression explicit field destructured receipt check passes the check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "passed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_tuple_literal_destructured_aggregate_origin_without_stale_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_literal_destructured_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let replacement = Ops { loader: load_config };
let (ops,) = (replacement,);
(ops.loader)("ops.txt");
}
"#,
)
.expect("write tuple literal destructured aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"tuple literal destructured aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_stored_variant_aggregate_origin_without_stale_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_stored_variant_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
enum Slot {
Ready(Ops),
Empty
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let replacement = Ops { loader: load_config };
let slot = Slot::Ready(replacement);
match slot {
Slot::Ready(ops) => { (ops.loader)("ops.txt"); }
Slot::Empty => { }
}
}
"#,
)
.expect("write stored variant aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"stored variant aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "ops.loader"])
);
}
#[test]
fn check_receipt_records_selected_aggregate_origin_without_stale_branch_aliases() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_selected_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let use_secret = true;
let config = Ops { loader: load_config };
let secret = Ops { loader: load_secret };
let ops = if use_secret { secret } else { config };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write selected aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"selected aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_records_tuple_destructured_selected_aggregate_origins() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_selected_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let use_secret = true;
let config = Ops { loader: load_config };
let secret = Ops { loader: load_secret };
let (ops,) = (if use_secret { secret } else { config },);
(ops.loader)("ops.txt");
}
"#,
)
.expect("write tuple destructured selected aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"tuple destructured selected aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_records_nested_if_let_selected_aggregate_origins() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_nested_if_let_selected_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
enum Slot {
Ready(i32),
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let config = Ops { loader: load_config };
let secret = Ops { loader: load_secret };
let outer = Outer { ops: if let Slot::Ready(version) = slot { secret } else { config } };
(outer.ops.loader)("ops.txt");
}
"#,
)
.expect("write nested if-let selected aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"nested if-let selected aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "outer.ops.loader"])
);
}
#[test]
fn check_receipt_records_tuple_destructured_nested_if_let_selected_aggregate_origins() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_nested_if_let_selected_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
enum Slot {
Ready(i32),
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let config = Ops { loader: load_config };
let secret = Ops { loader: load_secret };
let Outer { ops } = Outer { ops: if let Slot::Ready(version) = slot { secret } else { config } };
(ops.loader)("ops.txt");
}
"#,
)
.expect("write destructured nested if-let selected aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"destructured nested if-let selected aggregate receipt check passes the check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "passed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_records_shorthand_aggregate_field_origin_without_stale_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_shorthand_aggregate_field_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let ops = Ops { loader: load_config };
let outer = Outer { ops };
(outer.ops.loader)("ops.txt");
}
"#,
)
.expect("write shorthand aggregate field receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"shorthand aggregate field receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "outer.ops.loader"])
);
}
#[test]
fn check_receipt_records_direct_shorthand_aggregate_destructuring_origin_without_stale_alias() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_direct_shorthand_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
struct Outer {
ops: Ops
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let ops = Ops { loader: load_config };
let Outer { ops: unpacked } = Outer { ops };
(unpacked.loader)("ops.txt");
}
"#,
)
.expect("write direct shorthand aggregate destructuring receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"direct shorthand aggregate destructuring receipt check passes the check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "passed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "unpacked.loader"])
);
}
#[test]
fn check_receipt_clears_stale_aggregate_sources_for_shadowed_opaque_binding() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_shadowed_opaque_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn make_ops() -> Ops {
Ops { loader: read_file }
}
fn main() ~ FileSystem {
let ops = Ops { loader: load_config };
let ops = make_ops();
(ops.loader)("ops.txt");
}
"#,
)
.expect("write shadowed opaque aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"shadowed opaque aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["make_ops().loader", "ops.loader"])
);
}
#[test]
fn check_receipt_clears_outer_aggregate_sources_for_inner_shadowed_opaque_binding() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_inner_shadowed_opaque_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn make_ops() -> Ops {
Ops { loader: read_file }
}
fn main() ~ FileSystem {
let ops = Ops { loader: load_config };
{
let ops = make_ops();
(ops.loader)("ops.txt");
}
}
"#,
)
.expect("write inner shadowed opaque aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"inner shadowed opaque aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["make_ops().loader", "ops.loader"])
);
}
#[test]
fn check_receipt_clears_outer_aggregate_sources_when_inner_shadow_is_copied() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_inner_shadowed_aggregate_copy_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn make_ops() -> Ops {
Ops { loader: read_file }
}
fn main() ~ FileSystem {
let ops = Ops { loader: load_config };
{
let ops = make_ops();
let copied = ops;
(copied.loader)("ops.txt");
}
}
"#,
)
.expect("write inner shadowed aggregate copy receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"inner shadowed aggregate copy receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["copied.loader", "make_ops().loader", "ops.loader"])
);
}
#[test]
fn check_reports_effect_for_effectful_tuple_field_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_tuple_field_effect_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let loaders = (read_file,);
(loaders.0)("ops.txt");
}
"#,
)
.expect("write tuple field effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful tuple field call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loaders.0"),
"diagnostic should name tuple field call source:\n{}",
stderr
);
}
#[test]
fn check_receipt_refreshes_outer_alias_source_after_inner_block_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_inner_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut loader = load_config;
{
loader = load_secret;
};
loader("ops.txt");
}
"#,
)
.expect("write inner assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"inner assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "loader"])
);
}
#[test]
fn check_receipt_refreshes_outer_aggregate_source_after_inner_block_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_inner_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut ops = Ops { loader: load_config };
{
ops.loader = load_secret;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write inner assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"inner assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_conditional_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_conditional_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let use_secret = true;
let mut loader = load_config;
if use_secret {
loader = load_secret;
};
loader("ops.txt");
}
"#,
)
.expect("write conditional assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"conditional assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_conditional_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_conditional_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let use_secret = true;
let mut ops = Ops { loader: load_config };
if use_secret {
ops.loader = load_secret;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write conditional assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"conditional assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_if_let_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_if_let_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready(i32),
Empty,
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let mut loader = load_config;
if let Slot::Ready(version) = slot {
loader = load_secret;
};
loader("ops.txt");
}
"#,
)
.expect("write if-let assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"if-let assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_if_let_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_if_let_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
enum Slot {
Ready(i32),
Empty,
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let mut ops = Ops { loader: load_config };
if let Slot::Ready(version) = slot {
ops.loader = load_secret;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write if-let assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"if-let assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_if_else_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_if_else_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_backup(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let use_secret = true;
let mut loader = load_config;
if use_secret {
loader = load_secret;
} else {
loader = load_backup;
};
loader("ops.txt");
}
"#,
)
.expect("write if-else assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"if-else assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_backup", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_match_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_match_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_backup(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mode = 0;
let mut loader = load_config;
match mode {
0 => { loader = load_secret; }
_ => { loader = load_backup; }
};
loader("ops.txt");
}
"#,
)
.expect("write match assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"match assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_backup", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_keeps_pre_match_alias_source_after_guarded_match_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_guarded_match_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_backup(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mode = true;
let allow_secret = false;
let mut loader = load_config;
match mode {
true if allow_secret => { loader = load_secret; },
true => {},
false => { loader = load_backup; }
};
loader("ops.txt");
}
"#,
)
.expect("write guarded match assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"guarded match assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_backup", "load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_match_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_match_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_backup(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mode = 0;
let mut ops = Ops { loader: load_config };
match mode {
0 => { ops.loader = load_secret; }
_ => { ops.loader = load_backup; }
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write match assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"match assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_backup", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_while_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_while_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let should_reload = false;
let mut loader = load_config;
while should_reload {
loader = load_secret;
};
loader("ops.txt");
}
"#,
)
.expect("write while assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"while assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_while_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_while_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let should_reload = false;
let mut ops = Ops { loader: load_config };
while should_reload {
ops.loader = load_secret;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write while assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"while assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_for_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_for_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let mut loader = load_config;
for item in [0] {
loader = load_secret;
};
loader("ops.txt");
}
"#,
)
.expect("write for assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"for assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_while_let_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_while_let_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready(i32),
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let mut loader = load_config;
while let Slot::Ready(version) = slot {
loader = load_secret;
break;
};
loader("ops.txt");
}
"#,
)
.expect("write while-let assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"while-let assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_while_let_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_while_let_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
enum Slot {
Ready(i32),
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let mut ops = Ops { loader: load_config };
while let Slot::Ready(version) = slot {
ops.loader = load_secret;
break;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write while-let assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"while-let assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_merges_outer_alias_sources_after_loop_break_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_loop_break_assignment_alias_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let stop_now = true;
let mut loader = load_config;
loop {
if stop_now {
break;
};
loader = load_secret;
break;
};
loader("ops.txt");
}
"#,
)
.expect("write loop break assignment alias receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"loop break assignment alias receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_merges_outer_aggregate_sources_after_loop_break_assignment() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_loop_break_assignment_aggregate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn(str) -> str) with FileSystem
}
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
let stop_now = true;
let mut ops = Ops { loader: load_config };
loop {
if stop_now {
break;
};
ops.loader = load_secret;
break;
};
(ops.loader)("ops.txt");
}
"#,
)
.expect("write loop break assignment aggregate receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"loop break assignment aggregate receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "ops.loader"])
);
}
#[test]
fn check_receipt_records_effectful_tuple_field_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_field_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
let loaders = (read_file,);
(loaders.0)("ops.txt");
}
"#,
)
.expect("write tuple field effect receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"tuple field effect receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loaders.0"])
);
}
#[test]
fn check_reports_effect_for_effectful_index_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_index_effect_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() {
let loaders = [read_file];
(loaders[0])("ops.txt");
}
"#,
)
.expect("write index effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"effectful index call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loaders[0]"),
"diagnostic should name indexed call source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_effectful_index_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_index_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn main() ~ FileSystem {
let loaders = [read_file];
(loaders[0])("ops.txt");
}
"#,
)
.expect("write index effect receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"indexed effect receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["loaders[0]"])
);
}
#[test]
fn check_reports_effect_for_immediate_returned_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_returned_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn make_loader() -> (fn(str) -> str) with FileSystem {
read_file
}
fn main() {
make_loader()("ops.txt");
}
"#,
)
.expect("write returned effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"immediate returned effectful function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("make_loader()"),
"diagnostic should name returned function call source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_immediate_returned_effectful_function_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_returned_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn make_loader() -> (fn(str) -> str) with FileSystem {
read_file
}
fn main() ~ FileSystem {
make_loader()("ops.txt");
}
"#,
)
.expect("write returned effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"returned effectful function receipt check should be rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["make_loader()"])
);
}
#[test]
fn check_reports_effect_for_pipe_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_pipe_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() {
"ops.toml" |> load_config;
}
"#,
)
.expect("write pipe effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"pipe effectful function call should fail without FileSystem effect\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config"])
);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
let message = diag["message"].as_str().unwrap_or_default();
message.contains("FileSystem") && message.contains("main")
}),
"missing FileSystem diagnostic for pipe effectful function call\nreceipt:\n{}",
serde_json::to_string_pretty(&receipt).expect("receipt should serialize")
);
}
#[test]
fn check_receipt_records_pipe_effectful_function_call_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_pipe_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() ~ FileSystem {
"ops.toml" |> load_config;
}
"#,
)
.expect("write pipe effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"pipe effectful function receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config"])
);
}
#[test]
fn check_rejects_function_values_with_shift_operator() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_function_shift_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config(path: str) -> str ~ FileSystem {
read_file(path)
}
fn load_secret(path: str) -> str ~ FileSystem {
read_file(path)
}
fn main() {
let pipeline = load_config >> load_secret;
}
"#,
)
.expect("write function shift fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"function values used with >> should be rejected\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
let message = diag["message"].as_str().unwrap_or_default();
message.contains("binary operator `>>`") && message.contains("FileSystem")
}),
"missing invalid function shift diagnostic\nreceipt:\n{}",
serde_json::to_string_pretty(&receipt).expect("receipt should serialize")
);
}
#[test]
fn check_reports_effect_for_control_flow_selected_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_control_flow_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
(if use_secret { load_secret } else { load_config })();
}
"#,
)
.expect("write control-flow selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"control-flow selected effectful function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("load_config"),
"diagnostic should name one possible branch source:\n{}",
stderr
);
assert!(
stderr.contains("load_secret"),
"diagnostic should name the other possible branch source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_control_flow_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_control_flow_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
(if use_secret { load_secret } else { load_config })();
}
"#,
)
.expect("write control-flow selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"control-flow selected effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret"])
);
}
#[test]
fn check_reports_effect_for_match_selected_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_match_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
(match use_secret {
true => load_secret,
false => load_config,
})();
}
"#,
)
.expect("write match selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"match selected effectful function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("load_config"),
"diagnostic should name one possible match source:\n{}",
stderr
);
assert!(
stderr.contains("load_secret"),
"diagnostic should name the other possible match source:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_match_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_match_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
(match use_secret {
true => load_secret,
false => load_config,
})();
}
"#,
)
.expect("write match selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"match selected effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret"])
);
}
#[test]
fn check_reports_effect_for_let_bound_selected_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_let_bound_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let loader = if use_secret { load_secret } else { load_config };
loader();
}
"#,
)
.expect("write let-bound selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"let-bound selected effectful function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loader"),
"diagnostic should name selected binding source:\n{}",
stderr
);
assert!(
stderr.contains("load_config"),
"diagnostic should name one possible selected source:\n{}",
stderr
);
assert!(
stderr.contains("load_secret"),
"diagnostic should name the other possible selected source:\n{}",
stderr
);
}
#[test]
fn check_reports_effect_for_if_let_bound_selected_effectful_function_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_if_let_bound_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready(i32),
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let slot = Slot::Ready(0);
let loader = if let Slot::Ready(version) = slot { load_secret } else { load_config };
loader();
}
"#,
)
.expect("write if-let-bound selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"if-let-bound selected effectful function call should fail without FileSystem effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should name FileSystem effect:\n{}",
stderr
);
assert!(
stderr.contains("loader"),
"diagnostic should name selected binding source:\n{}",
stderr
);
assert!(
stderr.contains("load_config"),
"diagnostic should name if-let fallback source:\n{}",
stderr
);
assert!(
stderr.contains("load_secret"),
"diagnostic should name if-let matched source:\n{}",
stderr
);
}
#[test]
fn check_rejects_try_operator_on_selected_effectful_function_value() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_try_selected_effectful_function_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let loader = if use_secret { load_secret } else { load_config };
loader?();
}
"#,
)
.expect("write try selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"try operator on selected effectful function value should be rejected"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("`?`"),
"diagnostic should name the try operator:\n{}",
stderr
);
assert!(
stderr.contains("fn()"),
"diagnostic should name the invalid function operand:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_let_bound_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_let_bound_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let loader = if use_secret { load_secret } else { load_config };
loader();
}
"#,
)
.expect("write let-bound selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"let-bound selected effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_if_let_bound_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_if_let_bound_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready(i32),
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let slot = Slot::Ready(0);
let loader = if let Slot::Ready(version) = slot { load_secret } else { load_config };
loader();
}
"#,
)
.expect("write if-let-bound selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"if-let-bound selected effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_cast_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_cast_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let loader = (if use_secret { load_secret } else { load_config }) as (fn() -> str) with FileSystem;
loader();
}
"#,
)
.expect("write cast selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"cast selected effectful function receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_rejects_cast_laundering_selected_effectful_function_to_pure_callback() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_cast_selected_effectful_function_to_pure_gate_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let loader = (if use_secret { load_secret } else { load_config }) as fn() -> str;
loader();
}
"#,
)
.expect("write pure cast selected effectful function fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"casting selected effectful function to pure callback should be rejected"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("FileSystem"),
"diagnostic should retain the erased effect row:\n{}",
stderr
);
}
#[test]
fn check_receipt_records_ref_deref_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_ref_deref_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let loader = if use_secret { load_secret } else { load_config };
let loader_ref = &loader;
(*loader_ref)();
}
"#,
)
.expect("write ref-deref selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"ref-deref selected effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader", "loader_ref"])
);
}
#[test]
fn check_receipt_records_tuple_destructured_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_destructured_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let (loader,) = (if use_secret { load_secret } else { load_config },);
loader();
}
"#,
)
.expect("write tuple-destructured effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"tuple-destructured effectful function receipt check is rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_struct_destructured_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_struct_destructured_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Ops {
loader: (fn() -> str) with FileSystem
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let ops = Ops { loader: if use_secret { load_secret } else { load_config } };
let Ops { loader } = ops;
loader();
}
"#,
)
.expect("write struct-destructured effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"struct-destructured effectful function receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_slice_destructured_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_slice_destructured_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let loaders = [if use_secret { load_secret } else { load_config }];
let [loader] = loaders;
loader();
}
"#,
)
.expect("write slice-destructured effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"slice-destructured effectful function receipt check should be rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_tuple_struct_destructured_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_tuple_struct_destructured_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
struct Slot((fn() -> str) with FileSystem);
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let slot = Slot(if use_secret { load_secret } else { load_config });
let Slot(loader) = slot;
loader();
}
"#,
)
.expect("write tuple-struct destructured selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"tuple-struct destructured selected effectful function receipt check should be rejected by the C backend gate\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(receipt_from_stdout(&output)["status"], "failed");
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_receipt_records_enum_variant_destructured_selected_effectful_function_sources() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_enum_variant_destructured_selected_effectful_function_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready((fn() -> str) with FileSystem),
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() ~ FileSystem {
let use_secret = true;
let slot = if use_secret {
Slot::Ready(load_secret)
} else {
Slot::Ready(load_config)
};
match slot {
Slot::Ready(loader) => loader(),
};
}
"#,
)
.expect("write enum-variant destructured selected effectful function receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"enum-variant destructured selected effectful function receipt check should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["observed_capabilities"]["main"]
.as_object()
.expect("main observed capabilities")
.len(),
0
);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
}
#[test]
fn check_struct_enum_variant_destructured_callback_requires_declared_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_struct_enum_variant_callback_requires_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready { loader: (fn() -> str) with FileSystem },
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let slot = if use_secret {
Slot::Ready { loader: load_secret }
} else {
Slot::Ready { loader: load_config }
};
match slot {
Slot::Ready { loader } => loader(),
};
}
"#,
)
.expect("write struct enum variant callback effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"struct enum variant callback without declared effect should fail\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
let message = diag["message"].as_str().unwrap_or_default();
message.contains("FileSystem") && message.contains("main")
}),
"missing FileSystem diagnostic for struct enum variant callback\nreceipt:\n{}",
serde_json::to_string_pretty(&receipt).expect("receipt should serialize")
);
}
#[test]
fn check_if_let_destructured_enum_variant_callback_requires_declared_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_if_let_enum_variant_callback_requires_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready((fn() -> str) with FileSystem),
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let slot = if use_secret {
Slot::Ready(load_secret)
} else {
Slot::Ready(load_config)
};
if let Slot::Ready(loader) = slot {
loader();
};
}
"#,
)
.expect("write if-let enum variant callback effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"if-let destructured callback without declared effect should fail\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
let message = diag["message"].as_str().unwrap_or_default();
message.contains("FileSystem") && message.contains("main")
}),
"missing FileSystem diagnostic for if-let callback\nreceipt:\n{}",
serde_json::to_string_pretty(&receipt).expect("receipt should serialize")
);
}
#[test]
fn check_while_let_destructured_enum_variant_callback_requires_declared_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_while_let_enum_variant_callback_requires_effect_{}.bld",
std::process::id()
));
fs::write(
&fixture,
r#"
enum Slot {
Ready((fn() -> str) with FileSystem),
}
fn load_config() -> str ~ FileSystem {
read_file("config.toml")
}
fn load_secret() -> str ~ FileSystem {
read_file("secret.toml")
}
fn main() {
let use_secret = true;
let slot = if use_secret {
Slot::Ready(load_secret)
} else {
Slot::Ready(load_config)
};
while let Slot::Ready(loader) = slot {
loader();
break;
};
}
"#,
)
.expect("write while-let enum variant callback effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"while-let destructured callback without declared effect should fail\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config", "load_secret", "loader"])
);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
let message = diag["message"].as_str().unwrap_or_default();
message.contains("FileSystem") && message.contains("main")
}),
"missing FileSystem diagnostic for while-let callback\nreceipt:\n{}",
serde_json::to_string_pretty(&receipt).expect("receipt should serialize")
);
}
#[test]
fn check_receipt_file_records_failing_capability_diagnostic() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_receipt_fail_{}.bld",
std::process::id()
));
let receipt_path = fixture.with_extension("receipt.json");
fs::write(&fixture, r#"fn main() { read_file("ops.txt"); }"#)
.expect("write failing receipt fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--receipt")
.arg(&receipt_path)
.output()
.expect("run buildc check --receipt file");
let receipt_text = fs::read_to_string(&receipt_path).expect("read receipt file");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&receipt_path);
assert!(
!output.status.success(),
"failing capability check should return nonzero"
);
let receipt: serde_json::Value =
serde_json::from_str(&receipt_text).expect("receipt file should be JSON");
assert_eq!(receipt["schema"], "buildlang-check-receipt/v1");
assert_eq!(receipt["status"], "failed");
assert_eq!(receipt["compiler_version"], env!("CARGO_PKG_VERSION"));
assert_eq!(receipt["language_version"], "1.0.0");
assert_eq!(receipt["source_digest"]["algorithm"], "sha256");
assert_eq!(
receipt["source_digest"]["hex"]
.as_str()
.expect("failing receipt digest")
.len(),
64
);
assert_eq!(
receipt["observed_capabilities"]["main"]["FileSystem"],
serde_json::json!(["read_file"])
);
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
diag["stage"] == "type"
&& diag["kind"] == "UnhandledEffect"
&& diag["message"]
.as_str()
.unwrap_or("")
.contains("FileSystem")
}),
"expected FileSystem UnhandledEffect diagnostic in {diagnostics:#?}"
);
}
#[test]
fn check_receipt_source_digest_ignores_path_for_identical_content() {
let id = std::process::id();
let left = std::env::temp_dir().join(format!("buildlang_check_receipt_digest_left_{id}.bld"));
let right = std::env::temp_dir().join(format!("buildlang_check_receipt_digest_right_{id}.bld"));
let source = r#"fn main() ~ Console { println!("same"); }"#;
fs::write(&left, source).expect("write left digest fixture");
fs::write(&right, source).expect("write right digest fixture");
let left_output = buildc()
.arg("check")
.arg(&left)
.arg("--receipt")
.arg("-")
.output()
.expect("run left digest receipt");
let right_output = buildc()
.arg("check")
.arg(&right)
.arg("--receipt")
.arg("-")
.output()
.expect("run right digest receipt");
let _ = fs::remove_file(&left);
let _ = fs::remove_file(&right);
assert!(left_output.status.success(), "left check should pass");
assert!(right_output.status.success(), "right check should pass");
let left_receipt = receipt_from_stdout(&left_output);
let right_receipt = receipt_from_stdout(&right_output);
assert_ne!(left_receipt["source"], right_receipt["source"]);
let left_digest = left_receipt["source_digest"]["hex"]
.as_str()
.expect("left source digest hex string");
let right_digest = right_receipt["source_digest"]["hex"]
.as_str()
.expect("right source digest hex string");
assert_eq!(left_digest.len(), 64);
assert_eq!(right_digest.len(), 64);
assert_eq!(
left_receipt["source_digest"]["hex"],
right_receipt["source_digest"]["hex"]
);
}
#[test]
fn check_receipt_source_digest_changes_when_source_changes() {
let id = std::process::id();
let first = std::env::temp_dir().join(format!("buildlang_check_receipt_digest_first_{id}.bld"));
let second =
std::env::temp_dir().join(format!("buildlang_check_receipt_digest_second_{id}.bld"));
fs::write(&first, r#"fn main() ~ Console { println!("first"); }"#)
.expect("write first digest fixture");
fs::write(&second, r#"fn main() ~ Console { println!("second"); }"#)
.expect("write second digest fixture");
let first_output = buildc()
.arg("check")
.arg(&first)
.arg("--receipt")
.arg("-")
.output()
.expect("run first digest receipt");
let second_output = buildc()
.arg("check")
.arg(&second)
.arg("--receipt")
.arg("-")
.output()
.expect("run second digest receipt");
let _ = fs::remove_file(&first);
let _ = fs::remove_file(&second);
assert!(first_output.status.success(), "first check should pass");
assert!(second_output.status.success(), "second check should pass");
let first_receipt = receipt_from_stdout(&first_output);
let second_receipt = receipt_from_stdout(&second_output);
assert_ne!(
first_receipt["source_digest"]["hex"],
second_receipt["source_digest"]["hex"]
);
}
#[test]
fn check_receipt_input_digests_track_included_source_changes() {
let dir = std::env::temp_dir().join(format!(
"buildlang_check_receipt_inputs_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create input digest fixture dir");
let entry = dir.join("entry.bld");
let shared = dir.join("shared.bld");
fs::write(
&entry,
r#"include!("shared.bld");
fn main() ~ Console { println!("{}", value()); }
"#,
)
.expect("write entry fixture");
fs::write(&shared, "fn value() -> i32 { 7 }\n").expect("write first include fixture");
let first_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg("-")
.output()
.expect("run first input digest receipt");
assert!(
first_output.status.success(),
"first check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&first_output.stdout),
String::from_utf8_lossy(&first_output.stderr)
);
let first_receipt = receipt_from_stdout(&first_output);
let first_entry_digest = first_receipt["source_digest"]["hex"]
.as_str()
.expect("entry source digest")
.to_string();
let first_input_entry = input_digest_hex(&first_receipt, "entry", "entry.bld");
let first_input_include = input_digest_hex(&first_receipt, "include", "shared.bld");
let first_graph_digest = input_graph_digest_hex(&first_receipt);
assert_eq!(first_entry_digest, first_input_entry);
fs::write(&shared, "fn value() -> i32 { 8 }\n").expect("write changed include fixture");
let second_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg("-")
.output()
.expect("run second input digest receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
second_output.status.success(),
"second check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&second_output.stdout),
String::from_utf8_lossy(&second_output.stderr)
);
let second_receipt = receipt_from_stdout(&second_output);
assert_eq!(second_receipt["source_digest"]["hex"], first_entry_digest);
assert_eq!(
input_digest_hex(&second_receipt, "entry", "entry.bld"),
first_input_entry
);
assert_ne!(input_graph_digest_hex(&second_receipt), first_graph_digest);
assert_ne!(
input_digest_hex(&second_receipt, "include", "shared.bld"),
first_input_include
);
}
#[test]
fn check_receipt_input_digests_record_imports_and_modules() {
let dir = std::env::temp_dir().join(format!(
"buildlang_check_receipt_graph_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
let package_dir = dir.join("registry/packages/std-math/src");
fs::create_dir_all(&package_dir).expect("create import package dir");
fs::create_dir_all(dir.join("helpers")).expect("create helper module dir");
let entry = dir.join("entry.bld");
let imported = package_dir.join("lib.bld");
let module = dir.join("helpers/mod.bld");
fs::write(&imported, "fn imported_value() -> i32 { 2 }\n").expect("write import fixture");
fs::write(&module, "fn module_value() -> i32 { 5 }\n").expect("write module fixture");
fs::write(
&entry,
r#"use std_math;
mod helpers;
fn main() ~ Console {
println!("{}", imported_value() + helpers::module_value());
}
"#,
)
.expect("write graph entry fixture");
let output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg("-")
.output()
.expect("run graph input digest receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
output.status.success(),
"graph check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
input_digest_hex(&receipt, "entry", "entry.bld");
input_digest_hex(&receipt, "import", "lib.bld");
input_digest_hex(&receipt, "module", "mod.bld");
}
#[test]
fn check_receipt_input_graph_digest_is_path_portable() {
let mut graph_digests = Vec::new();
let mut entry_sources = Vec::new();
for label in ["left", "right"] {
let dir = std::env::temp_dir().join(format!(
"buildlang_check_receipt_graph_digest_{}_{}",
label,
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create graph digest fixture dir");
let entry = dir.join("entry.bld");
let shared = dir.join("shared.bld");
fs::write(
&entry,
r#"include!("shared.bld");
fn main() ~ Console { println!("{}", value()); }
"#,
)
.expect("write graph digest entry fixture");
fs::write(&shared, "fn value() -> i32 { 11 }\n")
.expect("write graph digest include fixture");
let output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg("-")
.output()
.expect("run graph digest receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
output.status.success(),
"graph digest check should pass for {label}\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
entry_sources.push(receipt["source"].as_str().unwrap_or("").to_string());
graph_digests.push(input_graph_digest_hex(&receipt));
}
assert_ne!(entry_sources[0], entry_sources[1]);
assert_eq!(graph_digests[0], graph_digests[1]);
}
#[test]
fn receipt_verify_accepts_fresh_check_receipt() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_fresh_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt verify fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() {}"#).expect("write receipt verify entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write fresh check receipt");
assert!(
check_output.status.success(),
"check should pass before receipt verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify fresh check receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
verify_output.status.success(),
"fresh receipt should verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_output.stdout),
String::from_utf8_lossy(&verify_output.stderr)
);
assert!(
String::from_utf8_lossy(&verify_output.stdout).contains("Receipt verified"),
"stdout should confirm verification:\n{}",
String::from_utf8_lossy(&verify_output.stdout)
);
}
#[test]
fn receipt_verify_json_reports_passed_checks() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_json_pass_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt json fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() {}"#).expect("write receipt json entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write check receipt for json verify");
assert!(
check_output.status.success(),
"check should pass before json receipt verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--json")
.output()
.expect("verify receipt as json");
let _ = fs::remove_dir_all(&dir);
assert!(
verify_output.status.success(),
"json receipt verification should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_output.stdout),
String::from_utf8_lossy(&verify_output.stderr)
);
let report: serde_json::Value =
serde_json::from_slice(&verify_output.stdout).expect("verification report should be JSON");
assert_eq!(report["schema"], "buildlang-receipt-verification/v1");
assert_eq!(report["status"], "passed");
assert_eq!(
verification_check(&report, "source_digest")["status"],
"passed"
);
assert_eq!(
verification_check(&report, "input_graph_digest")["status"],
"passed"
);
assert_eq!(
verification_check(&report, "policy_profile_digest")["status"],
"passed"
);
}
#[test]
fn receipt_verify_expect_profile_rejects_stripped_policy() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_expect_profile_stripped_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create expect profile fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() {}"#).expect("write expect profile entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--profile")
.arg("ci-review")
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write profile-backed receipt");
assert!(
check_output.status.success(),
"check should pass before stripping policy\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let mut saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read profile receipt"))
.expect("profile receipt should parse");
saved
.as_object_mut()
.expect("receipt should be an object")
.remove("policy");
fs::write(
&receipt,
serde_json::to_string_pretty(&saved).expect("serialize stripped receipt"),
)
.expect("write stripped profile receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--expect-profile")
.arg("ci-review")
.output()
.expect("verify stripped receipt with expected profile");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stripped policy receipt should fail expected-profile verification"
);
assert!(
String::from_utf8_lossy(&verify_output.stderr)
.contains("receipt built-in profile mismatch"),
"stderr should report expected profile mismatch:\n{}",
String::from_utf8_lossy(&verify_output.stderr)
);
}
#[test]
fn receipt_verify_json_reports_expected_profile_mismatch() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_expect_profile_json_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create expect profile json fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() {}"#).expect("write expect profile json entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write pure profile receipt");
assert!(
check_output.status.success(),
"check should pass before expected-profile mismatch\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--expect-profile")
.arg("ci-review")
.arg("--json")
.output()
.expect("verify mismatched profile receipt as json");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"mismatched profile receipt should fail json verification"
);
let report: serde_json::Value = serde_json::from_slice(&verify_output.stdout)
.expect("profile mismatch report should be JSON");
assert_eq!(report["status"], "failed");
let profile_check = verification_check(&report, "expected_profile");
assert_eq!(profile_check["status"], "failed");
assert_eq!(profile_check["expected"], "builtin:ci-review");
assert_eq!(profile_check["actual"], "builtin:pure");
assert!(
profile_check["message"]
.as_str()
.expect("expected profile failure message")
.contains("receipt built-in profile mismatch"),
"profile failure should explain mismatch: {profile_check:#?}"
);
}
#[test]
fn receipt_verify_json_reports_failed_input_graph() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_json_fail_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt json failure fixture dir");
let entry = dir.join("entry.bld");
let shared = dir.join("shared.bld");
let receipt = dir.join("receipt.json");
fs::write(
&entry,
r#"include!("shared.bld");
fn main() ~ Console { println!("{}", value()); }
"#,
)
.expect("write receipt json failure entry");
fs::write(&shared, "fn value() -> i32 { 7 }\n").expect("write first shared source");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write staleable check receipt for json verify");
assert!(
check_output.status.success(),
"check should pass before json graph mutation\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
fs::write(&shared, "fn value() -> i32 { 8 }\n").expect("mutate shared source for json verify");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--json")
.output()
.expect("verify stale receipt as json");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stale json receipt verification should fail"
);
let report: serde_json::Value =
serde_json::from_slice(&verify_output.stdout).expect("failure report should be JSON");
assert_eq!(report["schema"], "buildlang-receipt-verification/v1");
assert_eq!(report["status"], "failed");
let graph_check = verification_check(&report, "input_graph_digest");
assert_eq!(graph_check["status"], "failed");
assert!(
graph_check["message"]
.as_str()
.expect("failure check message")
.contains("input graph digest mismatch"),
"graph failure should explain mismatch: {graph_check:#?}"
);
}
#[test]
fn receipt_verify_rejects_changed_policy_file_digest() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_policy_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt policy fixture dir");
let entry = dir.join("entry.bld");
let policy = dir.join("policy.json");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write policy receipt entry");
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}
"#,
)
.expect("write initial policy");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write file-backed policy receipt");
assert!(
check_output.status.success(),
"check should pass before policy mutation\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"require_source_digest": true
}
"#,
)
.expect("mutate policy file");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify stale policy receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stale policy digest receipt should fail"
);
assert!(
String::from_utf8_lossy(&verify_output.stderr).contains("policy source digest mismatch"),
"stderr should report policy digest mismatch:\n{}",
String::from_utf8_lossy(&verify_output.stderr)
);
}
#[test]
fn receipt_verify_json_reports_failed_policy_file_digest() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_policy_json_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt policy json fixture dir");
let entry = dir.join("entry.bld");
let policy = dir.join("policy.json");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write policy json receipt entry");
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}
"#,
)
.expect("write initial json policy");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write file-backed policy receipt for json verify");
assert!(
check_output.status.success(),
"check should pass before json policy mutation\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"require_source_digest": true
}
"#,
)
.expect("mutate json policy file");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--json")
.output()
.expect("verify stale policy receipt as json");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stale policy json receipt should fail"
);
let report: serde_json::Value = serde_json::from_slice(&verify_output.stdout)
.expect("policy failure report should be JSON");
assert_eq!(report["status"], "failed");
let policy_check = verification_check(&report, "policy_source_digest");
assert_eq!(policy_check["status"], "failed");
assert!(
policy_check["message"]
.as_str()
.expect("policy failure message")
.contains("policy source digest mismatch"),
"policy failure should explain mismatch: {policy_check:#?}"
);
}
#[test]
fn receipt_verify_expect_policy_digest_rejects_stripped_policy() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_expect_policy_stripped_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create expect policy digest fixture dir");
let entry = dir.join("entry.bld");
let policy = dir.join("policy.json");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write expect policy digest entry");
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}
"#,
)
.expect("write expected policy");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write policy-backed receipt");
assert!(
check_output.status.success(),
"check should pass before stripping policy\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let mut saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read policy receipt"))
.expect("policy receipt should parse");
let expected_digest = saved["policy"]["source_digest"]["hex"]
.as_str()
.expect("policy digest")
.to_string();
saved
.as_object_mut()
.expect("receipt should be an object")
.remove("policy");
fs::write(
&receipt,
serde_json::to_string_pretty(&saved).expect("serialize stripped policy receipt"),
)
.expect("write stripped policy receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--expect-policy-digest")
.arg(format!("sha256:{expected_digest}"))
.output()
.expect("verify stripped policy with expected digest");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stripped policy receipt should fail policy digest expectation"
);
assert!(
String::from_utf8_lossy(&verify_output.stderr).contains("receipt policy digest mismatch"),
"stderr should report expected policy digest mismatch:\n{}",
String::from_utf8_lossy(&verify_output.stderr)
);
}
#[test]
fn receipt_verify_expect_policy_digest_rejects_algorithm_tamper() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_expect_policy_algorithm_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create expect policy digest algorithm fixture dir");
let entry = dir.join("entry.bld");
let policy = dir.join("policy.json");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write expect policy digest algorithm entry");
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}
"#,
)
.expect("write expected algorithm policy");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write policy-backed receipt for algorithm tamper");
assert!(
check_output.status.success(),
"check should pass before tampering policy digest algorithm\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let mut saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read policy algorithm receipt"))
.expect("policy algorithm receipt should parse");
let expected_digest = saved["policy"]["source_digest"]["hex"]
.as_str()
.expect("policy digest")
.to_string();
saved["policy"]
.as_object_mut()
.expect("policy should be an object")
.remove("source");
saved["policy"]["source_digest"]["algorithm"] = serde_json::Value::String("sha512".into());
fs::write(
&receipt,
serde_json::to_string_pretty(&saved).expect("serialize algorithm-tampered receipt"),
)
.expect("write algorithm-tampered policy receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--expect-policy-digest")
.arg(format!("sha256:{expected_digest}"))
.arg("--json")
.output()
.expect("verify algorithm-tampered policy digest");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"algorithm-tampered policy digest receipt should fail policy digest expectation"
);
let report: serde_json::Value = serde_json::from_slice(&verify_output.stdout)
.expect("algorithm-tampered policy digest report should be JSON");
let policy_check = verification_check(&report, "expected_policy_digest");
assert_eq!(policy_check["status"], "failed");
assert_eq!(
policy_check["expected"],
format!("sha256:{expected_digest}")
);
assert_eq!(policy_check["actual"], format!("sha512:{expected_digest}"));
}
#[test]
fn receipt_verify_json_reports_expected_policy_digest_mismatch() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_expect_policy_json_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create expect policy digest json fixture dir");
let entry = dir.join("entry.bld");
let policy = dir.join("policy.json");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write expect policy digest json entry");
fs::write(
&policy,
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}
"#,
)
.expect("write expected json policy");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write policy-backed receipt for json expectation");
assert!(
check_output.status.success(),
"check should pass before policy digest mismatch\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read policy digest receipt"))
.expect("policy digest receipt should parse");
let actual_digest = saved["policy"]["source_digest"]["hex"]
.as_str()
.expect("policy digest")
.to_string();
let wrong_digest = "0".repeat(64);
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--expect-policy-digest")
.arg(format!("sha256:{wrong_digest}"))
.arg("--json")
.output()
.expect("verify policy digest mismatch as json");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"mismatched policy digest receipt should fail json verification"
);
let report: serde_json::Value = serde_json::from_slice(&verify_output.stdout)
.expect("policy digest mismatch report should be JSON");
assert_eq!(report["status"], "failed");
let policy_check = verification_check(&report, "expected_policy_digest");
assert_eq!(policy_check["status"], "failed");
assert_eq!(policy_check["expected"], format!("sha256:{wrong_digest}"));
assert_eq!(policy_check["actual"], format!("sha256:{actual_digest}"));
assert!(
policy_check["message"]
.as_str()
.expect("expected policy digest failure message")
.contains("receipt policy digest mismatch"),
"policy digest failure should explain mismatch: {policy_check:#?}"
);
}
#[test]
fn receipt_verify_rejects_tampered_observed_capabilities() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_tampered_capabilities_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create tampered receipt fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(&entry, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write tampered receipt entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write receipt before capability tamper");
assert!(
check_output.status.success(),
"check should pass before receipt tamper\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let mut saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read saved receipt"))
.expect("saved receipt should parse");
saved["observed_capabilities"]["main"]["Console"] = serde_json::json!(["forged_console"]);
fs::write(
&receipt,
serde_json::to_string_pretty(&saved).expect("serialize tampered receipt"),
)
.expect("write tampered receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify tampered receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"tampered capability receipt should fail verification"
);
assert!(
String::from_utf8_lossy(&verify_output.stderr)
.contains("receipt observed_capabilities mismatch"),
"stderr should report observed capability mismatch:\n{}",
String::from_utf8_lossy(&verify_output.stderr)
);
}
#[test]
fn receipt_verify_json_reports_tampered_propagated_effects() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_tampered_propagated_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create tampered propagated receipt fixture dir");
let entry = dir.join("entry.bld");
let receipt = dir.join("receipt.json");
fs::write(
&entry,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write propagated receipt entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write receipt before propagated tamper");
assert!(
check_output.status.success(),
"check should pass before propagated tamper\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let mut saved: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read saved propagated receipt"))
.expect("saved propagated receipt should parse");
saved["propagated_effects"]["main"]["FileSystem"] = serde_json::json!(["forged_boundary"]);
fs::write(
&receipt,
serde_json::to_string_pretty(&saved).expect("serialize tampered propagated receipt"),
)
.expect("write tampered propagated receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--json")
.output()
.expect("verify tampered propagated receipt as json");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"tampered propagated receipt should fail verification"
);
let report: serde_json::Value = serde_json::from_slice(&verify_output.stdout)
.expect("tampered propagated failure report should be JSON");
assert_eq!(report["status"], "failed");
let replay_check = verification_check(&report, "propagated_effects");
assert_eq!(replay_check["status"], "failed");
assert!(
replay_check["message"]
.as_str()
.expect("propagated replay failure message")
.contains("receipt propagated_effects mismatch"),
"propagated failure should explain mismatch: {replay_check:#?}"
);
}
#[test]
fn receipt_verify_rejects_changed_input_graph() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_graph_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt graph fixture dir");
let entry = dir.join("entry.bld");
let shared = dir.join("shared.bld");
let receipt = dir.join("receipt.json");
fs::write(
&entry,
r#"include!("shared.bld");
fn main() ~ Console { println!("{}", value()); }
"#,
)
.expect("write receipt graph entry");
fs::write(&shared, "fn value() -> i32 { 7 }\n").expect("write first shared source");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write graph receipt");
assert!(
check_output.status.success(),
"check should pass before graph mutation\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
fs::write(&shared, "fn value() -> i32 { 8 }\n").expect("mutate shared source");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify stale graph receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"stale input graph receipt should fail"
);
assert!(
String::from_utf8_lossy(&verify_output.stderr).contains("input graph digest mismatch"),
"stderr should report graph mismatch:\n{}",
String::from_utf8_lossy(&verify_output.stderr)
);
}
#[test]
fn receipt_verify_rejects_tampered_builtin_profile_digest() {
let dir = std::env::temp_dir().join(format!(
"buildlang_receipt_verify_profile_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create receipt profile fixture dir");
let entry = dir.join("entry.bld");
let receipt_path = dir.join("receipt.json");
fs::write(&entry, r#"fn main() {}"#).expect("write pure entry");
let check_output = buildc()
.arg("check")
.arg(&entry)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg(&receipt_path)
.output()
.expect("write built-in profile receipt");
assert!(
check_output.status.success(),
"check should pass before profile digest tamper\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check_output.stdout),
String::from_utf8_lossy(&check_output.stderr)
);
let receipt_text = fs::read_to_string(&receipt_path).expect("read receipt json");
let mut receipt_json: serde_json::Value =
serde_json::from_str(&receipt_text).expect("receipt should be JSON");
receipt_json["policy"]["profile_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
fs::write(
&receipt_path,
serde_json::to_string_pretty(&receipt_json).expect("serialize tampered receipt"),
)
.expect("write tampered receipt");
let verify_output = buildc()
.args(["receipt", "verify"])
.arg(&receipt_path)
.output()
.expect("verify tampered profile receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify_output.status.success(),
"tampered profile digest receipt should fail"
);
let stderr = String::from_utf8_lossy(&verify_output.stderr);
assert!(
stderr.contains("built-in policy profile digest mismatch"),
"stderr should report profile digest mismatch:\n{stderr}"
);
assert!(
stderr.contains("pure"),
"stderr should name the profile:\n{stderr}"
);
}
#[test]
fn check_policy_allows_console_receipt() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_console_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"console_allow",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"],
"require_source_digest": true
}"#,
);
fs::write(&fixture, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write policy console fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with passing policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"console policy check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "passed");
assert_eq!(receipt["policy"]["schema"], "buildlang-check-policy/v1");
assert_eq!(receipt["policy"]["status"], "passed");
assert_eq!(receipt["policy"]["source_digest"]["algorithm"], "sha256");
assert_eq!(
receipt["policy"]["source_digest"]["hex"]
.as_str()
.expect("policy digest")
.len(),
64
);
assert!(receipt["policy"]["violations"]
.as_array()
.unwrap()
.is_empty());
}
#[test]
fn check_policy_denies_filesystem_even_when_typecheck_passes() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_deny_fs_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"deny_fs",
r#"{
"schema": "buildlang-check-policy/v1",
"denied_effects": ["FileSystem"]
}"#,
);
fs::write(
&fixture,
r#"fn main() ~ FileSystem { read_file("ops.txt"); }"#,
)
.expect("write denied filesystem fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with denied filesystem policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(!output.status.success(), "policy denial should fail check");
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DeniedEffect"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["message"]
.as_str()
.unwrap_or("")
.contains("policy denies effect `FileSystem`")
}),
"expected FileSystem denied violation in {violations:#?}"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("Policy violation"),
"stderr should include policy diagnostic:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_policy_denies_gpu_even_when_typecheck_passes() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_deny_gpu_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"deny_gpu",
r#"{
"schema": "buildlang-check-policy/v1",
"denied_effects": ["Gpu"]
}"#,
);
fs::write(&fixture, r#"fn main() ~ Gpu { build_vk_init(); }"#)
.expect("write denied gpu fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with denied gpu policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(!output.status.success(), "policy denial should fail check");
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DeniedEffect"
&& violation["effect"] == "Gpu"
&& violation["function"] == "main"
&& violation["source"] == "build_vk_init"
}),
"expected Gpu denied violation in {violations:#?}"
);
}
#[test]
fn check_policy_rejects_unknown_effect_name() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_unknown_effect_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"unknown_effect",
r#"{
"schema": "buildlang-check-policy/v1",
"denied_effects": ["Netwrok"]
}"#,
);
fs::write(&fixture, r#"fn main() {}"#).expect("write unknown policy effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with unknown policy effect");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"unknown policy effect should fail check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["status"], "failed");
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "UnknownPolicyEffect"
&& violation["effect"] == "Netwrok"
&& violation["surface"] == "denied_effects"
&& violation["message"]
.as_str()
.unwrap_or("")
.contains("unknown effect")
}),
"expected unknown policy effect violation in {violations:#?}"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("unknown effect"),
"stderr should report unknown policy effect:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_policy_allows_source_defined_effect_name() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_user_effect_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"user_effect",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Audit"]
}"#,
);
fs::write(
&fixture,
r#"
effect Audit {
fn record();
}
fn main() ~ Audit {}
"#,
)
.expect("write source-defined effect fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with source-defined effect policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"source-defined effect should be accepted by policy validator\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert_eq!(
receipt["declared_effects"]["main"],
serde_json::json!(["Audit"])
);
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_allow_list_rejects_unlisted_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_allow_list_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"allow_console_only",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"]
}"#,
);
fs::write(
&fixture,
r#"fn main() ~ FileSystem { read_file("ops.txt"); }"#,
)
.expect("write allow-list filesystem fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with allow-list policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"unlisted effect should fail policy"
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DisallowedEffect"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
}),
"expected FileSystem disallowed violation in {violations:#?}"
);
}
#[test]
fn check_policy_required_effect_allowlist_rejects_unlisted_declared_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_effect_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_effect_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": [],
"require_effect_allowlist": true
}"#,
);
fs::write(
&fixture,
r#"
effect Audit {
fn record();
}
fn main() ~ Audit {}
"#,
)
.expect("write required effect allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required effect allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"required empty effect allowlist should reject declared effect\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DisallowedEffect"
&& violation["effect"] == "Audit"
&& violation["function"] == "main"
}),
"expected Audit disallowed violation in {violations:#?}"
);
}
#[test]
fn check_policy_direct_allowlist_rejects_unapproved_direct_effect() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_direct_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"direct_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
}
}"#,
);
fs::write(
&fixture,
r#"fn main() ~ FileSystem { read_file("ops.txt"); }"#,
)
.expect("write direct allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with direct allowlist policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should reject direct helper\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DirectEffectNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "observed_capabilities"
&& violation["source"] == "read_file"
}),
"expected direct effect allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_provenance_allowlists_accept_boundary_and_caller() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_provenance_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"provenance_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write provenance allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with provenance allowlists");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept allowlisted provenance\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["load_config"])
);
}
#[test]
fn check_policy_strict_allowlist_coverage_rejects_unused_direct_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_unused_direct_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"unused_direct_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config", "legacy_loader"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"require_allowlist_coverage": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write unused direct allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with strict allowlist coverage");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"strict policy should reject unused direct allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "UnusedDirectEffectAllowlist"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "legacy_loader"
&& violation["surface"] == "direct_effect_allowlist"
&& violation["message"]
.as_str()
.unwrap_or("")
.contains("not matched")
}),
"expected unused direct allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_strict_allowlist_coverage_rejects_unused_propagated_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_unused_propagated_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"unused_propagated_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main", "legacy_workflow"]
},
"require_allowlist_coverage": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write unused propagated allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with strict propagated allowlist coverage");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"strict policy should reject unused propagated allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "UnusedPropagatedEffectAllowlist"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "legacy_workflow"
&& violation["surface"] == "propagated_effect_allowlist"
&& violation["message"]
.as_str()
.unwrap_or("")
.contains("not matched")
}),
"expected unused propagated allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_strict_allowlist_coverage_accepts_used_entries() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_used_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"used_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"require_allowlist_coverage": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write used allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with used strict allowlists");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"strict policy should accept fully-used allowlist entries\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_requires_direct_provenance_allowlist_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_direct_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_direct_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"require_provenance_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"fn main() ~ FileSystem { read_file("ops.txt"); }"#,
)
.expect("write required direct allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required direct allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should require explicit direct provenance allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DirectEffectNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "observed_capabilities"
&& violation["source"] == "read_file"
}),
"expected required direct provenance violation in {violations:#?}"
);
}
#[test]
fn check_policy_requires_propagated_provenance_allowlist_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_propagated_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_propagated_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"require_provenance_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write required propagated allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required propagated allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should require explicit propagated provenance allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "PropagatedEffectNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "propagated_effects"
&& violation["source"] == "load_config"
}),
"expected required propagated provenance violation in {violations:#?}"
);
}
#[test]
fn check_policy_required_provenance_allowlists_accept_explicit_entries() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_required_allowlists_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"required_allowlists_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"require_provenance_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write required allowlists accept fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required explicit allowlists");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept explicit direct and propagated allowlists\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_direct_capability_source_allowlist_rejects_unapproved_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_direct_source_reject_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"direct_source_reject",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"direct_capability_source_allowlist": {
"FileSystem": {
"load_config": ["read_file"]
}
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
write_file("ops.txt", "x");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write direct source allowlist rejection fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with direct source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should reject unapproved direct capability source\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DirectCapabilitySourceNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "load_config"
&& violation["surface"] == "observed_capabilities"
&& violation["source"] == "write_file"
}),
"expected direct capability source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_direct_capability_source_allowlist_accepts_approved_source() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_direct_source_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"direct_source_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"direct_capability_source_allowlist": {
"FileSystem": {
"load_config": ["read_file"]
}
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write direct source allowlist acceptance fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with approved direct source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept approved direct capability source\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_strict_allowlist_coverage_rejects_unused_direct_capability_source_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_unused_direct_source_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"unused_direct_source_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"direct_capability_source_allowlist": {
"FileSystem": {
"load_config": ["read_file", "legacy_reader"]
}
},
"require_allowlist_coverage": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write unused direct source allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with strict direct source coverage");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"strict policy should reject unused direct capability source entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "UnusedDirectCapabilitySourceAllowlist"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "load_config"
&& violation["surface"] == "direct_capability_source_allowlist"
&& violation["source"] == "legacy_reader"
}),
"expected unused direct capability source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_propagated_effect_source_allowlist_rejects_unapproved_callee() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_propagated_source_reject_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"propagated_source_reject",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config", "load_secret"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"propagated_effect_source_allowlist": {
"FileSystem": {
"main": ["load_config"]
}
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn load_secret() ~ FileSystem {
read_file("secret.txt");
}
fn main() ~ FileSystem {
load_secret();
}
"#,
)
.expect("write propagated source allowlist rejection fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with propagated source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should reject unapproved propagated effect source\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "PropagatedEffectSourceNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "propagated_effects"
&& violation["source"] == "load_secret"
}),
"expected propagated effect source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_propagated_effect_source_allowlist_accepts_approved_callee() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_propagated_source_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"propagated_source_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"propagated_effect_source_allowlist": {
"FileSystem": {
"main": ["load_config"]
}
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write propagated source allowlist acceptance fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with approved propagated source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept approved propagated effect source\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_propagated_effect_source_allowlist_accepts_approved_method() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_propagated_method_source_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"propagated_method_source_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"propagated_effect_source_allowlist": {
"FileSystem": {
"main": ["Config.load"]
}
}
}"#,
);
fs::write(
&fixture,
r#"
struct Config;
impl Config {
fn load(self) ~ FileSystem {
read_file("ops.txt");
}
}
fn main() ~ FileSystem {
let config = Config;
config.load();
}
"#,
)
.expect("write propagated method source allowlist acceptance fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with approved propagated method source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept approved propagated method source\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(
receipt["propagated_effects"]["main"]["FileSystem"],
serde_json::json!(["Config.load"])
);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_strict_allowlist_coverage_rejects_unused_propagated_effect_source_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_unused_propagated_source_allowlist_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"unused_propagated_source_allowlist",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"propagated_effect_source_allowlist": {
"FileSystem": {
"main": ["load_config", "legacy_loader"]
}
},
"require_allowlist_coverage": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write unused propagated source allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with strict propagated source coverage");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"strict policy should reject unused propagated effect source entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "UnusedPropagatedEffectSourceAllowlist"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "propagated_effect_source_allowlist"
&& violation["source"] == "legacy_loader"
}),
"expected unused propagated effect source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_require_source_allowlists_rejects_missing_direct_source_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_direct_source_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_direct_source",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"require_source_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
"#,
)
.expect("write required direct source allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required direct source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should require direct capability source allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DirectCapabilitySourceNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "load_config"
&& violation["surface"] == "observed_capabilities"
&& violation["source"] == "read_file"
}),
"expected required direct source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_require_source_allowlists_rejects_missing_propagated_source_entry() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_propagated_source_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_propagated_source",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"direct_capability_source_allowlist": {
"FileSystem": {
"load_config": ["read_file"]
}
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"require_source_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write required propagated source allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required propagated source allowlist");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should require propagated effect source allowlist entry\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "PropagatedEffectSourceNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "propagated_effects"
&& violation["source"] == "load_config"
}),
"expected required propagated source allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_require_source_allowlists_accepts_explicit_source_entries() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_require_sources_accept_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"require_sources_accept",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"direct_capability_source_allowlist": {
"FileSystem": {
"load_config": ["read_file"]
}
},
"propagated_effect_allowlist": {
"FileSystem": ["main"]
},
"propagated_effect_source_allowlist": {
"FileSystem": {
"main": ["load_config"]
}
},
"require_source_allowlists": true
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write required source allowlists acceptance fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with required explicit source allowlists");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
output.status.success(),
"policy should accept explicit source allowlist entries\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "passed");
assert!(receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
}
#[test]
fn check_policy_propagated_allowlist_rejects_unlisted_caller() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_propagated_reject_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"propagated_reject",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["FileSystem"],
"direct_effect_allowlist": {
"FileSystem": ["load_config"]
},
"propagated_effect_allowlist": {
"FileSystem": []
}
}"#,
);
fs::write(
&fixture,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write propagated allowlist fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with propagated allowlist policy");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy should reject propagated caller\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "PropagatedEffectNotAllowed"
&& violation["effect"] == "FileSystem"
&& violation["function"] == "main"
&& violation["surface"] == "propagated_effects"
&& violation["source"] == "load_config"
}),
"expected propagated effect allowlist violation in {violations:#?}"
);
}
#[test]
fn check_policy_rejects_unsupported_schema() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_policy_bad_schema_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"bad_schema",
r#"{
"schema": "buildlang-check-policy/v0",
"allowed_effects": ["Console"]
}"#,
);
fs::write(&fixture, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write bad schema fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.output()
.expect("run buildc check with bad policy schema");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"unsupported policy schema should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("Unsupported check policy schema 'buildlang-check-policy/v0'"),
"stderr should report unsupported schema:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn policy_list_includes_builtin_security_profiles() {
let output = buildc()
.args(["policy", "list"])
.output()
.expect("run buildc policy list");
assert!(
output.status.success(),
"policy list should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(stdout.contains("pure"), "missing pure profile:\n{stdout}");
assert!(
stdout.contains("console-only"),
"missing console-only profile:\n{stdout}"
);
assert!(
stdout.contains("offline"),
"missing offline profile:\n{stdout}"
);
assert!(
stdout.contains("ci-review"),
"missing ci-review profile:\n{stdout}"
);
assert!(
stdout.contains("strict-accountability"),
"missing strict-accountability profile:\n{stdout}"
);
}
#[test]
fn policy_list_json_emits_catalog_with_profile_digests() {
let output = buildc()
.args(["policy", "list", "--json"])
.output()
.expect("run buildc policy list --json");
assert!(
output.status.success(),
"policy list --json should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let catalog: serde_json::Value =
serde_json::from_slice(&output.stdout).expect("catalog should be JSON");
assert_eq!(catalog["schema"], "buildlang-policy-catalog/v1");
let profiles = catalog["profiles"]
.as_array()
.expect("profiles should be an array");
let names = profiles
.iter()
.map(|profile| profile["name"].as_str().unwrap_or(""))
.collect::<Vec<_>>();
assert_eq!(
names,
vec![
"pure",
"console-only",
"offline",
"ci-review",
"strict-accountability"
]
);
for profile in profiles {
assert_eq!(
profile["policy_schema"], "buildlang-check-policy/v1",
"profile should name the policy schema: {profile:#?}"
);
assert!(
profile["summary"]
.as_str()
.is_some_and(|summary| !summary.is_empty()),
"profile should include a summary: {profile:#?}"
);
assert_eq!(profile["digest"]["algorithm"], "sha256");
assert_eq!(
profile["digest"]["hex"]
.as_str()
.expect("profile digest hex")
.len(),
64
);
}
}
#[test]
fn policy_list_json_digest_matches_printed_profile() {
let dir = std::env::temp_dir().join(format!(
"buildlang_policy_catalog_digest_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create policy catalog digest directory");
let profile_path = dir.join("ci-review.json");
let catalog_output = buildc()
.args(["policy", "list", "--json"])
.output()
.expect("run buildc policy list --json");
let print_output = buildc()
.args(["policy", "print", "ci-review", "--output"])
.arg(&profile_path)
.output()
.expect("write ci-review policy");
assert!(
catalog_output.status.success(),
"policy catalog should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&catalog_output.stdout),
String::from_utf8_lossy(&catalog_output.stderr)
);
assert!(
print_output.status.success(),
"policy print should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&print_output.stdout),
String::from_utf8_lossy(&print_output.stderr)
);
let catalog: serde_json::Value =
serde_json::from_slice(&catalog_output.stdout).expect("catalog should be JSON");
let ci_review_digest = catalog["profiles"]
.as_array()
.expect("profiles should be an array")
.iter()
.find(|profile| profile["name"] == "ci-review")
.expect("ci-review profile")["digest"]
.clone();
let printed_text = fs::read(&profile_path).expect("read printed policy");
let expected_hex = sha256_hex(&printed_text);
assert_eq!(ci_review_digest["algorithm"], "sha256");
assert_eq!(ci_review_digest["hex"], expected_hex);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn policy_print_emits_valid_pure_profile() {
let output = buildc()
.args(["policy", "print", "pure"])
.output()
.expect("run buildc policy print pure");
assert!(
output.status.success(),
"policy print should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let profile: serde_json::Value =
serde_json::from_slice(&output.stdout).expect("policy profile should be JSON");
assert_eq!(profile["schema"], "buildlang-check-policy/v1");
assert_eq!(profile["require_source_digest"], true);
assert_eq!(profile["require_input_graph_digest"], true);
let denied = profile["denied_effects"]
.as_array()
.expect("denied_effects should be an array");
assert!(
denied.iter().any(|effect| effect == "Network"),
"pure profile should deny Network: {denied:#?}"
);
assert!(
denied.iter().any(|effect| effect == "Foreign"),
"pure profile should deny Foreign: {denied:#?}"
);
}
#[test]
fn policy_print_emits_strict_accountability_profile_with_source_gates() {
let output = buildc()
.args(["policy", "print", "strict-accountability"])
.output()
.expect("run buildc policy print strict-accountability");
assert!(
output.status.success(),
"policy print should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let profile: serde_json::Value =
serde_json::from_slice(&output.stdout).expect("policy profile should be JSON");
assert_eq!(profile["schema"], "buildlang-check-policy/v1");
assert_eq!(profile["require_source_digest"], true);
assert_eq!(profile["require_input_graph_digest"], true);
assert_eq!(profile["require_effect_allowlist"], true);
assert_eq!(profile["require_provenance_allowlists"], true);
assert_eq!(profile["require_source_allowlists"], true);
assert_eq!(profile["require_allowlist_coverage"], true);
let denied = profile["denied_effects"]
.as_array()
.expect("denied_effects should be an array");
for effect in ["Network", "Process", "Foreign", "Gpu"] {
assert!(
denied.iter().any(|denied| denied == effect),
"strict-accountability profile should deny {effect}: {denied:#?}"
);
}
}
#[test]
fn policy_scaffold_from_receipt_emits_exact_source_allowlists() {
let dir = std::env::temp_dir().join(format!(
"buildlang_policy_scaffold_receipt_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create policy scaffold fixture directory");
let input = dir.join("app.bld");
let receipt = dir.join("receipt.json");
let policy = dir.join("policy.json");
fs::write(
&input,
r#"
fn load_config() ~ FileSystem {
read_file("ops.txt");
}
fn main() ~ FileSystem {
load_config();
}
"#,
)
.expect("write policy scaffold input");
let check = buildc()
.arg("check")
.arg(&input)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write policy scaffold receipt");
assert!(
check.status.success(),
"check should produce a receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check.stdout),
String::from_utf8_lossy(&check.stderr)
);
let scaffold = buildc()
.arg("policy")
.arg("scaffold")
.arg(&receipt)
.arg("--output")
.arg(&policy)
.output()
.expect("scaffold policy from receipt");
assert!(
scaffold.status.success(),
"policy scaffold should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&scaffold.stdout),
String::from_utf8_lossy(&scaffold.stderr)
);
let scaffolded: serde_json::Value =
serde_json::from_slice(&fs::read(&policy).expect("read scaffolded policy"))
.expect("scaffolded policy should be JSON");
assert_eq!(scaffolded["schema"], "buildlang-check-policy/v1");
assert_eq!(
scaffolded["allowed_effects"],
serde_json::json!(["FileSystem"])
);
assert_eq!(
scaffolded["direct_effect_allowlist"]["FileSystem"],
serde_json::json!(["load_config"])
);
assert_eq!(
scaffolded["direct_capability_source_allowlist"]["FileSystem"]["load_config"],
serde_json::json!(["read_file"])
);
assert_eq!(
scaffolded["propagated_effect_allowlist"]["FileSystem"],
serde_json::json!(["main"])
);
assert_eq!(
scaffolded["propagated_effect_source_allowlist"]["FileSystem"]["main"],
serde_json::json!(["load_config"])
);
assert_eq!(scaffolded["require_source_digest"], true);
assert_eq!(scaffolded["require_input_graph_digest"], true);
assert_eq!(scaffolded["require_effect_allowlist"], true);
assert_eq!(scaffolded["require_provenance_allowlists"], true);
assert_eq!(scaffolded["require_source_allowlists"], true);
assert_eq!(scaffolded["require_allowlist_coverage"], true);
let verify_scaffold = buildc()
.arg("check")
.arg(&input)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("check source with scaffolded policy");
assert!(
verify_scaffold.status.success(),
"scaffolded policy should accept the exact receipt evidence\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_scaffold.stdout),
String::from_utf8_lossy(&verify_scaffold.stderr)
);
let verified_receipt = receipt_from_stdout(&verify_scaffold);
assert_eq!(verified_receipt["policy"]["status"], "passed");
assert!(verified_receipt["policy"]["violations"]
.as_array()
.expect("policy violations")
.is_empty());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn policy_scaffold_from_pure_receipt_rejects_later_effect_drift() {
let dir = std::env::temp_dir().join(format!(
"buildlang_policy_scaffold_pure_drift_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create pure scaffold drift fixture directory");
let input = dir.join("app.bld");
let receipt = dir.join("receipt.json");
let policy = dir.join("policy.json");
fs::write(&input, "fn main() {}\n").expect("write pure policy scaffold input");
let check = buildc()
.arg("check")
.arg(&input)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write pure policy scaffold receipt");
assert!(
check.status.success(),
"pure check should produce a receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check.stdout),
String::from_utf8_lossy(&check.stderr)
);
let scaffold = buildc()
.arg("policy")
.arg("scaffold")
.arg(&receipt)
.arg("--output")
.arg(&policy)
.output()
.expect("scaffold policy from pure receipt");
assert!(
scaffold.status.success(),
"pure policy scaffold should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&scaffold.stdout),
String::from_utf8_lossy(&scaffold.stderr)
);
let scaffolded: serde_json::Value =
serde_json::from_slice(&fs::read(&policy).expect("read pure scaffolded policy"))
.expect("pure scaffolded policy should be JSON");
assert_eq!(scaffolded["allowed_effects"], serde_json::json!([]));
assert_eq!(scaffolded["require_effect_allowlist"], true);
fs::write(
&input,
r#"
effect Audit {
fn record();
}
fn main() ~ Audit {}
"#,
)
.expect("write drifted effect input");
let drift = buildc()
.arg("check")
.arg(&input)
.arg("--policy")
.arg(&policy)
.arg("--receipt")
.arg("-")
.output()
.expect("check drifted source with pure scaffolded policy");
assert!(
!drift.status.success(),
"pure scaffolded policy should reject later declared effect drift\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&drift.stdout),
String::from_utf8_lossy(&drift.stderr)
);
let receipt = receipt_from_stdout(&drift);
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DisallowedEffect"
&& violation["effect"] == "Audit"
&& violation["function"] == "main"
}),
"expected declared effect drift violation in {violations:#?}"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn policy_scaffold_from_foreign_receipt_preserves_direct_ffi_boundary() {
let dir = std::env::temp_dir().join(format!(
"buildlang_policy_scaffold_foreign_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create foreign scaffold fixture directory");
let input = dir.join("app.bld");
let receipt = dir.join("receipt.json");
fs::write(
&input,
r#"
extern "C" { fn touch(); }
fn main() ~ Foreign {
touch();
}
"#,
)
.expect("write foreign policy scaffold input");
let check = buildc()
.arg("check")
.arg(&input)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write foreign policy scaffold receipt");
assert!(
check.status.success(),
"foreign check should produce a receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check.stdout),
String::from_utf8_lossy(&check.stderr)
);
let scaffold = buildc()
.arg("policy")
.arg("scaffold")
.arg(&receipt)
.output()
.expect("scaffold policy from foreign receipt");
assert!(
scaffold.status.success(),
"foreign policy scaffold should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&scaffold.stdout),
String::from_utf8_lossy(&scaffold.stderr)
);
let scaffolded: serde_json::Value =
serde_json::from_slice(&scaffold.stdout).expect("foreign scaffold should be JSON");
assert_eq!(
scaffolded["allowed_effects"],
serde_json::json!(["Foreign"])
);
assert_eq!(
scaffolded["direct_effect_allowlist"]["Foreign"],
serde_json::json!(["main"])
);
assert_eq!(
scaffolded["direct_capability_source_allowlist"]["Foreign"]["main"],
serde_json::json!(["touch"])
);
assert!(
scaffolded["propagated_effect_allowlist"]
.as_object()
.expect("propagated effect allowlist")
.is_empty(),
"direct FFI boundary should not be scaffolded as propagated: {scaffolded:#?}"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn policy_scaffold_from_qualified_capability_receipt_preserves_source_path() {
let dir = std::env::temp_dir().join(format!(
"buildlang_policy_scaffold_qualified_capability_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create qualified scaffold fixture directory");
let input = dir.join("app.bld");
let receipt = dir.join("receipt.json");
fs::write(
&input,
r#"fn main() ~ FileSystem { io::read_file("ops.txt"); }"#,
)
.expect("write qualified policy scaffold input");
let check = buildc()
.arg("check")
.arg(&input)
.arg("--receipt")
.arg(&receipt)
.output()
.expect("write qualified policy scaffold receipt");
assert!(
check.status.success(),
"qualified check should produce a receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&check.stdout),
String::from_utf8_lossy(&check.stderr)
);
let scaffold = buildc()
.arg("policy")
.arg("scaffold")
.arg(&receipt)
.output()
.expect("scaffold policy from qualified receipt");
assert!(
scaffold.status.success(),
"qualified policy scaffold should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&scaffold.stdout),
String::from_utf8_lossy(&scaffold.stderr)
);
let scaffolded: serde_json::Value =
serde_json::from_slice(&scaffold.stdout).expect("qualified scaffold should be JSON");
assert_eq!(
scaffolded["direct_effect_allowlist"]["FileSystem"],
serde_json::json!(["main"])
);
assert_eq!(
scaffolded["direct_capability_source_allowlist"]["FileSystem"]["main"],
serde_json::json!(["io::read_file"])
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn printed_pure_policy_rejects_console_program() {
let dir = std::env::temp_dir().join(format!(
"buildlang_printed_pure_policy_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create pure policy fixture directory");
let policy_path = dir.join("pure-policy.json");
let fixture = dir.join("console.bld");
let print = buildc()
.args(["policy", "print", "pure", "--output"])
.arg(&policy_path)
.output()
.expect("write pure policy");
assert!(
print.status.success(),
"policy print --output should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&print.stdout),
String::from_utf8_lossy(&print.stderr)
);
fs::write(&fixture, r#"fn main() ~ Console { println!("blocked"); }"#)
.expect("write console fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy_path)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with pure policy");
assert!(
!output.status.success(),
"pure policy should reject console program\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DeniedEffect"
&& violation["effect"] == "Console"
&& violation["function"] == "main"
}),
"expected Console denial in {violations:#?}"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_profile_strict_accountability_rejects_ambient_console_without_allowlists() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_strict_accountability_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() ~ Console { println!("blocked"); }"#)
.expect("write console fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--profile")
.arg("strict-accountability")
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with strict-accountability profile");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"strict-accountability profile should reject console without allowlists\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["source"], "builtin:strict-accountability");
assert_eq!(receipt["policy"]["profile"], "strict-accountability");
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DisallowedEffect"
&& violation["effect"] == "Console"
&& violation["function"] == "main"
}),
"expected strict Console effect allowlist denial in {violations:#?}"
);
}
#[test]
fn check_profile_pure_rejects_console_program_without_policy_file() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_pure_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() ~ Console { println!("blocked"); }"#)
.expect("write console fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check with pure profile");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"pure profile should reject console program\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["source"], "builtin:pure");
assert_eq!(receipt["policy"]["profile"], "pure");
assert_eq!(receipt["policy"]["profile_digest"]["algorithm"], "sha256");
assert_eq!(
receipt["policy"]["profile_digest"]["hex"]
.as_str()
.expect("profile digest")
.len(),
64
);
assert_eq!(receipt["policy"]["status"], "failed");
let violations = receipt["policy"]["violations"]
.as_array()
.expect("policy violations");
assert!(
violations.iter().any(|violation| {
violation["kind"] == "DeniedEffect"
&& violation["effect"] == "Console"
&& violation["function"] == "main"
}),
"expected Console denial in {violations:#?}"
);
}
#[test]
fn check_profile_receipt_digest_matches_printed_builtin_profile() {
let dir = std::env::temp_dir().join(format!("buildlang_profile_digest_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create profile digest fixture directory");
let profile_path = dir.join("pure.json");
let input = dir.join("pure.bld");
let print = buildc()
.args(["policy", "print", "pure", "--output"])
.arg(&profile_path)
.output()
.expect("write pure profile");
assert!(
print.status.success(),
"policy print should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&print.stdout),
String::from_utf8_lossy(&print.stderr)
);
fs::write(&input, r#"fn main() {}"#).expect("write pure input");
let via_profile = buildc()
.arg("check")
.arg(&input)
.arg("--profile")
.arg("pure")
.arg("--receipt")
.arg("-")
.output()
.expect("run check with built-in profile");
let via_policy = buildc()
.arg("check")
.arg(&input)
.arg("--policy")
.arg(&profile_path)
.arg("--receipt")
.arg("-")
.output()
.expect("run check with printed profile");
assert!(
via_profile.status.success(),
"built-in profile check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&via_profile.stdout),
String::from_utf8_lossy(&via_profile.stderr)
);
assert!(
via_policy.status.success(),
"printed policy check should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&via_policy.stdout),
String::from_utf8_lossy(&via_policy.stderr)
);
let profile_receipt = receipt_from_stdout(&via_profile);
let policy_receipt = receipt_from_stdout(&via_policy);
assert_eq!(profile_receipt["policy"]["profile"], "pure");
assert_eq!(
profile_receipt["policy"]["profile_digest"],
policy_receipt["policy"]["source_digest"]
);
assert_eq!(policy_receipt["policy"]["profile"], serde_json::Value::Null);
assert_eq!(
policy_receipt["policy"]["profile_digest"],
serde_json::Value::Null
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_profile_expect_digest_accepts_matching_builtin_digest() {
let dir = std::env::temp_dir().join(format!(
"buildlang_profile_expect_digest_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create profile digest fixture directory");
let input = dir.join("pure.bld");
fs::write(&input, r#"fn main() {}"#).expect("write pure input");
let catalog_output = buildc()
.args(["policy", "list", "--json"])
.output()
.expect("run buildc policy list --json");
assert!(
catalog_output.status.success(),
"policy catalog should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&catalog_output.stdout),
String::from_utf8_lossy(&catalog_output.stderr)
);
let catalog: serde_json::Value =
serde_json::from_slice(&catalog_output.stdout).expect("catalog should be JSON");
let pure_digest = catalog["profiles"]
.as_array()
.expect("profiles should be an array")
.iter()
.find(|profile| profile["name"] == "pure")
.expect("pure profile")["digest"]["hex"]
.as_str()
.expect("pure digest")
.to_string();
let output = buildc()
.arg("check")
.arg(&input)
.arg("--profile")
.arg("pure")
.arg("--expect-profile-digest")
.arg(&pure_digest)
.arg("--receipt")
.arg("-")
.output()
.expect("run check with matching profile digest");
assert!(
output.status.success(),
"matching profile digest should pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["policy"]["profile"], "pure");
assert_eq!(receipt["policy"]["profile_digest"]["hex"], pure_digest);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_profile_expect_digest_rejects_mismatch() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_digest_mismatch_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() {}"#).expect("write pure fixture");
let wrong_digest = "0".repeat(64);
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--profile")
.arg("pure")
.arg("--expect-profile-digest")
.arg(&wrong_digest)
.output()
.expect("run check with mismatched profile digest");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"mismatched profile digest should fail"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Built-in policy profile digest mismatch"),
"stderr should report digest mismatch:\n{stderr}"
);
assert!(
stderr.contains("pure"),
"stderr should name the profile:\n{stderr}"
);
}
#[test]
fn check_expect_profile_digest_requires_builtin_profile() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_digest_without_profile_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() {}"#).expect("write pure fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--expect-profile-digest")
.arg("0".repeat(64))
.output()
.expect("run check with profile digest but no profile");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"profile digest pin without profile should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("requires --profile"),
"stderr should report missing --profile:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_profile_rejects_unknown_builtin_profile() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_unknown_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() {}"#).expect("write pure fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--profile")
.arg("missing")
.output()
.expect("run buildc check with missing profile");
let _ = fs::remove_file(&fixture);
assert!(!output.status.success(), "unknown profile should fail");
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("Unknown built-in policy profile 'missing'"),
"stderr should name the unknown profile:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn check_rejects_policy_file_and_builtin_profile_together() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_check_profile_conflict_{}.bld",
std::process::id()
));
let policy = write_temp_policy(
"profile_conflict",
r#"{
"schema": "buildlang-check-policy/v1",
"allowed_effects": ["Console"]
}"#,
);
fs::write(&fixture, r#"fn main() ~ Console { println!("ok"); }"#)
.expect("write conflict fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.arg("--policy")
.arg(&policy)
.arg("--profile")
.arg("pure")
.output()
.expect("run buildc check with conflicting policy inputs");
let _ = fs::remove_file(&fixture);
let _ = fs::remove_file(&policy);
assert!(
!output.status.success(),
"policy file and profile should conflict"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("cannot be used with"),
"stderr should report the argument conflict:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_accepts_explicit_root() {
if !c_backend_ready() {
eprintln!("skipping semantic corpus root verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with explicit root");
assert!(
output.status.success(),
"corpus verify --root should exit successfully\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("c execution: 9 passed"),
"corpus verify --root should run the manifest programs:\n{}",
stdout
);
}
#[test]
fn corpus_verify_write_repairs_receipt_program_drift_in_copy() {
if !c_backend_ready() {
eprintln!("skipping semantic corpus write verification because no C backend is available");
return;
}
let corpus_root = temp_semantic_corpus("write");
let c_receipt_path = corpus_root
.join("receipts")
.join("c-execution-2026-06-13.json");
let original_receipt = fs::read_to_string(&c_receipt_path).expect("read copied C receipt");
let drifted_receipt = original_receipt.replacen(
r#""expected_stdout": "4\n""#,
r#""expected_stdout": "999\n""#,
1,
);
assert_ne!(
original_receipt, drifted_receipt,
"copied C receipt should contain the scalar stdout fixture"
);
fs::write(&c_receipt_path, drifted_receipt).expect("write drifted copied C receipt");
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.arg("--write")
.output()
.expect("run buildc corpus verify --write");
assert!(
output.status.success(),
"corpus verify --write should repair copied receipt drift\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("c receipt: written"),
"corpus verify --write should report the C receipt write:\n{}",
stdout
);
let repaired_receipt = fs::read_to_string(&c_receipt_path).expect("read repaired C receipt");
assert!(
repaired_receipt.contains(r#""expected_stdout": "4\n""#),
"repaired C receipt should restore manifest stdout:\n{}",
repaired_receipt
);
assert!(
!repaired_receipt.contains(r#""expected_stdout": "999\n""#),
"repaired C receipt should remove drifted stdout:\n{}",
repaired_receipt
);
assert!(
repaired_receipt.contains("all 9 programs"),
"repaired C receipt should restamp notes with current manifest count:\n{}",
repaired_receipt
);
assert!(
!repaired_receipt.contains("all 8 programs")
&& !repaired_receipt.contains("same 8 programs"),
"repaired C receipt should not preserve stale 8-program notes:\n{}",
repaired_receipt
);
let _ = fs::remove_dir_all(&corpus_root);
}
#[test]
fn corpus_refresh_rust_receipt_runs_manifest_and_writes_current_metadata() {
if !rustc_available() {
eprintln!("skipping rust receipt refresh: rustc not available");
return;
}
let corpus_root = temp_semantic_corpus("rust_receipt_refresh");
let output = buildc()
.arg("corpus")
.arg("refresh-rust-receipt")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus refresh-rust-receipt");
assert!(
output.status.success(),
"rust receipt refresh should succeed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("rust receipt: written"),
"refresh command should report the write:\n{}",
stdout
);
let manifest_path = corpus_root.join("manifest.json");
let manifest: serde_json::Value =
serde_json::from_slice(&fs::read(&manifest_path).expect("read manifest"))
.expect("parse manifest");
let program_count = manifest["programs"]
.as_array()
.expect("programs array")
.len();
let receipt_path = corpus_root
.join("receipts")
.join("rust-execution-2026-06-13.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read rust receipt"))
.expect("parse rust receipt");
assert_eq!(receipt["backend"], "rust");
assert_eq!(receipt["result"]["passed"], program_count + 1);
assert_eq!(
receipt["programs"]
.as_array()
.expect("receipt programs")
.len(),
program_count
);
assert!(
receipt["programs"]
.as_array()
.expect("receipt programs")
.iter()
.any(|program| program["id"] == "integer_arithmetic_portable_lf"),
"refreshed rust receipt should include the arithmetic corpus program"
);
assert!(
receipt["verified_at"]
.as_str()
.is_some_and(|value| value.starts_with("unix-seconds:")),
"refreshed rust receipt should carry current runner metadata: {receipt:#?}"
);
assert_eq!(
receipt["verification_command"], receipt["command"],
"verification_command should name the exact refresh command"
);
let _ = fs::remove_dir_all(&corpus_root);
}
#[test]
fn corpus_verify_checks_manifest_receipts_and_c_execution() {
if !c_backend_ready() {
eprintln!("skipping semantic corpus verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.output()
.expect("run buildc corpus verify");
assert!(
output.status.success(),
"corpus verify should exit successfully\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
for expected in [
"Semantic Corpus Verify",
"manifest: 9 program(s)",
"c receipt: ok",
"rust receipt: ok",
"c execution: 9 passed",
] {
assert!(
stdout.contains(expected),
"corpus verify output should contain {expected:?}:\n{}",
stdout
);
}
}
#[test]
fn corpus_verify_checks_substrate_receipt() {
if !c_backend_ready() {
eprintln!("skipping substrate receipt verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with substrate receipt");
assert!(
output.status.success(),
"corpus verify should accept substrate receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("substrate receipt: ok"),
"corpus verify should report substrate receipt status:\n{}",
stdout
);
}
#[test]
fn corpus_verify_checks_mir_representation_receipt() {
if !c_backend_ready() {
eprintln!(
"skipping MIR representation receipt verification because no C backend is available"
);
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with MIR representation receipt");
assert!(
output.status.success(),
"corpus verify should accept MIR representation receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("mir representation receipt: ok"),
"corpus verify should report MIR representation receipt status:\n{}",
stdout
);
}
#[test]
fn corpus_verify_checks_memory_layout_receipt() {
if !c_backend_ready() {
eprintln!("skipping memory layout receipt verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with memory layout receipt");
assert!(
output.status.success(),
"corpus verify should accept memory layout receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("memory layout receipt: ok"),
"corpus verify should report memory layout receipt status:\n{}",
stdout
);
}
#[test]
fn corpus_verify_checks_symbol_graph_receipt() {
if !c_backend_ready() {
eprintln!("skipping symbol graph receipt verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with symbol graph receipt");
assert!(
output.status.success(),
"corpus verify should accept symbol graph receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("symbol graph receipt: ok"),
"corpus verify should report symbol graph receipt status:\n{}",
stdout
);
}
#[test]
fn corpus_verify_checks_module_graph_receipt() {
if !c_backend_ready() {
eprintln!("skipping module graph receipt verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with module graph receipt");
assert!(
output.status.success(),
"corpus verify should accept module graph receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("module graph receipt: ok"),
"corpus verify should report module graph receipt status:\n{}",
stdout
);
}
#[test]
fn corpus_verify_checks_lsp_dispatch_receipt() {
if !c_backend_ready() {
eprintln!("skipping LSP dispatch receipt verification because no C backend is available");
return;
}
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(repo_root().join("semantic-corpus"))
.output()
.expect("run buildc corpus verify with LSP dispatch receipt");
assert!(
output.status.success(),
"corpus verify should accept LSP dispatch receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("lsp dispatch receipt: ok"),
"corpus verify should report LSP dispatch receipt status:\n{}",
stdout
);
}
fn write_c_execution_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("c-execution-2026-06-13.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read c execution receipt"))
.expect("parse c execution receipt");
let rendered = serde_json::to_string_pretty(&transform(receipt))
.expect("render modified c execution receipt");
fs::write(&receipt_path, format!("{rendered}\n")).expect("write modified c execution receipt");
}
fn write_rust_execution_receipt_copy(
corpus_root: &Path,
transform: impl FnOnce(serde_json::Value) -> serde_json::Value,
) {
let receipt_path = corpus_root
.join("receipts")
.join("rust-execution-2026-06-13.json");
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read rust execution receipt"))
.expect("parse rust execution receipt");
let rendered = serde_json::to_string_pretty(&transform(receipt))
.expect("render modified rust execution receipt");
fs::write(&receipt_path, format!("{rendered}\n"))
.expect("write modified rust execution receipt");
}
#[test]
fn corpus_verify_rejects_manifest_stdout_tamper() {
let corpus_root = temp_semantic_corpus("manifest_stdout_tamper");
let manifest_path = corpus_root.join("manifest.json");
let mut manifest: serde_json::Value =
serde_json::from_slice(&fs::read(&manifest_path).expect("read manifest"))
.expect("parse manifest");
manifest["programs"][0]["expected_stdout"] =
serde_json::Value::String("tampered-stdout\n".to_string());
fs::write(
&manifest_path,
serde_json::to_string_pretty(&manifest).expect("render manifest"),
)
.expect("write tampered manifest");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["expected_stdout"] =
serde_json::Value::String("tampered-stdout\n".to_string());
receipt
});
let rust_receipt_path = corpus_root
.join("receipts")
.join("rust-execution-2026-06-13.json");
let mut rust_receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&rust_receipt_path).expect("read rust execution receipt"))
.expect("parse rust execution receipt");
rust_receipt["programs"][0]["expected_stdout"] =
serde_json::Value::String("tampered-stdout\n".to_string());
fs::write(
&rust_receipt_path,
format!(
"{}\n",
serde_json::to_string_pretty(&rust_receipt).expect("render rust execution receipt")
),
)
.expect("write tampered rust execution receipt");
assert_corpus_verify_rejects(&corpus_root, "semantic corpus stdout drift");
}
#[test]
fn corpus_verify_rejects_c_execution_pass_count_tamper() {
let corpus_root = temp_semantic_corpus("c_exec_pass_count");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["result"]["passed"] = serde_json::Value::from(3);
receipt
});
assert_corpus_verify_rejects(&corpus_root, "c receipt pass count mismatch");
}
#[test]
fn corpus_verify_rejects_c_execution_program_list_truncation() {
let corpus_root = temp_semantic_corpus("c_exec_program_truncation");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
let programs = receipt["programs"].as_array_mut().expect("programs array");
programs.pop();
receipt
});
assert_corpus_verify_rejects(&corpus_root, "c receipt program count mismatch");
}
#[test]
fn corpus_verify_rejects_capability_metadata_tamper() {
let corpus_root = temp_semantic_corpus("capability_metadata_tamper");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["observed_capabilities"]
.as_array_mut()
.expect("observed_capabilities array")
.push(serde_json::Value::String("Network".to_string()));
receipt
});
assert_corpus_verify_rejects(&corpus_root, "c receipt capability metadata drift");
}
#[test]
fn corpus_verify_rejects_capability_gate_stamp_tamper() {
let corpus_root = temp_semantic_corpus("capability_gate_tamper");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["capability_gate"] = serde_json::Value::String("skipped".to_string());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "c receipt capability metadata drift");
}
#[test]
fn corpus_verify_rejects_c_execution_mode_tamper() {
let corpus_root = temp_semantic_corpus("c_exec_mode_tamper");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["execution_mode"] = serde_json::Value::String("native".to_string());
receipt["command"] =
serde_json::Value::String("buildc run <semantic-corpus-program>".to_string());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "c receipt execution mode drift");
}
#[test]
fn corpus_verify_rejects_c_execution_missing_verification_metadata() {
let corpus_root = temp_semantic_corpus("c_exec_missing_verified_at");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt
.as_object_mut()
.expect("c receipt object")
.remove("verified_at");
receipt
.as_object_mut()
.expect("c receipt object")
.remove("verification_command");
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"c receipt verification metadata drift: missing verified_at",
);
}
#[test]
fn corpus_verify_rejects_c_execution_malformed_verified_at() {
let corpus_root = temp_semantic_corpus("c_exec_malformed_verified_at");
write_c_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["verified_at"] = serde_json::Value::String("unix-seconds:not-a-number".to_string());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"c receipt verification metadata drift: malformed verified_at",
);
}
#[test]
fn corpus_verify_rejects_rust_execution_missing_verification_metadata() {
let corpus_root = temp_semantic_corpus("rust_exec_missing_verified_at");
write_rust_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt
.as_object_mut()
.expect("rust receipt object")
.remove("verified_at");
receipt
.as_object_mut()
.expect("rust receipt object")
.remove("verification_command");
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"rust receipt verification metadata drift: missing verified_at",
);
}
#[test]
fn corpus_verify_rejects_rust_execution_malformed_verified_at() {
let corpus_root = temp_semantic_corpus("rust_exec_malformed_verified_at");
write_rust_execution_receipt_copy(&corpus_root, |mut receipt| {
receipt["verified_at"] = serde_json::Value::String("unix-seconds:not-a-number".to_string());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"rust receipt verification metadata drift: malformed verified_at",
);
}
#[test]
fn corpus_verify_rejects_rust_execution_command_tamper() {
let corpus_root = temp_semantic_corpus("rust_exec_command_tamper");
write_rust_execution_receipt_copy(&corpus_root, |mut receipt| {
let wrong = "hand edited rust receipt; not the refresh command";
receipt["command"] = serde_json::Value::String(wrong.to_string());
receipt["verification_command"] = serde_json::Value::String(wrong.to_string());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "rust receipt command drift");
}
#[test]
fn corpus_verify_rejects_per_program_surface_tamper() {
let corpus_root = temp_semantic_corpus("per_program_surface_tamper");
let manifest_path = corpus_root.join("manifest.json");
let mut manifest: serde_json::Value =
serde_json::from_slice(&fs::read(&manifest_path).expect("read manifest"))
.expect("parse manifest");
manifest["programs"][0]["surfaces"] = serde_json::Value::Array(Vec::new());
fs::write(
&manifest_path,
serde_json::to_string_pretty(&manifest).expect("render manifest"),
)
.expect("write tampered manifest");
assert_corpus_verify_rejects(&corpus_root, "corpus manifest surface drift for program");
}
#[test]
fn corpus_verify_rejects_module_graph_schema_drift() {
let corpus_root = temp_semantic_corpus("module_graph_schema");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] = serde_json::Value::String("buildlang-module-graph-receipt/v9".into());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "module graph receipt has unsupported schema");
}
#[test]
fn corpus_verify_rejects_module_graph_program_count_drift() {
let corpus_root = temp_semantic_corpus("module_graph_program_count");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["source_set"]["program_count"] = serde_json::Value::from(7);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph source_set.program_count mismatch",
);
}
#[test]
fn corpus_verify_rejects_module_graph_path_escape() {
let corpus_root = temp_semantic_corpus("module_graph_path_escape");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["path"] = serde_json::Value::String("../outside.bld".into());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph program.path must stay within corpus root",
);
}
#[test]
fn corpus_verify_rejects_module_graph_source_digest_drift() {
let corpus_root = temp_semantic_corpus("module_graph_source_digest");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["source_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph program scalar_branch source_digest mismatch",
);
}
#[test]
fn corpus_verify_rejects_module_graph_input_graph_digest_drift() {
let corpus_root = temp_semantic_corpus("module_graph_input_graph_digest");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["input_graph_digest"]["hex"] =
serde_json::Value::String("1".repeat(64));
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph program scalar_branch input_graph_digest mismatch",
);
}
#[test]
fn corpus_verify_rejects_module_graph_inputs_drift() {
let corpus_root = temp_semantic_corpus("module_graph_inputs");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["inputs"][0]["role"] = serde_json::Value::String("forged".into());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph program scalar_branch inputs drift",
);
}
#[test]
fn corpus_verify_rejects_module_graph_edges_drift() {
let corpus_root = temp_semantic_corpus("module_graph_edges");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["edges"][0]["kind"] =
serde_json::Value::String("forged_edge".into());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"module graph program scalar_branch edges drift",
);
}
#[test]
fn corpus_verify_rejects_module_graph_summary_drift() {
let corpus_root = temp_semantic_corpus("module_graph_summary");
write_module_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["summary"]["input_count"] = serde_json::Value::from(999);
receipt
});
assert_corpus_verify_rejects(&corpus_root, "module graph summary drift");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_schema_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_schema");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] = serde_json::Value::String("buildlang-lsp-dispatch-receipt/v9".into());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch receipt has unsupported schema");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_fixture_digest_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_digest");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["id"] == "document-symbol")
.expect("document-symbol fixture should exist");
fixture["result_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture document-symbol result_digest mismatch",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["id"] == "document-symbol")
.expect("document-symbol fixture should exist");
fixture["observed"]["document_symbols"] = serde_json::Value::from(0);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture document-symbol observed drift",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_semantic_tokens_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_semantic_tokens_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["id"] == "semantic-tokens")
.expect("semantic token fixture should exist");
fixture["observed"]["semantic_tokens"] = serde_json::Value::from(0);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture semantic-tokens observed drift",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_workspace_symbol_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_workspace_symbol_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["id"] == "workspace-symbol")
.expect("workspace symbol fixture should exist");
fixture["observed"]["workspace_symbols"] = serde_json::Value::from(0);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture workspace-symbol observed drift",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_code_action_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_code_action_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["method"] == "textDocument/codeAction")
.expect("codeAction fixture should exist");
fixture["observed"]["code_actions"] = serde_json::Value::from(1);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture code-action observed drift",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_rename_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_rename_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["method"] == "textDocument/rename")
.expect("rename fixture should exist");
fixture["observed"]["workspace_edits"] = serde_json::Value::from(0);
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch fixture rename observed drift");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_compiler_diagnostic_observed_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_compiler_diagnostic_observed");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
let fixture = receipt["fixtures"]
.as_array_mut()
.expect("fixtures should be an array")
.iter_mut()
.find(|fixture| fixture["id"] == "did-change-type-error")
.expect("type-error fixture should exist");
fixture["observed"]["compiler_diagnostics"] = serde_json::Value::from(0);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"lsp dispatch fixture did-change-type-error observed drift",
);
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_stale_compiler_diagnostics_gap() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_compiler_diagnostics_gap");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
receipt["summary"]["known_gaps"] = serde_json::json!([
"compiler type-checker diagnostics in LSP",
"full VS Code extension readiness"
]);
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch summary drift");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_summary_drift() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_summary");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
receipt["summary"]["known_gaps"]
.as_array_mut()
.expect("known_gaps should be an array")
.push(serde_json::Value::String("untracked gap".into()));
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch summary drift");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_stale_parser_metadata() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_parser_metadata");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
receipt["lsp_model"]["request_parser"] =
serde_json::Value::String("simplified string extraction".into());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch lsp_model drift");
}
#[test]
fn corpus_verify_rejects_lsp_dispatch_stale_json_rpc_gap() {
let corpus_root = temp_semantic_corpus("lsp_dispatch_json_rpc_gap");
write_lsp_dispatch_receipt_copy(&corpus_root, |mut receipt| {
receipt["summary"]["known_gaps"] = serde_json::json!([
"compiler type-checker diagnostics in LSP",
"full JSON-RPC deserialization",
"full VS Code extension readiness"
]);
receipt
});
assert_corpus_verify_rejects(&corpus_root, "lsp dispatch summary drift");
}
#[test]
fn corpus_verify_rejects_symbol_graph_schema_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_schema");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] = serde_json::Value::String("buildlang-symbol-graph-receipt/v9".into());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "symbol graph receipt has unsupported schema");
}
#[test]
fn corpus_verify_rejects_symbol_graph_program_count_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_program_count");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["source_set"]["program_count"] = serde_json::Value::from(7);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph source_set.program_count mismatch",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_path_escape() {
let corpus_root = temp_semantic_corpus("symbol_graph_path_escape");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["path"] = serde_json::Value::String("../outside.bld".into());
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph program.path must stay within corpus root",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_source_digest_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_source_digest");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["source_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph program scalar_branch source_digest mismatch",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_source_symbol_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_source_symbol");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["source_symbols"] = serde_json::json!([]);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph program scalar_branch source_symbols drift",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_mir_symbol_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_mir_symbol");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["mir_symbols"]["functions"] = serde_json::json!(["forged"]);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph program scalar_branch mir_symbols drift",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_edge_drift() {
let corpus_root = temp_semantic_corpus("symbol_graph_edge");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["edges"] = serde_json::json!([]);
receipt
});
assert_corpus_verify_rejects(
&corpus_root,
"symbol graph program scalar_branch edges drift",
);
}
#[test]
fn corpus_verify_rejects_symbol_graph_lsp_overclaim() {
let corpus_root = temp_semantic_corpus("symbol_graph_lsp_overclaim");
write_symbol_graph_receipt_copy(&corpus_root, |mut receipt| {
receipt["symbol_model"]["semantic_anchor"] =
serde_json::Value::String("LSP request dispatch verified".into());
receipt
});
assert_corpus_verify_rejects(&corpus_root, "symbol graph symbol_model drift");
}
#[test]
fn corpus_verify_rejects_memory_layout_schema_drift() {
let corpus_root = temp_semantic_corpus("memory_layout_schema");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] = serde_json::Value::String("buildlang-memory-layout-receipt/v9".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against bad memory layout schema");
let _ = fs::remove_dir_all(&corpus_root);
assert!(!output.status.success(), "schema drift should fail");
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("memory layout receipt has unsupported schema"),
"stderr should name memory layout schema drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_program_count_drift() {
let corpus_root = temp_semantic_corpus("memory_layout_program_count");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["source_set"]["program_count"] = serde_json::Value::from(7);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout program count drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(!output.status.success(), "program count drift should fail");
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("memory layout source_set.program_count mismatch"),
"stderr should name memory layout program count drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_path_escape() {
let corpus_root = temp_semantic_corpus("memory_layout_path_escape");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["path"] = serde_json::Value::String("../outside.bld".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(!output.status.success(), "path escape should fail");
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("memory layout program.path must stay within corpus root"),
"stderr should name memory layout path containment:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_source_digest_drift() {
let corpus_root = temp_semantic_corpus("memory_layout_source_digest");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["source_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout source digest drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(!output.status.success(), "source digest drift should fail");
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("memory layout program scalar_branch source_digest mismatch"),
"stderr should name memory layout source digest drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_observed_surface_drift() {
let corpus_root = temp_semantic_corpus("memory_layout_observed_surface");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
let programs = receipt["programs"]
.as_array_mut()
.expect("memory layout programs");
let references_program = programs
.iter_mut()
.find(|program| program["id"] == "references_mutation")
.expect("references_mutation memory layout row");
references_program["observed_memory_surfaces"]["references"] =
serde_json::Value::Bool(false);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout observed surface drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"observed memory surface drift should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("memory layout program references_mutation observed_memory_surfaces drift"),
"stderr should name memory layout observed surface drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_known_gap_drift() {
let corpus_root = temp_semantic_corpus("memory_layout_known_gap");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["summary"]["known_gaps"] = serde_json::json!(["none"]);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout known gap drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(!output.status.success(), "known gap drift should fail");
assert!(
String::from_utf8_lossy(&output.stderr).contains("memory layout summary drift"),
"stderr should name memory layout summary drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_memory_layout_byte_layout_overclaim() {
let corpus_root = temp_semantic_corpus("memory_layout_overclaim");
write_memory_layout_receipt_copy(&corpus_root, |mut receipt| {
receipt["memory_model"]["layout_claim"] =
serde_json::Value::String("byte-offset ABI layout verified".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against memory layout overclaim");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"byte layout overclaim should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("memory layout memory_model drift"),
"stderr should name memory layout overclaim:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_receipt_schema_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_schema");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] =
serde_json::Value::String("buildlang-mir-representation-receipt/v9".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against bad MIR representation schema");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation schema drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation receipt has unsupported schema"),
"stderr should name MIR representation schema drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_program_count_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_program_count");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["source_set"]["program_count"] = serde_json::Value::from(7);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation program count drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation program count drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation source_set.program_count mismatch"),
"stderr should name MIR representation program count drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_path_escape() {
let corpus_root = temp_semantic_corpus("mir_repr_path_escape");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["path"] = serde_json::Value::String("../outside.bld".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation path escape"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name MIR representation path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_path_escape_absolute() {
let corpus_root = temp_semantic_corpus("mir_repr_path_escape_absolute");
let absolute_path = std::env::temp_dir().join("outside.bld");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["path"] =
serde_json::Value::String(absolute_path.to_string_lossy().into_owned());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation absolute path");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation absolute path"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name MIR representation path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_source_digest_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_source_digest");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["source_digest"]["hex"] = serde_json::Value::String("0".repeat(64));
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation source digest drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation source digest drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation program scalar_branch source_digest mismatch"),
"stderr should name MIR representation source digest drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_operation_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_operation_drift");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["operations"]["rvalues"] = serde_json::json!(["ForgedRValue"]);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation operation drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation operation drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation program scalar_branch operations.rvalues drift"),
"stderr should name MIR representation operation drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_input_graph_digest_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_input_graph_digest");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["input_graph_digest"]["hex"] =
serde_json::Value::String("f".repeat(64));
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation input graph digest drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation input graph digest drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation program scalar_branch input_graph_digest mismatch"),
"stderr should name MIR representation input graph digest drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_mir_representation_mir_digest_drift() {
let corpus_root = temp_semantic_corpus("mir_repr_mir_digest");
write_mir_representation_receipt_copy(&corpus_root, |mut receipt| {
receipt["programs"][0]["mir_digest"]["hex"] = serde_json::Value::String("e".repeat(64));
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against MIR representation MIR digest drift");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject MIR representation MIR digest drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("mir representation program scalar_branch mir_digest mismatch"),
"stderr should name MIR representation MIR digest drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_receipt_schema_drift() {
let corpus_root = temp_semantic_corpus("substrate_schema");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["schema"] = serde_json::Value::String("buildlang-substrate-receipt/v9".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against bad substrate schema");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject bad substrate schema"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate receipt has unsupported schema"),
"stderr should name schema drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_program_count_drift() {
let corpus_root = temp_semantic_corpus("substrate_program_count");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["source_set"]["program_count"] = serde_json::Value::from(7);
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against bad substrate program count");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate program count drift"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate source_set.program_count mismatch"),
"stderr should name program-count drift:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_production_substrate_backend_without_receipt() {
let corpus_root = temp_semantic_corpus("substrate_missing_receipt");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
if let Some(c) = receipt["execution_surface"]["c"].as_object_mut() {
c.remove("receipt");
}
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against missing production receipt");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject production backend without receipt"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate execution_surface.c is production-anchor but receipt is missing"),
"stderr should name missing production receipt:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_rust_subset_without_receipt() {
let corpus_root = temp_semantic_corpus("substrate_rust_subset_missing_receipt");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
if let Some(rust) = receipt["execution_surface"]["rust"].as_object_mut() {
rust.remove("receipt");
}
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against missing rust subset receipt");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject rust subset without receipt evidence"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains(
"substrate execution_surface.rust experimental-subset requires receipt evidence"
),
"stderr should name missing rust subset receipt:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_missing_required_spirv_target() {
let corpus_root = temp_semantic_corpus("substrate_missing_spirv");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
if let Some(execution_surface) = receipt["execution_surface"].as_object_mut() {
execution_surface.remove("spirv");
}
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against missing spirv target");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject missing required spirv target"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate execution_surface missing required target spirv"),
"stderr should name missing required spirv target:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["execution_surface"]["c"]["receipt"] =
serde_json::Value::String("../outside.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate receipt path escape"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_representation_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_repr_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["representation_surface"]["representation_receipt"] =
serde_json::Value::String("../outside.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate representation receipt path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate representation receipt path escape"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate representation receipt path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_memory_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_memory_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["memory_surface"]["memory_receipt"] =
serde_json::Value::String("../memory-layout-2026-06-18.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate memory receipt path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate memory receipt path escape should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate memory_surface.memory_receipt must stay within corpus root"),
"stderr should name substrate memory receipt path containment:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_module_receipt_missing_path() {
let corpus_root = temp_semantic_corpus("substrate_module_path_missing");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["module_surface"]["module_receipt"] =
serde_json::Value::String("receipts/missing-module-graph.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate module receipt missing path");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate module receipt missing path should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate module_surface.module_receipt path not found"),
"stderr should name substrate module receipt missing path:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_module_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_module_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["module_surface"]["module_receipt"] =
serde_json::Value::String("../module-graph-2026-06-18.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate module receipt path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate module receipt path escape should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate module_surface.module_receipt must stay within corpus root"),
"stderr should name substrate module receipt path containment:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_symbol_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_symbol_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["symbol_surface"]["symbol_receipt"] =
serde_json::Value::String("../symbol.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate symbol receipt path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate symbol receipt path escape should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate symbol_surface.symbol_receipt must stay within corpus root"),
"stderr should name substrate symbol receipt path containment:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_lsp_receipt_missing_path() {
let corpus_root = temp_semantic_corpus("substrate_lsp_path_missing");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["lsp_surface"]["lsp_receipt"] =
serde_json::Value::String("receipts/missing-lsp-dispatch.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate LSP receipt missing path");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate LSP receipt missing path should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate lsp_surface.lsp_receipt path not found"),
"stderr should name substrate LSP receipt missing path:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_lsp_receipt_path_escape() {
let corpus_root = temp_semantic_corpus("substrate_lsp_path_escape");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["lsp_surface"]["lsp_receipt"] =
serde_json::Value::String("../lsp-dispatch-2026-06-18.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate LSP receipt path escape");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"substrate LSP receipt path escape should fail"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate lsp_surface.lsp_receipt must stay within corpus root"),
"stderr should name substrate LSP receipt path containment:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_representation_receipt_root_qualified_path() {
let corpus_root = temp_semantic_corpus("substrate_repr_path_root");
let rooted = if cfg!(windows) {
"\\receipts\\mir-representation-2026-06-18.json"
} else {
"/receipts/mir-representation-2026-06-18.json"
};
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["representation_surface"]["representation_receipt"] =
serde_json::Value::String(rooted.into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect(
"run buildc corpus verify against substrate representation receipt root-qualified path",
);
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate representation receipt root-qualified path"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate representation receipt path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_representation_receipt_absolute_path() {
let corpus_root = temp_semantic_corpus("substrate_repr_path_absolute");
let absolute_path = std::env::temp_dir().join("outside.json");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["representation_surface"]["representation_receipt"] =
serde_json::Value::String(absolute_path.to_string_lossy().into_owned());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against substrate representation receipt absolute path");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate representation receipt absolute path"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate representation receipt path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_representation_receipt_windows_drive_path() {
let corpus_root = temp_semantic_corpus("substrate_repr_windows_drive_path");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["representation_surface"]["representation_receipt"] =
serde_json::Value::String("C:\\outside.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect(
"run buildc corpus verify against substrate representation receipt windows drive path",
);
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate representation receipt windows drive path"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate representation receipt path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_substrate_representation_receipt_windows_drive_relative_path() {
let corpus_root = temp_semantic_corpus("substrate_repr_windows_drive_relative_path");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["representation_surface"]["representation_receipt"] =
serde_json::Value::String("C:outside.json".into());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect(
"run buildc corpus verify against substrate representation receipt windows drive-relative path",
);
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject substrate representation receipt windows drive-relative path"
);
assert!(
String::from_utf8_lossy(&output.stderr).contains("must stay within corpus root"),
"stderr should name substrate representation receipt path containment failure:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn corpus_verify_rejects_empty_substrate_evidence_commands() {
let corpus_root = temp_semantic_corpus("substrate_empty_commands");
write_substrate_receipt_copy(&corpus_root, |mut receipt| {
receipt["evidence_surface"]["commands"] = serde_json::Value::Array(Vec::new());
receipt
});
let output = buildc()
.arg("corpus")
.arg("verify")
.arg("--root")
.arg(&corpus_root)
.output()
.expect("run buildc corpus verify against empty substrate commands");
let _ = fs::remove_dir_all(&corpus_root);
assert!(
!output.status.success(),
"corpus verify should reject empty evidence commands"
);
assert!(
String::from_utf8_lossy(&output.stderr)
.contains("substrate evidence_surface.commands must not be empty"),
"stderr should name empty evidence commands:\n{}",
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn quickstart_examples_are_typechecked() {
for name in [
"hello.bld",
"ledger.bld",
"effects_greeting.bld",
"vignette_shader.bld",
] {
let path = quickstart_example(name);
let output = buildc()
.arg("check")
.arg(&path)
.output()
.unwrap_or_else(|err| panic!("run buildc check for {name}: {err}"));
assert!(
output.status.success(),
"quickstart example {name} should typecheck\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
}
#[test]
fn quickstart_cpu_examples_run_when_c_backend_is_ready() {
if !c_backend_ready() {
eprintln!("skipping quickstart run smoke test because no C backend is available");
return;
}
for (name, expected_stdout) in [
("hello.bld", "Hello from BuildLang!\n"),
("ledger.bld", "balance: 115\n"),
("effects_greeting.bld", "Hello, teammate!\n"),
] {
let output = buildc()
.arg("run")
.arg(quickstart_example(name))
.output()
.unwrap_or_else(|err| panic!("run buildc run for {name}: {err}"));
assert!(
output.status.success(),
"quickstart example {name} should run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert_eq!(stdout, expected_stdout);
}
}
#[test]
fn quickstart_shader_example_compiles_to_hlsl() {
let out_dir = std::env::temp_dir().join(format!(
"buildlang_quickstart_shader_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&out_dir);
fs::create_dir_all(&out_dir).expect("create quickstart shader temp dir");
let output_path = out_dir.join("vignette_shader.hlsl");
let output = buildc()
.arg(quickstart_example("vignette_shader.bld"))
.arg("--target")
.arg("hlsl")
.arg("-o")
.arg(&output_path)
.output()
.expect("compile quickstart shader to HLSL");
assert!(
output.status.success(),
"quickstart shader should compile to HLSL\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let hlsl = fs::read_to_string(&output_path).expect("read generated HLSL");
assert!(
hlsl.contains("PS_Vignette"),
"generated HLSL should contain the fragment entry point:\n{}",
hlsl
);
let _ = fs::remove_dir_all(&out_dir);
}
#[derive(serde::Deserialize)]
struct PreservationCorpusManifest {
programs: Vec<PreservationCorpusProgram>,
}
#[derive(serde::Deserialize)]
struct PreservationCorpusProgram {
id: String,
path: String,
rust_execution_test: String,
}
fn semantic_corpus_root() -> PathBuf {
repo_root().join("semantic-corpus")
}
fn load_preservation_corpus() -> PreservationCorpusManifest {
let manifest_path = semantic_corpus_root().join("manifest.json");
let manifest = fs::read_to_string(&manifest_path)
.unwrap_or_else(|err| panic!("read {}: {}", manifest_path.display(), err));
serde_json::from_str(&manifest)
.unwrap_or_else(|err| panic!("parse {}: {}", manifest_path.display(), err))
}
fn rustc_available() -> bool {
let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
Command::new(rustc)
.arg("--version")
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map(|status| status.success())
.unwrap_or(false)
}
fn lower_source_to_rust(source: &str) -> String {
use buildlang::lexer::{Lexer, SourceFile};
use buildlang::parser::Parser;
use buildlang::types::{TypeChecker, TypeContext};
use buildlang::{CodeGenerator, Target};
let source_file = SourceFile::new("transpile_preservation_test.bld", source);
let mut lexer = Lexer::new(&source_file);
let tokens = lexer.tokenize().expect("lexing should succeed");
let mut parser = Parser::new(&source_file, tokens);
let ast = parser.parse().expect("parsing should succeed");
assert!(
parser.errors().is_empty(),
"unexpected parser errors: {:?}",
parser.errors()
);
let mut ctx = TypeContext::new();
let mut checker = TypeChecker::new(&mut ctx);
checker.set_source_file(&source_file);
checker.check_module(&ast);
assert!(
!checker.has_errors(),
"unexpected type errors: {:?}",
checker.errors()
);
let mut codegen = CodeGenerator::with_source(&ctx, Target::Rust, source_file.source().into());
codegen
.generate(&ast)
.expect("rust codegen should succeed")
.as_string()
.expect("generated Rust should be UTF-8")
}
struct RunResult {
stdout: String,
exit_code: Option<i32>,
}
fn rustc_compile_and_run(name: &str, rust_source: &str) -> RunResult {
let rustc = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
let dir = std::env::temp_dir().join(format!(
"buildlang_transpile_preservation_{}_{}",
name,
std::process::id()
));
fs::create_dir_all(&dir).expect("create temp dir");
let source_path = dir.join("generated.rs");
let exe_path = dir.join(format!("generated{}", std::env::consts::EXE_SUFFIX));
fs::write(&source_path, rust_source).expect("write generated Rust");
let compile = Command::new(&rustc)
.arg(&source_path)
.arg("-o")
.arg(&exe_path)
.output()
.expect("invoke rustc");
assert!(
compile.status.success(),
"rustc failed for {name}\nstdout:\n{}\nstderr:\n{}\nsource:\n{}",
String::from_utf8_lossy(&compile.stdout),
String::from_utf8_lossy(&compile.stderr),
rust_source
);
let run = Command::new(&exe_path)
.output()
.expect("run generated Rust executable");
let stdout = String::from_utf8_lossy(&run.stdout).replace("\r\n", "\n");
let result = RunResult {
stdout,
exit_code: run.status.code(),
};
let _ = fs::remove_dir_all(&dir);
result
}
#[test]
fn generated_rust_runs_for_integer_arithmetic_portable_lf() {
if !rustc_available() {
eprintln!("skipping arithmetic corpus Rust run: rustc not available");
return;
}
let path = semantic_corpus_root()
.join("programs")
.join("integer_arithmetic_portable_lf.bld");
let source = fs::read_to_string(&path)
.unwrap_or_else(|err| panic!("read arithmetic corpus program {}: {}", path.display(), err));
let rust_source = lower_source_to_rust(&source);
let result = rustc_compile_and_run("integer_arithmetic_portable_lf", &rust_source);
assert_eq!(
result.stdout, "arith 9\nwide 1000\nmix 7\n",
"generated Rust must preserve the arithmetic corpus stdout"
);
}
fn c_backend_run(program_path: &Path) -> RunResult {
let output = buildc()
.arg("run")
.arg(program_path)
.output()
.unwrap_or_else(|err| panic!("run buildc run for {}: {}", program_path.display(), err));
assert!(
output.status.success(),
"C backend run failed for {}\nstdout:\n{}\nstderr:\n{}",
program_path.display(),
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
RunResult {
stdout: String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n"),
exit_code: output.status.code(),
}
}
fn c_backend_run_capture(program_path: &Path) -> (String, String, Option<i32>) {
let output = buildc()
.arg("run")
.arg(program_path)
.output()
.unwrap_or_else(|err| panic!("run buildc run for {}: {}", program_path.display(), err));
(
String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n"),
String::from_utf8_lossy(&output.stderr).replace("\r\n", "\n"),
output.status.code(),
)
}
#[test]
fn semantic_corpus_integer_arithmetic_portable_lf_runs_on_c_backend() {
if !c_backend_ready() {
eprintln!("skipping semantic corpus arithmetic run: no C backend available");
return;
}
let path = semantic_corpus_root()
.join("programs")
.join("integer_arithmetic_portable_lf.bld");
let output = buildc()
.arg("run")
.arg(&path)
.arg("--stdio-mode")
.arg("portable-lf")
.output()
.expect("run arithmetic corpus program with portable LF");
assert!(
output.status.success(),
"arithmetic corpus program should run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(
!output.stdout.contains(&b'\r'),
"portable-LF corpus stdout must not contain CR bytes: {:?}",
output.stdout
);
assert_eq!(
output.stdout, b"arith 9\nwide 1000\nmix 7\n",
"arithmetic corpus stdout is the executable contract"
);
}
#[test]
fn safe_math_checked_and_saturating_arithmetic_runs() {
if !c_backend_ready() {
eprintln!("skipping safe_math e2e: no C backend available (buildc doctor)");
return;
}
let path =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/finance/safe_math.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout,
"add ok 102599\nadd overflow 1\nsub ok 60\nsat_add 9223372036854775807\nsat_sub 60\n",
"checked/saturating arithmetic must detect overflow and clamp, not wrap"
);
}
#[test]
fn large_unsuffixed_int_literal_not_truncated_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping large-literal e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let big = 9223372036854775000;\n\
let diff = big - 100000;\n\
println(\"{}\", big);\n\
println(\"{}\", diff);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_large_literal_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("large_literal.bld");
std::fs::write(&path, src).expect("write large_literal.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "9223372036854775000\n9223372036854675000\n",
"a 64-bit literal must not be truncated to 32 bits"
);
}
#[test]
fn compile_time_integer_literal_and_fold_overflow_are_diagnostics() {
let dir = std::env::temp_dir().join(format!(
"buildlang_integer_overflow_diagnostics_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create overflow diagnostics dir");
let cases: [(&str, &str, &str); 5] = [
(
"too_large_u128_literal",
"fn main() { let x = 340282366920938463463374607431768211456u128; }\n",
"integer literal is too large",
),
(
"u8_suffix_out_of_range",
"fn main() { let x = 256u8; }\n",
"integer literal `256u8` is out of range for type `u8`",
),
(
"i8_add_fold_overflow",
"fn main() { let x: i8 = 127i8 + 1i8; }\n",
"integer overflow in `+` for type `i8`",
),
(
"u8_sub_fold_overflow",
"fn main() { let x: u8 = 0u8 - 1u8; }\n",
"integer overflow in `-` for type `u8`",
),
(
"i8_neg_fold_overflow",
"fn main() { let x: i8 = -(0i8 - 127i8 - 1i8); }\n",
"integer overflow in unary `-` for type `i8`",
),
];
for (name, src, needle) in cases {
let file = dir.join(format!("{name}.bld"));
fs::write(&file, src).expect("write overflow diagnostic fixture");
let (status, stdout, stderr) = check_within(&file, 30);
assert!(
!status.success(),
"overflow diagnostic case `{name}` must fail buildc check\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains(needle),
"overflow diagnostic case `{name}` must report `{needle}`\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
let lower_stderr = stderr.to_lowercase();
assert!(
!lower_stderr.contains("internal") && !lower_stderr.contains("panic"),
"overflow diagnostic case `{name}` must be a user diagnostic, not a compiler panic\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn function_i64_argument_signed_min_spelling_is_the_i64_minimum() {
let dir = std::env::temp_dir().join(format!(
"buildlang_i64_arg_signed_min_literal_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create signed-min literal diagnostics dir");
let file = dir.join("i64_arg_signed_min.bld");
fs::write(
&file,
"fn takes_i64(x: i64) -> i64 { x }\n\
fn main() { let _ = takes_i64(-9223372036854775808); }\n",
)
.expect("write signed-min literal fixture");
let (status, stdout, stderr) = check_within(&file, 30);
assert!(
status.success(),
"the i64 minimum written as a negated literal must pass the check\n\
stdout:\n{stdout}\nstderr:\n{stderr}"
);
let mir_path = dir.join("i64_arg_signed_min.mir.json");
let mir = buildc()
.arg("mir")
.arg("emit")
.arg(&file)
.arg("-o")
.arg(&mir_path)
.output()
.expect("run buildc mir emit");
assert!(
mir.status.success(),
"stderr:\n{}",
String::from_utf8_lossy(&mir.stderr)
);
let text = fs::read_to_string(&mir_path).expect("read MIR");
let json: serde_json::Value = serde_json::from_str(&text).expect("MIR is JSON");
let compact = serde_json::to_string(&json).expect("MIR prints");
assert!(
compact.contains(r#"{"Const":{"Int":[-9223372036854775808,{"Int":["I64",true]}]}}"#),
"the argument must be an i64 constant in the MIR"
);
assert!(
!compact.contains("I128"),
"no i128 value may appear in the MIR of this program"
);
let below = dir.join("i64_arg_below_min.bld");
fs::write(
&below,
"fn takes_i64(x: i64) -> i64 { x }\n\
fn main() { let _ = takes_i64(-9223372036854775809); }\n",
)
.expect("write below-min literal fixture");
let (status, stdout, stderr) = check_within(&below, 30);
assert!(
!status.success(),
"one below the i64 minimum must be rejected\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains("integer literal `9223372036854775809` is out of range for type `i64`"),
"stdout:\n{stdout}\nstderr:\n{stderr}"
);
let mir = buildc()
.arg("mir")
.arg("emit")
.arg(&below)
.arg("-o")
.arg(dir.join("i64_arg_below_min.mir.json"))
.output()
.expect("run buildc mir emit");
assert!(
!mir.status.success(),
"an out-of-range i64 argument literal must not reach MIR\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&mir.stdout),
String::from_utf8_lossy(&mir.stderr)
);
}
#[test]
fn mut_to_shared_argument_coercion_survives_integer_context_checks() {
let dir = std::env::temp_dir().join(format!(
"buildlang_mut_to_shared_arg_coercion_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create mut-to-shared argument dir");
let cases = [
(
"direct",
"fn observe(x: &i64) { }\n\
fn main() { let mut v: i64 = 7; observe(&mut v); }\n",
),
(
"impl_method",
"struct Box;\n\
impl Box { fn observe(self, x: &i64) { } }\n\
fn main() { let b = Box; let mut v: i64 = 7; b.observe(&mut v); }\n",
),
(
"overload",
"fn observe(x: &i64) { }\n\
fn observe(x: str) { }\n\
fn main() { let mut v: i64 = 7; observe(&mut v); }\n",
),
];
for (name, src) in cases {
let file = dir.join(format!("{name}.bld"));
fs::write(&file, src).expect("write mut-to-shared argument fixture");
let (status, stdout, stderr) = check_within(&file, 30);
assert!(
status.success(),
"&mut T argument must still coerce to &T parameter for {name}\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
fn explicit_integer_arithmetic_source() -> &'static str {
r#"fn u8_max() -> u8 { 255u8 }
fn u8_one() -> u8 { 1u8 }
fn u8_two() -> u8 { 2u8 }
fn u8_two_hundred() -> u8 { 200u8 }
fn i8_max() -> i8 { 127i8 }
fn i8_min() -> i8 { 0i8 - 127i8 - 1i8 }
fn i8_sixty_four() -> i8 { 64i8 }
fn i16_max() -> i16 { 32767i16 }
fn u16_max() -> u16 { 65535u16 }
fn i32_big() -> i32 { 46341 }
fn u32_maxish() -> u32 { 65535u32 }
fn i64_max() -> i64 { 9223372036854775807i64 }
fn u64_max() -> u64 { 18446744073709551615u64 }
fn u64_almost() -> u64 { 18446744073709551614u64 }
fn i128_max() -> i128 { 170141183460469231731687303715884105727i128 }
fn u128_max() -> u128 { 340282366920938463463374607431768211455u128 }
fn isize_max() -> isize { 9223372036854775807isize }
fn usize_max() -> usize { 18446744073709551615usize }
fn i16_min() -> i16 { 0i16 - 32767i16 - 1i16 }
fn i16_half_max() -> i16 { 16383i16 }
fn u16_half_max() -> u16 { 32767u16 }
fn i32_max() -> i32 { 2147483647i32 }
fn i32_min() -> i32 { 0i32 - 2147483647i32 - 1i32 }
fn i32_half_max() -> i32 { 1073741823i32 }
fn u32_half_max() -> u32 { 2147483647u32 }
fn i64_min() -> i64 { 0i64 - 9223372036854775807i64 - 1i64 }
fn i64_half_max() -> i64 { 4611686018427387903i64 }
fn u64_half_max() -> u64 { 9223372036854775807u64 }
fn i128_min() -> i128 { 0i128 - 170141183460469231731687303715884105727i128 - 1i128 }
fn i128_half_max() -> i128 { 85070591730234615865843651857942052863i128 }
fn u128_half_max() -> u128 { 170141183460469231731687303715884105727u128 }
fn isize_min() -> isize { 0isize - 9223372036854775807isize - 1isize }
fn isize_half_max() -> isize { 4611686018427387903isize }
fn usize_half_max() -> usize { 9223372036854775807usize }
fn checked_u64_return() -> Option<u64> { u64_almost().checked_add(1u64) }
fn id_u64_option(x: Option<u64>) -> Option<u64> { x }
fn main() ~ Console {
println("u8 wrap {} {} {}", u8_max().wrapping_add(u8_one()), 0u8.wrapping_sub(u8_one()), u8_two_hundred().wrapping_mul(u8_two()));
println("i8 wrap {} {} {}", i8_max().wrapping_add(1i8), i8_min().wrapping_sub(1i8), i8_sixty_four().wrapping_mul(2i8));
println("u16 sat {} {}", u16_max().saturating_add(1u16), 0u16.saturating_sub(1u16));
println("i16 sat {} {}", i16_max().saturating_add(1i16), (0i16 - 32767i16 - 1i16).saturating_sub(1i16));
println("i32 satmul {}", i32_big().saturating_mul(i32_big()));
println("u32 satmul {}", u32_maxish().saturating_mul(u32_maxish()));
println("i64 sat {}", i64_max().saturating_add(1i64));
println("u64 wrap {}", u64_max().wrapping_add(1u64));
println("i128 sat {}", i128_max().saturating_add(1i128));
println("u128 wrapsat {} {}", u128_max().wrapping_add(1u128), u128_max().saturating_mul(2u128));
println("isize sat {}", isize_max().saturating_add(1isize));
println("usize wrap {}", usize_max().wrapping_add(1usize));
match u64_almost().checked_add(1u64) { Some(v) => println("u64 some {}", v), None => println("u64 none {}", 0) }
match u64_max().checked_add(1u64) { Some(v) => println("u64 overflow {}", v), None => println("u64 none {}", 1) }
match i128_max().checked_sub(1i128) { Some(v) => println("i128 some {}", v), None => println("i128 none {}", 0) }
match i128_max().checked_add(1i128) { Some(v) => println("i128 none {}", v), None => println("i128 none {}", 1) }
match u128_max().checked_sub(1u128) { Some(v) => println("u128 some {}", v), None => println("u128 none {}", 0) }
match u128_max().checked_mul(2u128) { Some(v) => println("u128 overflow {}", v), None => println("u128 none {}", 1) }
match 126i8.checked_add(1i8) { Some(v) => println("chk i8 add some {}", v), None => println("chk i8 add some none {}", 0) }
match i8_max().checked_add(1i8) { Some(v) => println("chk i8 add none value {}", v), None => println("chk i8 add none {}", 1) }
match i8_min().checked_add(1i8).unwrap_or(0i8).checked_sub(1i8) { Some(v) => println("chk i8 sub some {}", v), None => println("chk i8 sub some none {}", 0) }
match i8_min().checked_sub(1i8) { Some(v) => println("chk i8 sub none value {}", v), None => println("chk i8 sub none {}", 1) }
match 63i8.checked_mul(2i8) { Some(v) => println("chk i8 mul some {}", v), None => println("chk i8 mul some none {}", 0) }
match i8_max().checked_mul(2i8) { Some(v) => println("chk i8 mul none value {}", v), None => println("chk i8 mul none {}", 1) }
match 254u8.checked_add(1u8) { Some(v) => println("chk u8 add some {}", v), None => println("chk u8 add some none {}", 0) }
match u8_max().checked_add(1u8) { Some(v) => println("chk u8 add none value {}", v), None => println("chk u8 add none {}", 1) }
match 1u8.checked_sub(1u8) { Some(v) => println("chk u8 sub some {}", v), None => println("chk u8 sub some none {}", 0) }
match 0u8.checked_sub(1u8) { Some(v) => println("chk u8 sub none value {}", v), None => println("chk u8 sub none {}", 1) }
match 127u8.checked_mul(2u8) { Some(v) => println("chk u8 mul some {}", v), None => println("chk u8 mul some none {}", 0) }
match u8_max().checked_mul(2u8) { Some(v) => println("chk u8 mul none value {}", v), None => println("chk u8 mul none {}", 1) }
match 32766i16.checked_add(1i16) { Some(v) => println("chk i16 add some {}", v), None => println("chk i16 add some none {}", 0) }
match i16_max().checked_add(1i16) { Some(v) => println("chk i16 add none value {}", v), None => println("chk i16 add none {}", 1) }
match i16_min().checked_add(1i16).unwrap_or(0i16).checked_sub(1i16) { Some(v) => println("chk i16 sub some {}", v), None => println("chk i16 sub some none {}", 0) }
match i16_min().checked_sub(1i16) { Some(v) => println("chk i16 sub none value {}", v), None => println("chk i16 sub none {}", 1) }
match i16_half_max().checked_mul(2i16) { Some(v) => println("chk i16 mul some {}", v), None => println("chk i16 mul some none {}", 0) }
match i16_max().checked_mul(2i16) { Some(v) => println("chk i16 mul none value {}", v), None => println("chk i16 mul none {}", 1) }
match 65534u16.checked_add(1u16) { Some(v) => println("chk u16 add some {}", v), None => println("chk u16 add some none {}", 0) }
match u16_max().checked_add(1u16) { Some(v) => println("chk u16 add none value {}", v), None => println("chk u16 add none {}", 1) }
match 1u16.checked_sub(1u16) { Some(v) => println("chk u16 sub some {}", v), None => println("chk u16 sub some none {}", 0) }
match 0u16.checked_sub(1u16) { Some(v) => println("chk u16 sub none value {}", v), None => println("chk u16 sub none {}", 1) }
match u16_half_max().checked_mul(2u16) { Some(v) => println("chk u16 mul some {}", v), None => println("chk u16 mul some none {}", 0) }
match u16_max().checked_mul(2u16) { Some(v) => println("chk u16 mul none value {}", v), None => println("chk u16 mul none {}", 1) }
match 2147483646i32.checked_add(1i32) { Some(v) => println("chk i32 add some {}", v), None => println("chk i32 add some none {}", 0) }
match i32_max().checked_add(1i32) { Some(v) => println("chk i32 add none value {}", v), None => println("chk i32 add none {}", 1) }
match i32_min().checked_add(1i32).unwrap_or(0i32).checked_sub(1i32) { Some(v) => println("chk i32 sub some {}", v), None => println("chk i32 sub some none {}", 0) }
match i32_min().checked_sub(1i32) { Some(v) => println("chk i32 sub none value {}", v), None => println("chk i32 sub none {}", 1) }
match i32_half_max().checked_mul(2i32) { Some(v) => println("chk i32 mul some {}", v), None => println("chk i32 mul some none {}", 0) }
match i32_max().checked_mul(2i32) { Some(v) => println("chk i32 mul none value {}", v), None => println("chk i32 mul none {}", 1) }
match 4294967294u32.checked_add(1u32) { Some(v) => println("chk u32 add some {}", v), None => println("chk u32 add some none {}", 0) }
match 4294967295u32.checked_add(1u32) { Some(v) => println("chk u32 add none value {}", v), None => println("chk u32 add none {}", 1) }
match 1u32.checked_sub(1u32) { Some(v) => println("chk u32 sub some {}", v), None => println("chk u32 sub some none {}", 0) }
match 0u32.checked_sub(1u32) { Some(v) => println("chk u32 sub none value {}", v), None => println("chk u32 sub none {}", 1) }
match u32_half_max().checked_mul(2u32) { Some(v) => println("chk u32 mul some {}", v), None => println("chk u32 mul some none {}", 0) }
match 4294967295u32.checked_mul(2u32) { Some(v) => println("chk u32 mul none value {}", v), None => println("chk u32 mul none {}", 1) }
match 9223372036854775806i64.checked_add(1i64) { Some(v) => println("chk i64 add some {}", v), None => println("chk i64 add some none {}", 0) }
match i64_max().checked_add(1i64) { Some(v) => println("chk i64 add none value {}", v), None => println("chk i64 add none {}", 1) }
match i64_min().checked_add(1i64).unwrap_or(0i64).checked_sub(1i64) { Some(v) => println("chk i64 sub some {}", v), None => println("chk i64 sub some none {}", 0) }
match i64_min().checked_sub(1i64) { Some(v) => println("chk i64 sub none value {}", v), None => println("chk i64 sub none {}", 1) }
match i64_half_max().checked_mul(2i64) { Some(v) => println("chk i64 mul some {}", v), None => println("chk i64 mul some none {}", 0) }
match i64_max().checked_mul(2i64) { Some(v) => println("chk i64 mul none value {}", v), None => println("chk i64 mul none {}", 1) }
match u64_almost().checked_add(1u64) { Some(v) => println("chk u64 add some {}", v), None => println("chk u64 add some none {}", 0) }
match u64_max().checked_add(1u64) { Some(v) => println("chk u64 add none value {}", v), None => println("chk u64 add none {}", 1) }
match 1u64.checked_sub(1u64) { Some(v) => println("chk u64 sub some {}", v), None => println("chk u64 sub some none {}", 0) }
match 0u64.checked_sub(1u64) { Some(v) => println("chk u64 sub none value {}", v), None => println("chk u64 sub none {}", 1) }
match u64_half_max().checked_mul(2u64) { Some(v) => println("chk u64 mul some {}", v), None => println("chk u64 mul some none {}", 0) }
match u64_max().checked_mul(2u64) { Some(v) => println("chk u64 mul none value {}", v), None => println("chk u64 mul none {}", 1) }
match 170141183460469231731687303715884105726i128.checked_add(1i128) { Some(v) => println("chk i128 add some {}", v), None => println("chk i128 add some none {}", 0) }
match i128_max().checked_add(1i128) { Some(v) => println("chk i128 add none value {}", v), None => println("chk i128 add none {}", 1) }
match i128_min().checked_add(1i128).unwrap_or(0i128).checked_sub(1i128) { Some(v) => println("chk i128 sub some {}", v), None => println("chk i128 sub some none {}", 0) }
match i128_min().checked_sub(1i128) { Some(v) => println("chk i128 sub none value {}", v), None => println("chk i128 sub none {}", 1) }
match i128_half_max().checked_mul(2i128) { Some(v) => println("chk i128 mul some {}", v), None => println("chk i128 mul some none {}", 0) }
match i128_max().checked_mul(2i128) { Some(v) => println("chk i128 mul none value {}", v), None => println("chk i128 mul none {}", 1) }
match 340282366920938463463374607431768211454u128.checked_add(1u128) { Some(v) => println("chk u128 add some {}", v), None => println("chk u128 add some none {}", 0) }
match u128_max().checked_add(1u128) { Some(v) => println("chk u128 add none value {}", v), None => println("chk u128 add none {}", 1) }
match 1u128.checked_sub(1u128) { Some(v) => println("chk u128 sub some {}", v), None => println("chk u128 sub some none {}", 0) }
match 0u128.checked_sub(1u128) { Some(v) => println("chk u128 sub none value {}", v), None => println("chk u128 sub none {}", 1) }
match u128_half_max().checked_mul(2u128) { Some(v) => println("chk u128 mul some {}", v), None => println("chk u128 mul some none {}", 0) }
match u128_max().checked_mul(2u128) { Some(v) => println("chk u128 mul none value {}", v), None => println("chk u128 mul none {}", 1) }
match 9223372036854775806isize.checked_add(1isize) { Some(v) => println("chk isize add some {}", v), None => println("chk isize add some none {}", 0) }
match isize_max().checked_add(1isize) { Some(v) => println("chk isize add none value {}", v), None => println("chk isize add none {}", 1) }
match isize_min().checked_add(1isize).unwrap_or(0isize).checked_sub(1isize) { Some(v) => println("chk isize sub some {}", v), None => println("chk isize sub some none {}", 0) }
match isize_min().checked_sub(1isize) { Some(v) => println("chk isize sub none value {}", v), None => println("chk isize sub none {}", 1) }
match isize_half_max().checked_mul(2isize) { Some(v) => println("chk isize mul some {}", v), None => println("chk isize mul some none {}", 0) }
match isize_max().checked_mul(2isize) { Some(v) => println("chk isize mul none value {}", v), None => println("chk isize mul none {}", 1) }
match 18446744073709551614usize.checked_add(1usize) { Some(v) => println("chk usize add some {}", v), None => println("chk usize add some none {}", 0) }
match usize_max().checked_add(1usize) { Some(v) => println("chk usize add none value {}", v), None => println("chk usize add none {}", 1) }
match 1usize.checked_sub(1usize) { Some(v) => println("chk usize sub some {}", v), None => println("chk usize sub some none {}", 0) }
match 0usize.checked_sub(1usize) { Some(v) => println("chk usize sub none value {}", v), None => println("chk usize sub none {}", 1) }
match usize_half_max().checked_mul(2usize) { Some(v) => println("chk usize mul some {}", v), None => println("chk usize mul some none {}", 0) }
match usize_max().checked_mul(2usize) { Some(v) => println("chk usize mul none value {}", v), None => println("chk usize mul none {}", 1) }
let assigned: Option<u64> = checked_u64_return();
match assigned { Some(v) => println("option assign {}", v), None => println("option assign none {}", 0) }
match id_u64_option(checked_u64_return()) { Some(v) => println("option call {}", v), None => println("option call none {}", 0) }
if let Some(v) = checked_u64_return() { println("option iflet {}", v); }
println("option pred {} {}", checked_u64_return().is_some(), u64_max().checked_add(1u64).is_none());
println("option unwrap {}", checked_u64_return().unwrap());
println("option unwrapor {}", u64_max().checked_add(1u64).unwrap_or(7u64));
}
"#
}
#[test]
fn explicit_integer_arithmetic_methods_run_on_c_backend_boundaries() {
if !c_backend_ready() {
eprintln!(
"skipping explicit integer arithmetic C e2e: no C backend available (buildc doctor)"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_explicit_integer_methods_c_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create explicit integer C dir");
let path = dir.join("explicit_integer_methods.bld");
std::fs::write(&path, explicit_integer_arithmetic_source())
.expect("write explicit integer method fixture");
let result = c_backend_run(&path);
assert_eq!(
result.stdout,
"u8 wrap 0 255 144\n\
i8 wrap -128 127 -128\n\
u16 sat 65535 0\n\
i16 sat 32767 -32768\n\
i32 satmul 2147483647\n\
u32 satmul 4294836225\n\
i64 sat 9223372036854775807\n\
u64 wrap 0\n\
i128 sat 170141183460469231731687303715884105727\n\
u128 wrapsat 0 340282366920938463463374607431768211455\n\
isize sat 9223372036854775807\n\
usize wrap 0\n\
u64 some 18446744073709551615\n\
u64 none 1\n\
i128 some 170141183460469231731687303715884105726\n\
i128 none 1\n\
u128 some 340282366920938463463374607431768211454\n\
u128 none 1\n\
chk i8 add some 127\n\
chk i8 add none 1\n\
chk i8 sub some -128\n\
chk i8 sub none 1\n\
chk i8 mul some 126\n\
chk i8 mul none 1\n\
chk u8 add some 255\n\
chk u8 add none 1\n\
chk u8 sub some 0\n\
chk u8 sub none 1\n\
chk u8 mul some 254\n\
chk u8 mul none 1\n\
chk i16 add some 32767\n\
chk i16 add none 1\n\
chk i16 sub some -32768\n\
chk i16 sub none 1\n\
chk i16 mul some 32766\n\
chk i16 mul none 1\n\
chk u16 add some 65535\n\
chk u16 add none 1\n\
chk u16 sub some 0\n\
chk u16 sub none 1\n\
chk u16 mul some 65534\n\
chk u16 mul none 1\n\
chk i32 add some 2147483647\n\
chk i32 add none 1\n\
chk i32 sub some -2147483648\n\
chk i32 sub none 1\n\
chk i32 mul some 2147483646\n\
chk i32 mul none 1\n\
chk u32 add some 4294967295\n\
chk u32 add none 1\n\
chk u32 sub some 0\n\
chk u32 sub none 1\n\
chk u32 mul some 4294967294\n\
chk u32 mul none 1\n\
chk i64 add some 9223372036854775807\n\
chk i64 add none 1\n\
chk i64 sub some -9223372036854775808\n\
chk i64 sub none 1\n\
chk i64 mul some 9223372036854775806\n\
chk i64 mul none 1\n\
chk u64 add some 18446744073709551615\n\
chk u64 add none 1\n\
chk u64 sub some 0\n\
chk u64 sub none 1\n\
chk u64 mul some 18446744073709551614\n\
chk u64 mul none 1\n\
chk i128 add some 170141183460469231731687303715884105727\n\
chk i128 add none 1\n\
chk i128 sub some -170141183460469231731687303715884105728\n\
chk i128 sub none 1\n\
chk i128 mul some 170141183460469231731687303715884105726\n\
chk i128 mul none 1\n\
chk u128 add some 340282366920938463463374607431768211455\n\
chk u128 add none 1\n\
chk u128 sub some 0\n\
chk u128 sub none 1\n\
chk u128 mul some 340282366920938463463374607431768211454\n\
chk u128 mul none 1\n\
chk isize add some 9223372036854775807\n\
chk isize add none 1\n\
chk isize sub some -9223372036854775808\n\
chk isize sub none 1\n\
chk isize mul some 9223372036854775806\n\
chk isize mul none 1\n\
chk usize add some 18446744073709551615\n\
chk usize add none 1\n\
chk usize sub some 0\n\
chk usize sub none 1\n\
chk usize mul some 18446744073709551614\n\
chk usize mul none 1\n\
option assign 18446744073709551615\n\
option call 18446744073709551615\n\
option iflet 18446744073709551615\n\
option pred true true\n\
option unwrap 18446744073709551615\n\
option unwrapor 7\n",
"explicit wrapping/saturating/checked integer methods must run with exact payloads"
);
}
#[test]
fn explicit_integer_arithmetic_methods_match_c_and_rust_backends() {
if !rustc_available() {
eprintln!("skipping explicit integer arithmetic Rust e2e: rustc not available");
return;
}
let rust_source = lower_source_to_rust(explicit_integer_arithmetic_source());
let result = rustc_compile_and_run("explicit_integer_methods", &rust_source);
assert_eq!(
result.stdout,
"u8 wrap 0 255 144\n\
i8 wrap -128 127 -128\n\
u16 sat 65535 0\n\
i16 sat 32767 -32768\n\
i32 satmul 2147483647\n\
u32 satmul 4294836225\n\
i64 sat 9223372036854775807\n\
u64 wrap 0\n\
i128 sat 170141183460469231731687303715884105727\n\
u128 wrapsat 0 340282366920938463463374607431768211455\n\
isize sat 9223372036854775807\n\
usize wrap 0\n\
u64 some 18446744073709551615\n\
u64 none 1\n\
i128 some 170141183460469231731687303715884105726\n\
i128 none 1\n\
u128 some 340282366920938463463374607431768211454\n\
u128 none 1\n\
chk i8 add some 127\n\
chk i8 add none 1\n\
chk i8 sub some -128\n\
chk i8 sub none 1\n\
chk i8 mul some 126\n\
chk i8 mul none 1\n\
chk u8 add some 255\n\
chk u8 add none 1\n\
chk u8 sub some 0\n\
chk u8 sub none 1\n\
chk u8 mul some 254\n\
chk u8 mul none 1\n\
chk i16 add some 32767\n\
chk i16 add none 1\n\
chk i16 sub some -32768\n\
chk i16 sub none 1\n\
chk i16 mul some 32766\n\
chk i16 mul none 1\n\
chk u16 add some 65535\n\
chk u16 add none 1\n\
chk u16 sub some 0\n\
chk u16 sub none 1\n\
chk u16 mul some 65534\n\
chk u16 mul none 1\n\
chk i32 add some 2147483647\n\
chk i32 add none 1\n\
chk i32 sub some -2147483648\n\
chk i32 sub none 1\n\
chk i32 mul some 2147483646\n\
chk i32 mul none 1\n\
chk u32 add some 4294967295\n\
chk u32 add none 1\n\
chk u32 sub some 0\n\
chk u32 sub none 1\n\
chk u32 mul some 4294967294\n\
chk u32 mul none 1\n\
chk i64 add some 9223372036854775807\n\
chk i64 add none 1\n\
chk i64 sub some -9223372036854775808\n\
chk i64 sub none 1\n\
chk i64 mul some 9223372036854775806\n\
chk i64 mul none 1\n\
chk u64 add some 18446744073709551615\n\
chk u64 add none 1\n\
chk u64 sub some 0\n\
chk u64 sub none 1\n\
chk u64 mul some 18446744073709551614\n\
chk u64 mul none 1\n\
chk i128 add some 170141183460469231731687303715884105727\n\
chk i128 add none 1\n\
chk i128 sub some -170141183460469231731687303715884105728\n\
chk i128 sub none 1\n\
chk i128 mul some 170141183460469231731687303715884105726\n\
chk i128 mul none 1\n\
chk u128 add some 340282366920938463463374607431768211455\n\
chk u128 add none 1\n\
chk u128 sub some 0\n\
chk u128 sub none 1\n\
chk u128 mul some 340282366920938463463374607431768211454\n\
chk u128 mul none 1\n\
chk isize add some 9223372036854775807\n\
chk isize add none 1\n\
chk isize sub some -9223372036854775808\n\
chk isize sub none 1\n\
chk isize mul some 9223372036854775806\n\
chk isize mul none 1\n\
chk usize add some 18446744073709551615\n\
chk usize add none 1\n\
chk usize sub some 0\n\
chk usize sub none 1\n\
chk usize mul some 18446744073709551614\n\
chk usize mul none 1\n\
option assign 18446744073709551615\n\
option call 18446744073709551615\n\
option iflet 18446744073709551615\n\
option pred true true\n\
option unwrap 18446744073709551615\n\
option unwrapor 7\n",
"Rust backend must match the C backend explicit arithmetic contract"
);
}
#[test]
fn explicit_integer_method_operands_are_evaluated_once_in_order() {
if !c_backend_ready() {
eprintln!(
"skipping explicit integer operand order C e2e: no C backend available (buildc doctor)"
);
return;
}
if !rustc_available() {
eprintln!("skipping explicit integer operand order Rust e2e: rustc not available");
return;
}
let src = r#"fn lhs() -> u8 ~ Console { println("lhs"); 255u8 }
fn rhs() -> u8 ~ Console { println("rhs"); 1u8 }
fn main() ~ Console {
println("wrap {}", lhs().wrapping_add(rhs()));
match lhs().checked_add(rhs()) { Some(v) => println("some {}", v), None => println("none {}", 0) }
}
"#;
let dir = std::env::temp_dir().join(format!(
"buildlang_explicit_integer_method_order_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create explicit integer operand order dir");
let path = dir.join("explicit_integer_method_order.bld");
std::fs::write(&path, src).expect("write explicit integer method operand order fixture");
let c_result = c_backend_run(&path);
let rust_source = lower_source_to_rust(src);
let rust_result = rustc_compile_and_run("explicit_integer_method_order", &rust_source);
let expected = "lhs\nrhs\nwrap 0\nlhs\nrhs\nnone 0\n";
assert_eq!(
c_result.stdout, expected,
"C backend must evaluate receiver and rhs once"
);
assert_eq!(
rust_result.stdout, expected,
"Rust backend must evaluate receiver and rhs once"
);
}
#[test]
fn unsupported_explicit_integer_methods_are_type_diagnostics() {
let dir = std::env::temp_dir().join(format!(
"buildlang_unsupported_explicit_integer_methods_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create unsupported explicit integer dir");
let cases = [
(
"wrapping_div",
"fn main() { let x = 1u8.wrapping_div(1u8); }\n",
".wrapping_div() on a primitive integer",
),
(
"checked_shl",
"fn main() { let x = 1u8.checked_shl(1u8); }\n",
".checked_shl() on a primitive integer",
),
(
"saturating_pow",
"fn main() { let x = 2u8.saturating_pow(3u8); }\n",
".saturating_pow() on a primitive integer",
),
(
"overflowing_add",
"fn main() { let x = 255u8.overflowing_add(1u8); }\n",
".overflowing_add() on a primitive integer",
),
];
for (name, src, needle) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write unsupported explicit integer fixture");
let (status, stdout, stderr) = check_within(&path, 30);
assert!(
!status.success(),
"unsupported explicit integer method `{name}` must fail type checking\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains(needle)
&& stderr.contains("supported primitive methods are wrapping/checked/saturating add, sub, and mul"),
"unsupported explicit integer method `{name}` must produce a focused diagnostic\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
let lower_stderr = stderr.to_lowercase();
assert!(
!lower_stderr.contains("undefined reference")
&& !lower_stderr.contains("unresolved")
&& !lower_stderr.contains("panic"),
"unsupported explicit integer method `{name}` must not reach a late backend/link failure\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn place_projection_stores_and_borrows_reach_real_storage_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping place-projection e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 6] = [
(
"cluster_p_struct_field_compound",
r#"struct Point { x: i64, y: i64 }
fn main() ~ Console {
let mut p = Point { x: 10, y: 5 };
let k = 7;
p.x += k;
println!("{}", p.x);
}
"#,
"17\n",
),
(
"cluster_p_array_element_field",
r#"struct Point { x: i64, y: i64 }
fn main() ~ Console {
let mut arr = [Point{x:1,y:1}, Point{x:2,y:2}, Point{x:3,y:3}];
arr[0].x = 100;
println!("{}", arr[0].x);
println!("{}", arr[1].x);
println!("{}", arr[2].x);
}
"#,
"100\n2\n3\n",
),
(
"cluster_p_nested_struct_field",
r#"struct Inner { c: i64 }
struct Outer { b: Inner, tag: i64 }
fn main() ~ Console {
let mut a = Outer { b: Inner { c: 9 }, tag: 9 };
a.b.c = 42;
println!("{}", a.b.c);
println!("{}", a.tag);
}
"#,
"42\n9\n",
),
(
"cluster_p_tuple_field",
r#"fn main() ~ Console {
let mut t = (10, 20);
t.0 = 50;
println!("{}", t.0);
println!("{}", t.1);
}
"#,
"50\n20\n",
),
(
"cluster_p_borrow_struct_field",
r#"struct Point { x: i64, y: i64 }
fn set77(r: &mut i64) {
*r = 77;
}
fn main() ~ Console {
let mut p = Point { x: 1, y: 2 };
set77(&mut p.x);
println!("{}", p.x);
}
"#,
"77\n",
),
(
"cluster_p_borrow_array_element",
r#"fn set88(r: &mut i32) {
*r = 88;
}
fn main() ~ Console {
let mut arr = [10, 20, 30];
set88(&mut arr[1]);
println!("{}", arr[0]);
println!("{}", arr[1]);
println!("{}", arr[2]);
}
"#,
"10\n88\n30\n",
),
];
let dir = std::env::temp_dir().join("buildlang_cluster_p_projection");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write cluster-p case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"cluster-p case `{name}` must store or borrow through the real place"
);
}
}
#[test]
fn reference_pointee_width_matched_and_annotated_array_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping ref-width positive e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 4] = [
(
"refwidth_matched_scalar_borrow",
r#"fn set6(r: &mut i64) { *r = 6; }
fn main() ~ Console {
let mut a: i64 = 5;
set6(&mut a);
println!("{}", a);
}
"#,
"6\n",
),
(
"refwidth_matched_float_borrow",
r#"fn setf(r: &mut f64) { *r = 2.0; }
fn main() ~ Console {
let mut a: f64 = 1.0;
setf(&mut a);
let n: i64 = a as i64;
println!("{}", n);
}
"#,
"2\n",
),
(
"refwidth_annotated_array_wide_borrow",
r#"fn set88(r: &mut i64) { *r = 88; }
fn main() ~ Console {
let mut arr: [i64; 3] = [10, 20, 30];
set88(&mut arr[1]);
println!("{}", arr[0]);
println!("{}", arr[1]);
println!("{}", arr[2]);
}
"#,
"10\n88\n30\n",
),
(
"refwidth_annotated_array_read",
r#"fn main() ~ Console {
let arr: [i64; 3] = [10, 20, 30];
println!("{}", arr[0]);
println!("{}", arr[1]);
println!("{}", arr[2]);
}
"#,
"10\n20\n30\n",
),
];
let dir = std::env::temp_dir().join("buildlang_refwidth_positive");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write ref-width positive case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"ref-width positive case `{name}` must reach storage at the correct width"
);
}
}
#[test]
fn compound_assign_through_plain_deref_reads_before_storing() {
if !c_backend_ready() {
eprintln!("skipping deref compound-assign e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str, &str); 5] = [
(
"deref_compound_add_param",
r#"fn addv(r: &mut i64, v: i64) { *r += v; }
fn main() ~ Console {
let mut a: i64 = 5;
addv(&mut a, 3);
println!("{}", a);
}
"#,
"8\n",
"3",
),
(
"deref_compound_mul_param",
r#"fn mulv(r: &mut i64, v: i64) { *r *= v; }
fn main() ~ Console {
let mut a: i64 = 6;
mulv(&mut a, 7);
println!("{}", a);
}
"#,
"42\n",
"7",
),
(
"deref_compound_bitand_local",
r#"fn main() ~ Console {
let mut a: i64 = 12;
let p: &mut i64 = &mut a;
*p &= 10;
println!("{}", a);
}
"#,
"8\n",
"10",
),
(
"deref_compound_shl_local",
r#"fn main() ~ Console {
let mut a: i64 = 3;
let p: &mut i64 = &mut a;
*p <<= 4;
println!("{}", a);
}
"#,
"48\n",
"4",
),
(
"deref_compound_mul_float_param",
r#"fn scale(r: &mut f64, v: f64) { *r *= v; }
fn main() ~ Console {
let mut a: f64 = 2.5;
scale(&mut a, 4.0);
println!("{}", a);
}
"#,
"10\n",
"4",
),
];
let dir = std::env::temp_dir().join("buildlang_deref_compound");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected, prefix_value) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write deref compound case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"deref compound case `{name}` must read-modify-write; pre-fix printed the bare `{prefix_value}`"
);
}
}
#[test]
fn return_position_aggregate_is_built_at_declared_width() {
if !c_backend_ready() {
eprintln!("skipping return-width e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str, &str); 4] = [
(
"return_tuple_tail",
r#"fn ret_t() -> (i64, i64) { (11, 22) }
fn main() ~ Console {
let r = ret_t();
println!("{}", r.0);
println!("{}", r.1);
}
"#,
"11\n22\n",
"94489280523 then 0 = (22<<32)|11 read at i64 over an i32-strided tuple",
),
(
"return_tuple_explicit",
r#"fn ret_t() -> (i64, i64) { return (33, 44); }
fn main() ~ Console {
let r = ret_t();
println!("{}", r.0);
println!("{}", r.1);
}
"#,
"33\n44\n",
"188978561057 then 0 = (44<<32)|33",
),
(
"return_vec_i64",
r#"fn ret_v() -> Vec<i64> { vec![1, 2, 3] }
fn main() ~ Console {
let v = ret_v();
println!("{}", v[1]);
}
"#,
"2\n",
"12884901890 = (3<<32)|2",
),
(
"return_array_i64",
r#"fn ret_a() -> [i64; 3] { [5, 6, 7] }
fn main() ~ Console {
let a = ret_a();
println!("{}", a[2]);
}
"#,
"7\n",
"garbage from an out-of-stride 8-byte read",
),
];
let dir = std::env::temp_dir().join("buildlang_return_width");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected, prefix_value) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write return-width case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"return-width case `{name}` must build the aggregate at the declared width; pre-fix printed `{prefix_value}`"
);
}
}
#[test]
fn call_argument_aggregate_is_built_at_parameter_width() {
if !c_backend_ready() {
eprintln!("skipping call-arg-width e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str, &str); 3] = [
(
"tuple_arg",
r#"fn take_t(t: (i64, i64)) ~ Console {
println!("{}", t.0);
println!("{}", t.1);
}
fn main() ~ Console {
take_t((7, 8));
}
"#,
"7\n8\n",
"C compile error: incompatible type Tuple_i32_i32 for a Tuple_i64_i64 parameter",
),
(
"vec_arg",
r#"fn take_v(v: Vec<i64>) ~ Console {
println!("{}", v[1]);
}
fn main() ~ Console {
take_v(vec![10, 20, 30]);
}
"#,
"20\n",
"128849018900 = (30<<32)|20 read at i64 over an i32-strided vec",
),
(
"array_arg",
r#"fn take_a(a: [i64; 3]) ~ Console {
println!("{}", a[2]);
}
fn main() ~ Console {
take_a([5, 6, 7]);
}
"#,
"7\n",
"garbage from an out-of-stride 8-byte read over an i32-strided array",
),
];
let dir = std::env::temp_dir().join("buildlang_call_arg_width");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected, prefix_value) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write call-arg-width case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"call-arg-width case `{name}` must build the aggregate at the parameter width; pre-fix showed `{prefix_value}`"
);
}
}
#[test]
fn reference_pointee_width_mismatch_is_rejected() {
if !c_backend_ready() {
eprintln!("skipping ref-width reject e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 4] = [
(
"refwidth_reject_scalar_int",
r#"fn set88(r: &mut i64) { *r = 88; }
fn main() ~ Console {
let mut a: i32 = 5;
set88(&mut a);
println!("{}", a);
}
"#,
"type mismatch",
),
(
"refwidth_reject_scalar_float",
r#"fn setf(r: &mut f64) { *r = 2.0; }
fn main() ~ Console {
let mut a: f32 = 1.0;
setf(&mut a);
println!("{}", a);
}
"#,
"type mismatch",
),
(
"refwidth_reject_array_mut_borrow",
r#"fn set88(r: &mut i64) { *r = 88; }
fn main() ~ Console {
let mut arr = [10, 20, 30];
set88(&mut arr[1]);
println!("{}", arr[0]);
println!("{}", arr[1]);
println!("{}", arr[2]);
}
"#,
"byte integer reference",
),
(
"refwidth_reject_array_shared_read",
r#"fn get(r: &i64) -> i64 { *r }
fn main() ~ Console {
let arr = [10, 20, 30];
let x = get(&arr[1]);
println!("{}", x);
}
"#,
"byte integer reference",
),
];
let dir = std::env::temp_dir().join("buildlang_refwidth_reject");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, reason) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write ref-width reject case");
let output = buildc()
.arg("run")
.arg(&path)
.output()
.unwrap_or_else(|err| panic!("run buildc for {name}: {err}"));
assert!(
!output.status.success(),
"ref-width reject case `{name}` must fail to compile, not silently miscompile\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains(reason),
"ref-width reject case `{name}` must fail for the width-mismatch reason (expected `{reason}` in the diagnostic), not an unrelated error:\n{stderr}"
);
}
}
#[test]
fn vec_of_tuple_or_array_element_is_rejected() {
if !c_backend_ready() {
eprintln!("skipping vec tuple/array reject e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 4] = [
(
"vec_of_array_macro_swa",
r#"fn main() ~ Console {
let v: Vec<[i64; 2]> = vec![[1, 2], [3, 4]];
println!("{}", v[0][0]);
}
"#,
"silent wrong answer: the array decayed to a pointer truncated to int32_t",
),
(
"vec_of_array_push_swa",
r#"fn main() ~ Console {
let mut v: Vec<[i64; 2]> = Vec::new();
v.push([1, 2]);
println!("{}", v[0][0]);
}
"#,
"same array-element mis-store, reached through the .push() builder path",
),
(
"vec_of_tuple_macro",
r#"fn main() ~ Console {
let v: Vec<(i64, i64)> = vec![(1, 2), (3, 4)];
println!("{}", v[0].0);
}
"#,
"leaked C type error: int32_t parameter for a Tuple_i64_i64 element",
),
(
"vec_of_tuple_push",
r#"fn main() ~ Console {
let mut v: Vec<(i64, i64)> = Vec::new();
v.push((1, 2));
println!("{}", v[0].0);
}
"#,
"same tuple-element mis-store, reached through the .push() builder path",
),
];
let dir = std::env::temp_dir().join("buildlang_vec_tuple_array_reject");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, prefix_behaviour) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write vec tuple/array reject case");
let output = buildc()
.arg("run")
.arg(&path)
.output()
.unwrap_or_else(|err| panic!("run buildc for {name}: {err}"));
assert!(
!output.status.success(),
"vec tuple/array reject case `{name}` must fail to compile, not build a scalar-strided vec (pre-fix: {prefix_behaviour})\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("the Vec runtime stores scalar"),
"vec tuple/array reject case `{name}` must fail for the unsupported-element reason, not an unrelated error:\n{stderr}"
);
}
}
#[test]
fn vec_of_supported_element_builds_and_reads() {
if !c_backend_ready() {
eprintln!(
"skipping vec supported-element positive e2e: no C backend available (buildc doctor)"
);
return;
}
let cases: [(&str, &str, &str); 9] = [
(
"vec_i64",
r#"fn main() ~ Console {
let v: Vec<i64> = vec![10, 20, 30];
println!("{}", v[1]);
}
"#,
"20\n",
),
(
"vec_f32",
r#"fn main() ~ Console {
let v: Vec<f32> = vec![1.5, 2.5, 3.5];
println!("{}", v[1]);
}
"#,
"2.5\n",
),
(
"vec_i32",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![10, 20, 30];
println!("{}", v[1]);
}
"#,
"20\n",
),
(
"vec_bool",
r#"fn main() ~ Console {
let v: Vec<bool> = vec![true, false, true];
if v[1] { println!("A"); } else { println!("B"); }
}
"#,
"B\n",
),
(
"vec_string",
r#"fn main() ~ Console {
let v: Vec<String> = vec!["a", "b", "c"];
println!("{}", v[1]);
}
"#,
"b\n",
),
(
"vec_struct_macro",
r#"struct Point { x: i64, y: i64 }
fn main() ~ Console {
let v: Vec<Point> = vec![Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
println!("{}", v[1].x);
}
"#,
"3\n",
),
(
"vec_struct_push",
r#"struct Point { x: i64, y: i64 }
fn main() ~ Console {
let mut v: Vec<Point> = Vec::new();
v.push(Point { x: 5, y: 6 });
println!("{}", v[0].y);
}
"#,
"6\n",
),
(
"vec_nested_vec_macro",
r#"fn main() ~ Console {
let v: Vec<Vec<i64>> = vec![vec![1, 2], vec![3, 4]];
println!("{}", v[1][0]);
}
"#,
"3\n",
),
(
"vec_nested_vec_push",
r#"fn main() ~ Console {
let mut v: Vec<Vec<i64>> = Vec::new();
let inner: Vec<i64> = vec![7, 8];
v.push(inner);
println!("{}", v[0][1]);
}
"#,
"8\n",
),
];
let dir = std::env::temp_dir().join("buildlang_vec_supported_positive");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write vec supported-element positive case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"vec supported-element case `{name}` must build and read its element type"
);
}
}
#[test]
fn out_of_bounds_index_aborts_fail_closed() {
if !c_backend_ready() {
eprintln!("skipping OOB fail-closed e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str); 5] = [
(
"array_read_oob",
r#"fn main() ~ Console {
let a = [11, 22, 33];
let i = 5;
println!("{}", a[i]);
}
"#,
),
(
"array_write_oob",
r#"fn main() ~ Console {
let mut a = [11, 22, 33];
let i = 7;
a[i] = 99;
println!("{}", a[0]);
}
"#,
),
(
"vec_read_oob",
r#"fn main() ~ Console {
let v: Vec<i64> = vec![1, 2, 3];
let i = 5;
println!("{}", v[i]);
}
"#,
),
(
"vec_write_oob",
r#"fn main() ~ Console {
let mut v: Vec<i64> = vec![1, 2, 3];
let i = 5;
v[i] = 9;
println!("{}", v[0]);
}
"#,
),
(
"array_negative_index",
r#"fn main() ~ Console {
let a = [11, 22, 33];
let i = 0 - 1;
println!("{}", a[i]);
}
"#,
),
];
let dir = std::env::temp_dir().join("buildlang_oob_fail_closed");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write OOB fail-closed case");
let (stdout, stderr, exit_code) = c_backend_run_capture(&path);
assert_ne!(
exit_code,
Some(0),
"OOB case `{name}` must abort, not exit 0\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains("index out of bounds"),
"OOB case `{name}` must print the bounds diagnostic; got exit {exit_code:?}\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn in_bounds_index_reads_and_writes_correctly() {
if !c_backend_ready() {
eprintln!("skipping in-bounds positive e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 4] = [
(
"array_read_last",
r#"fn main() ~ Console {
let a = [11, 22, 33];
let i = 2;
println!("{}", a[i]);
}
"#,
"33\n",
),
(
"array_write_mid",
r#"fn main() ~ Console {
let mut a = [11, 22, 33];
let i = 1;
a[i] = 99;
println!("{}", a[i]);
}
"#,
"99\n",
),
(
"vec_read_mid",
r#"fn main() ~ Console {
let v: Vec<i64> = vec![10, 20, 30];
let i = 1;
println!("{}", v[i]);
}
"#,
"20\n",
),
(
"vec_write_last",
r#"fn main() ~ Console {
let mut v: Vec<i64> = vec![10, 20, 30];
let i = 2;
v[i] = 77;
println!("{}", v[i]);
}
"#,
"77\n",
),
];
let dir = std::env::temp_dir().join("buildlang_in_bounds_positive");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write in-bounds positive case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"in-bounds case `{name}` must read/write the correct value at the boundary"
);
}
}
#[test]
fn plain_integer_add_sub_mul_and_neg_overflow_abort_fail_closed() {
if !c_backend_ready() {
eprintln!("skipping plain integer overflow fail-closed e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 13] = [
(
"i8_add_overflow",
r#"fn main() ~ Console {
let v: Vec<i8> = vec![127i8, 1i8];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"u8_add_overflow",
r#"fn main() ~ Console {
let v: Vec<u8> = vec![255u8, 1u8];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"i16_sub_overflow",
r#"fn main() ~ Console {
let v: Vec<i16> = vec![0i16, 32767i16, 1i16];
let min = v[0] - v[1] - v[2];
println!("{}", min - v[2]);
}
"#,
"attempt to subtract with overflow",
),
(
"u16_sub_overflow",
r#"fn main() ~ Console {
let v: Vec<u16> = vec![0u16, 1u16];
let a = v[0];
let b = v[1];
println!("{}", a - b);
}
"#,
"attempt to subtract with overflow",
),
(
"i32_mul_overflow",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![2147483647, 2];
let a = v[0];
let b = v[1];
println!("{}", a * b);
}
"#,
"attempt to multiply with overflow",
),
(
"u32_mul_overflow",
r#"fn main() ~ Console {
let v: Vec<u32> = vec![4294967295u32, 2u32];
let a = v[0];
let b = v[1];
println!("{}", a * b);
}
"#,
"attempt to multiply with overflow",
),
(
"i64_add_overflow",
r#"fn main() ~ Console {
let v: Vec<i64> = vec![9223372036854775807i64, 1i64];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"u64_add_overflow",
r#"fn main() ~ Console {
let v: Vec<u64> = vec![18446744073709551615u64, 1u64];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"i128_add_overflow",
r#"fn main() ~ Console {
let v: Vec<i128> = vec![170141183460469231731687303715884105727i128, 1i128];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"u128_add_overflow",
r#"fn main() ~ Console {
let v: Vec<u128> = vec![340282366920938463463374607431768211455u128, 1u128];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"isize_add_overflow",
r#"fn main() ~ Console {
let v: Vec<isize> = vec![9223372036854775807isize, 1isize];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"usize_add_overflow",
r#"fn main() ~ Console {
let v: Vec<usize> = vec![18446744073709551615usize, 1usize];
let a = v[0];
let b = v[1];
println!("{}", a + b);
}
"#,
"attempt to add with overflow",
),
(
"i8_neg_overflow",
r#"fn main() ~ Console {
let v: Vec<i8> = vec![0i8, 127i8, 1i8];
let min = v[0] - v[1] - v[2];
println!("{}", -min);
}
"#,
"attempt to negate with overflow",
),
];
let dir = std::env::temp_dir().join("buildlang_plain_integer_overflow_fail_closed");
std::fs::create_dir_all(&dir).expect("create plain-overflow fail-closed dir");
for (name, src, needle) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write plain-overflow fail-closed case");
let (stdout, stderr, exit_code) = c_backend_run_capture(&path);
assert_eq!(
exit_code,
Some(101),
"plain integer overflow case `{name}` must abort with exit 101\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains(needle),
"plain integer overflow case `{name}` must print `{needle}`; got exit {exit_code:?}\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn plain_integer_in_bounds_near_boundaries_and_compound_assignment_run() {
if !c_backend_ready() {
eprintln!("skipping plain integer in-bounds e2e: no C backend available (buildc doctor)");
return;
}
let src = r#"fn main() ~ Console {
let i8s: Vec<i8> = vec![126i8, 1i8];
let u8s: Vec<u8> = vec![254u8, 1u8];
let i16s: Vec<i16> = vec![0i16, 32767i16, 1i16];
let u16s: Vec<u16> = vec![1u16, 1u16];
let i32s: Vec<i32> = vec![46340, 46340];
let u32s: Vec<u32> = vec![65535u32, 65535u32];
let i64s: Vec<i64> = vec![9223372036854775806i64, 1i64];
let u64s: Vec<u64> = vec![18446744073709551614u64, 1u64];
let i128s: Vec<i128> = vec![170141183460469231731687303715884105727i128, 1i128];
let u128s: Vec<u128> = vec![340282366920938463463374607431768211455u128, 1u128];
let isizes: Vec<isize> = vec![9223372036854775806isize, 1isize];
let usizes: Vec<usize> = vec![18446744073709551614usize, 1usize];
println!("{}", i8s[0] + i8s[1]);
let mut c: u8 = u8s[0];
c += u8s[1];
println!("{}", c);
println!("{}", i16s[0] - i16s[1] - i16s[2]);
println!("{}", u16s[0] - u16s[1]);
println!("{}", i32s[0] * i32s[1]);
println!("{}", u32s[0] * u32s[1]);
println!("{}", i64s[0] + i64s[1]);
println!("{}", u64s[0] + u64s[1]);
println!("{}", i128s[0] - i128s[1]);
println!("{}", u128s[0] - u128s[1]);
println!("{}", isizes[0] + isizes[1]);
println!("{}", usizes[0] + usizes[1]);
let min_i8 = i8s[1] - i8s[0] - i8s[1];
println!("{}", -min_i8);
}
"#;
let dir = std::env::temp_dir().join("buildlang_plain_integer_in_bounds");
std::fs::create_dir_all(&dir).expect("create plain integer in-bounds dir");
let path = dir.join("in_bounds.bld");
std::fs::write(&path, src).expect("write plain integer in-bounds case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout,
"127\n255\n-32768\n0\n2147395600\n4294836225\n9223372036854775807\n18446744073709551615\n170141183460469231731687303715884105726\n340282366920938463463374607431768211454\n9223372036854775807\n18446744073709551615\n126\n",
"plain integer checked arithmetic must not reject in-bounds boundary operations"
);
}
#[test]
fn c_i128_u128_print_materializes_more_than_static_formatter_slot_count() {
if !c_backend_ready() {
eprintln!("skipping i128/u128 formatter slot e2e: no C backend available (buildc doctor)");
return;
}
let src = r#"fn main() ~ Console {
let i1: i128 = 1i128;
let i2: i128 = 2i128;
let i3: i128 = 3i128;
let i4: i128 = 4i128;
let i5: i128 = 5i128;
let i6: i128 = 6i128;
let i7: i128 = 7i128;
let i8: i128 = 8i128;
let i9: i128 = 9i128;
let i10: i128 = 10i128;
let i11: i128 = 11i128;
let i12: i128 = 12i128;
let i13: i128 = 13i128;
let i14: i128 = 14i128;
let i15: i128 = 15i128;
let i16: i128 = 16i128;
let i17: i128 = 17i128;
println("{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17);
let u1: u128 = 1u128;
let u2: u128 = 2u128;
let u3: u128 = 3u128;
let u4: u128 = 4u128;
let u5: u128 = 5u128;
let u6: u128 = 6u128;
let u7: u128 = 7u128;
let u8: u128 = 8u128;
let u9: u128 = 9u128;
let u10: u128 = 10u128;
let u11: u128 = 11u128;
let u12: u128 = 12u128;
let u13: u128 = 13u128;
let u14: u128 = 14u128;
let u15: u128 = 15u128;
let u16: u128 = 16u128;
let u17: u128 = 17u128;
println("{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}", u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15, u16, u17);
}
"#;
let dir = std::env::temp_dir().join("buildlang_i128_u128_formatter_slots");
std::fs::create_dir_all(&dir).expect("create i128/u128 formatter slot dir");
let path = dir.join("formatter_slots.bld");
std::fs::write(&path, src).expect("write i128/u128 formatter slot case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout,
"1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17\n",
"i128/u128 print arguments must not alias the runtime formatter's static ring slots"
);
}
#[test]
fn plain_integer_runtime_overflow_exit_code_matches_c_and_rust_backends() {
if !c_backend_ready() {
eprintln!(
"skipping C/Rust plain integer overflow parity: no C backend available (buildc doctor)"
);
return;
}
if !rustc_available() {
eprintln!("skipping C/Rust plain integer overflow parity: rustc not available");
return;
}
let src = r#"fn add(a: i32, b: i32) -> i32 {
a + b
}
fn main() ~ Console {
println!("{}", add(2147483647, 1));
}
"#;
let dir = std::env::temp_dir().join("buildlang_plain_integer_backend_parity");
std::fs::create_dir_all(&dir).expect("create plain integer backend parity dir");
let path = dir.join("backend_parity.bld");
std::fs::write(&path, src).expect("write backend parity fixture");
let (c_stdout, c_stderr, c_exit_code) = c_backend_run_capture(&path);
let rust_source = lower_source_to_rust(src);
let rust_result = rustc_compile_and_run("plain_integer_overflow_parity", &rust_source);
assert_eq!(
c_exit_code,
Some(101),
"C backend must abort plain integer overflow with exit 101\nstdout:\n{c_stdout}\nstderr:\n{c_stderr}"
);
assert!(
c_stderr.contains("attempt to add with overflow"),
"C backend overflow diagnostic must name addition overflow\nstdout:\n{c_stdout}\nstderr:\n{c_stderr}"
);
assert_eq!(
rust_result.exit_code, c_exit_code,
"Rust backend must match the C backend's overflow exit status"
);
}
#[test]
fn integer_divide_by_zero_and_overflow_abort_fail_closed() {
if !c_backend_ready() {
eprintln!(
"skipping integer div/rem fail-closed e2e: no C backend available (buildc doctor)"
);
return;
}
let cases: [(&str, &str, &str); 7] = [
(
"div_zero_i32",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![0, 1];
let b = v[0];
let a = 7;
println!("{}", a / b);
}
"#,
"attempt to divide by zero",
),
(
"rem_zero_i32",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![0, 1];
let b = v[0];
let a = 7;
println!("{}", a % b);
}
"#,
"attempt to calculate the remainder with a divisor of zero",
),
(
"div_zero_u32",
r#"fn main() ~ Console {
let v: Vec<u32> = vec![0u32, 1u32];
let b = v[0];
let a: u32 = 7u32;
println!("{}", a / b);
}
"#,
"attempt to divide by zero",
),
(
"div_overflow_i32",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![0];
let nb = v[0] - 1;
let a: i32 = 0 - 2147483647 - 1;
println!("{}", a / nb);
}
"#,
"attempt to divide with overflow",
),
(
"rem_overflow_i32",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![0];
let nb = v[0] - 1;
let a: i32 = 0 - 2147483647 - 1;
println!("{}", a % nb);
}
"#,
"attempt to calculate the remainder with overflow",
),
(
"div_overflow_i8",
r#"fn main() ~ Console {
let v: Vec<i8> = vec![0i8];
let nb = v[0] - 1i8;
let a: i8 = 0i8 - 127i8 - 1i8;
println!("{}", a / nb);
}
"#,
"attempt to divide with overflow",
),
(
"div_overflow_i64",
r#"fn main() ~ Console {
let v: Vec<i64> = vec![0i64];
let nb = v[0] - 1i64;
let a: i64 = 0i64 - 9223372036854775807i64 - 1i64;
println!("{}", a / nb);
}
"#,
"attempt to divide with overflow",
),
];
let dir = std::env::temp_dir().join("buildlang_div_fail_closed");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, needle) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write div/rem fail-closed case");
let (stdout, stderr, exit_code) = c_backend_run_capture(&path);
assert_eq!(
exit_code,
Some(101),
"div/rem case `{name}` must abort with exit 101 (Rust panic)\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains(needle),
"div/rem case `{name}` must print `{needle}`; got exit {exit_code:?}\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn integer_divide_and_remainder_compute_correctly() {
if !c_backend_ready() {
eprintln!("skipping integer div/rem positive e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 9] = [
(
"div_7_2",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![7, 2];
let a = v[0];
let b = v[1];
println!("{}", a / b);
}
"#,
"3\n",
),
(
"rem_7_2",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![7, 2];
let a = v[0];
let b = v[1];
println!("{}", a % b);
}
"#,
"1\n",
),
(
"div_neg7_2",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![-7, 2];
let a = v[0];
let b = v[1];
println!("{}", a / b);
}
"#,
"-3\n",
),
(
"rem_neg7_2",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![-7, 2];
let a = v[0];
let b = v[1];
println!("{}", a % b);
}
"#,
"-1\n",
),
(
"div_u32_7_2",
r#"fn main() ~ Console {
let v: Vec<u32> = vec![7u32, 2u32];
let a = v[0];
let b = v[1];
println!("{}", a / b);
}
"#,
"3\n",
),
(
"div_i8_100_3",
r#"fn main() ~ Console {
let v: Vec<i8> = vec![100i8, 3i8];
let a = v[0];
let b = v[1];
println!("{}", a / b);
}
"#,
"33\n",
),
(
"div_min_1",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![1];
let b = v[0];
let a: i32 = 0 - 2147483647 - 1;
println!("{}", a / b);
}
"#,
"-2147483648\n",
),
(
"rem_min_1",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![1];
let b = v[0];
let a: i32 = 0 - 2147483647 - 1;
println!("{}", a % b);
}
"#,
"0\n",
),
(
"div_min_neg2",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![1];
let b = v[0] - 3;
let a: i32 = 0 - 2147483647 - 1;
println!("{}", a / b);
}
"#,
"1073741824\n",
),
];
let dir = std::env::temp_dir().join("buildlang_div_positive");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write div/rem positive case");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, expected,
"div/rem case `{name}` must compute the correct value"
);
}
}
#[test]
fn non_exhaustive_scalar_match_is_rejected_at_compile_time() {
let cases: [(&str, &str, &str); 4] = [
(
"bool_missing_false",
r#"fn pick(b: bool) -> i32 {
match b {
true => 42,
}
}
fn main() ~ Console {
println!("{}", pick(true));
}
"#,
"non-exhaustive match: missing variants",
),
(
"i32_two_literals",
r#"fn classify(n: i32) -> i32 {
match n {
0 => 100,
1 => 200,
}
}
fn main() ~ Console {
println!("{}", classify(9));
}
"#,
"non-exhaustive patterns",
),
(
"annotated_let_i32",
r#"fn main() ~ Console {
let n: i32 = 9;
let mut out = 7;
match n {
0 => { out = 1; }
1 => { out = 2; }
}
println!("{}", out);
}
"#,
"non-exhaustive patterns",
),
(
"typed_param_i32",
r#"fn go(n: i32) ~ Console {
let mut out = 7;
match n {
0 => { out = 1; }
1 => { out = 2; }
}
println!("{}", out);
}
fn main() ~ Console {
go(9);
}
"#,
"non-exhaustive patterns",
),
];
let dir = std::env::temp_dir().join("buildlang_match_nonexhaustive_reject");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, needle) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write non-exhaustive case");
let out_c = dir.join(format!("{name}.c"));
let output = buildc()
.arg(&path)
.arg("-o")
.arg(&out_c)
.output()
.expect("run buildc to emit C");
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
!output.status.success(),
"case `{name}` must fail to compile (non-exhaustive match)\nstderr:\n{stderr}"
);
assert!(
stderr.contains(needle),
"case `{name}` must report `{needle}`\nstderr:\n{stderr}"
);
}
}
#[test]
fn exhaustive_scalar_match_still_compiles_and_runs() {
if !c_backend_ready() {
eprintln!("skipping exhaustive-match e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str, &str); 3] = [
(
"wildcard_arm",
r#"fn classify(n: i32) -> i32 {
match n {
0 => 100,
1 => 200,
_ => 999,
}
}
fn main() ~ Console {
println!("{}", classify(9));
}
"#,
"999",
),
(
"binding_arm",
r#"fn classify(n: i32) -> i32 {
match n {
0 => 100,
other => other + 1,
}
}
fn main() ~ Console {
println!("{}", classify(41));
}
"#,
"42",
),
(
"bool_both_arms",
r#"fn pick(b: bool) -> i32 {
match b {
true => 42,
false => 7,
}
}
fn main() ~ Console {
println!("{}", pick(false));
}
"#,
"7",
),
];
let dir = std::env::temp_dir().join("buildlang_match_exhaustive_ok");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src, expected) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write exhaustive case");
let (stdout, stderr, exit_code) = c_backend_run_capture(&path);
assert_eq!(
exit_code,
Some(0),
"exhaustive case `{name}` must run cleanly\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert_eq!(
stdout.trim(),
expected,
"exhaustive case `{name}` must print `{expected}`\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn non_exhaustive_match_over_runtime_value_aborts_fail_closed() {
if !c_backend_ready() {
eprintln!("skipping match backstop e2e: no C backend available (buildc doctor)");
return;
}
let cases: [(&str, &str); 2] = [
(
"let_bound_vec_value",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![9];
let n = v[0];
let mut out = 7;
match n {
0 => { out = 1; }
1 => { out = 2; }
}
println!("{}", out);
}
"#,
),
(
"direct_vec_index",
r#"fn main() ~ Console {
let v: Vec<i32> = vec![9];
match v[0] {
0 => { println!("z"); }
1 => { println!("o"); }
}
}
"#,
),
];
let dir = std::env::temp_dir().join("buildlang_match_backstop");
std::fs::create_dir_all(&dir).expect("create temp dir");
for (name, src) in cases {
let path = dir.join(format!("{name}.bld"));
std::fs::write(&path, src).expect("write match backstop case");
let (stdout, stderr, exit_code) = c_backend_run_capture(&path);
assert_eq!(
exit_code,
Some(101),
"match backstop case `{name}` must abort with exit 101\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
assert!(
stderr.contains("non-exhaustive match: no arm matched the scrutinee"),
"match backstop case `{name}` must print the no-match diagnostic\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
}
}
#[test]
fn unary_complement_uses_type_directed_c_operator_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping unary-complement e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let x: i32 = 5;\n\
println!(\"{}\", ~x);\n\
println!(\"{}\", !x);\n\
let y: u8 = 5;\n\
println!(\"{}\", ~y);\n\
let b: bool = true;\n\
if !b { println!(\"t\"); } else { println!(\"f\"); }\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_unary_complement_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("unary_complement.bld");
std::fs::write(&path, src).expect("write unary_complement.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "-6\n-6\n250\nf\n",
"`~` and integer `!` must lower to bitwise complement, `!bool` to logical not"
);
}
#[test]
fn float_remainder_uses_fmod_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping float-remainder e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let a: f64 = 5.5;\n\
let b: f64 = 2.0;\n\
println!(\"{}\", a % b);\n\
let c: f32 = 7.5;\n\
let d: f32 = 2.0;\n\
println!(\"{}\", c % d);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_float_remainder_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("float_remainder.bld");
std::fs::write(&path, src).expect("write float_remainder.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "1.5\n1.5\n",
"float remainder must lower to fmod/fmodf and compute correctly"
);
}
#[test]
fn float_display_matches_rust_shortest_roundtrip_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping float-display e2e: no C backend available (buildc doctor)");
return;
}
let src = r#"fn main() ~ Console {
let a: f64 = 0.1;
let b: f64 = 0.2;
println!("{}", a + b);
let big: f64 = 1234567.0;
println!("{}", big);
let whole: f64 = 2.0;
println!("{}", whole);
let x: f64 = 3.14159265358979;
println!("{}", x);
let f: f32 = 1234567.0;
println!("{}", f);
let s: f32 = 0.1;
println!("{}", s);
}
"#;
let dir = std::env::temp_dir().join("buildlang_float_display_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("float_display.bld");
std::fs::write(&path, src).expect("write float_display.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "0.30000000000000004\n1234567\n2\n3.14159265358979\n1234567\n0.1\n",
"float Display must match Rust's shortest round-trip, not C's %g"
);
}
#[test]
fn float_to_int_cast_saturates_like_rust_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping float-cast e2e: no C backend available (buildc doctor)");
return;
}
let src = r#"fn main() ~ Console {
let m: f64 = 1000000.0;
let big: f64 = m * m * m * m * m;
let neg: f64 = 0.0 - big;
let zero: f64 = 0.0;
let nan: f64 = zero / zero;
println!("{}", big as i32);
println!("{}", neg as i32);
println!("{}", nan as i32);
println!("{}", big as u8);
println!("{}", neg as u8);
println!("{}", big as i64);
println!("{}", big as u64);
}
"#;
let dir = std::env::temp_dir().join("buildlang_float_cast_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("float_cast.bld");
std::fs::write(&path, src).expect("write float_cast.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout,
"2147483647\n-2147483648\n0\n255\n0\n9223372036854775807\n18446744073709551615\n",
"float-to-int cast must saturate to MIN/MAX and map NaN to 0 like Rust's as"
);
}
#[test]
fn narrow_shift_masks_count_to_width_like_rust_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping narrow-shift e2e: no C backend available (buildc doctor)");
return;
}
let src = r#"fn main() ~ Console {
let mut s9: u32 = 9;
let mut s8: u32 = 8;
let mut s16: u32 = 16;
let mut s17: u32 = 17;
let a: u8 = 255u8;
let b: u8 = 1u8;
let c: i8 = 0i8 - 127i8 - 1i8;
let d: u16 = 1u16;
let e: u16 = 65535u16;
let f: i16 = 1i16;
println!("{}", a >> s9);
println!("{}", b << s8);
println!("{}", c >> s9);
println!("{}", d << s16);
println!("{}", e >> s17);
println!("{}", f << s16);
let mut s32: u32 = 32;
let g: i32 = 1i32;
println!("{}", g << s32);
let h: u64 = 255u64;
let mut s65: u32 = 65;
println!("{}", h >> s65);
}
"#;
let dir = std::env::temp_dir().join("buildlang_narrow_shift_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("narrow_shift.bld");
std::fs::write(&path, src).expect("write narrow_shift.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "127\n1\n-64\n1\n32767\n1\n1\n127\n",
"narrow-width over-shift must mask the count to the operand width like Rust release"
);
}
#[test]
fn labeled_break_continue_target_named_loop_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping labeled-loop e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let mut a = 0;\n\
'outer: for i in 0..3 {\n\
for j in 0..3 { if j == 1 { break 'outer; } a = a + 1; }\n\
}\n\
println(\"{}\", a);\n\
let mut b = 0;\n\
'outer2: for i in 0..3 {\n\
for j in 0..3 { if j == 0 { continue 'outer2; } b = b + 1; }\n\
}\n\
println(\"{}\", b);\n\
let mut c = 0;\n\
for i in 0..3 { for j in 0..3 { if j == 1 { break; } c = c + 1; } }\n\
println(\"{}\", c);\n\
let mut d = 0;\n\
let mut k = 0;\n\
'w: while k < 3 {\n\
for j in 0..3 { if j == 2 { break 'w; } d = d + 1; }\n\
k = k + 1;\n\
}\n\
println(\"{}\", d);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_labeled_loops_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("labeled_loops.bld");
std::fs::write(&path, src).expect("write labeled_loops.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "1\n0\n3\n2\n",
"break/continue with a label must target the named loop, not the innermost"
);
}
#[test]
fn check_rejects_undefined_loop_label() {
let id = std::process::id();
let bad = std::env::temp_dir().join(format!("buildlang_undef_break_label_{id}.bld"));
fs::write(
&bad,
"fn main() {\n loop {\n break 'nope;\n }\n}\n",
)
.expect("write undefined-label fixture");
let output = buildc()
.arg("check")
.arg(&bad)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let stdout = output.stdout.clone();
let _ = fs::remove_file(&bad);
assert!(
!output.status.success(),
"check must fail for an undefined loop label\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&stdout),
String::from_utf8_lossy(&output.stderr)
);
let receipt: serde_json::Value =
serde_json::from_slice(&stdout).expect("stdout should be JSON receipt");
assert_eq!(receipt["status"], "failed");
let diagnostics = receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert!(
diagnostics.iter().any(|diag| {
diag["stage"] == "type"
&& diag["kind"] == "UndefinedLoopLabel"
&& diag["message"].as_str().unwrap_or("").contains("'nope")
}),
"expected an UndefinedLoopLabel type diagnostic naming 'nope in {diagnostics:#?}"
);
let bad_cont = std::env::temp_dir().join(format!("buildlang_undef_cont_label_{id}.bld"));
fs::write(
&bad_cont,
"fn main() {\n 'a: loop {\n continue 'b;\n }\n}\n",
)
.expect("write undefined-continue-label fixture");
let cont_out = buildc()
.arg("check")
.arg(&bad_cont)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&bad_cont);
assert!(
!cont_out.status.success(),
"check must fail for `continue` to an undefined label"
);
let good = std::env::temp_dir().join(format!("buildlang_valid_label_{id}.bld"));
fs::write(
&good,
"fn main() {\n 'outer: loop {\n loop {\n break 'outer;\n }\n }\n}\n",
)
.expect("write valid-label fixture");
let good_out = buildc()
.arg("check")
.arg(&good)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&good);
assert!(
good_out.status.success(),
"a labeled loop with a resolvable `break` target must pass check\nstderr:\n{}",
String::from_utf8_lossy(&good_out.stderr)
);
}
#[test]
fn match_pattern_tests_and_result_type_compute_correctly_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping match-pattern e2e: no C backend available (buildc doctor)");
return;
}
let src = "enum Color { Red, Green, Blue }\n\
fn main() ~ Console {\n\
let x: i64 = 5000000000;\n\
let r_open = match x { 100.. => 1, _ => 0 };\n\
println!(\"{}\", r_open);\n\
let y: i32 = 100;\n\
let r_at = match y { n @ 1..=5 => n, _ => -1 };\n\
println!(\"{}\", r_at);\n\
let a = Color::Blue;\n\
let r_or = match a { Color::Red => 1, Color::Green | Color::Blue => 2 };\n\
println!(\"{}\", r_or);\n\
let c = Color::Blue;\n\
let r_enumat = match c { n @ Color::Red => 1, _ => 2 };\n\
println!(\"{}\", r_enumat);\n\
let b: bool = true;\n\
let r_bool = match b { true => 42, false => 7 };\n\
println!(\"{}\", r_bool);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_pattern_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("match_pattern.bld");
std::fs::write(&path, src).expect("write match_pattern.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "1\n-1\n2\n2\n42\n",
"match pattern tests must gate on the real pattern and the result must take the arm type"
);
}
#[test]
fn option_i64_return_and_match_runs_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping option_i64 e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn checked_add(a: i64, b: i64) -> Option<i64> {\n\
let max = 9223372036854775807;\n\
if b > max - a { None } else { Some(a + b) }\n\
}\n\
fn main() ~ Console {\n\
match checked_add(100000, 2599) { Some(v) => println(\"ok {}\", v), None => println(\"of {}\", 0) }\n\
let big = 9223372036854775000;\n\
match checked_add(big, 1000) { Some(v) => println(\"ok {}\", v), None => println(\"rej {}\", 1) }\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_option_i64_regress");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("option_i64.bld");
std::fs::write(&path, src).expect("write option_i64.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "ok 102599\nrej 1\n",
"Option<i64> return + match must run end-to-end with the 64-bit payload intact"
);
}
#[test]
fn match_tuple_literal_pattern_selects_equal_arm() {
if !c_backend_ready() {
eprintln!("skipping tuple-literal-arm e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let pair = (3, 4);\n\
let r = match pair {\n\
(1, 2) => \"a\",\n\
(3, 4) => \"b\",\n\
_ => \"other\",\n\
};\n\
println(\"{}\", r);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_tuple_literal");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("tuple_literal.bld");
std::fs::write(&path, src).expect("write tuple_literal.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "b\n",
"a tuple pattern must test every element for equality, not silently always match"
);
}
#[test]
fn match_tuple_scalar_result_over_tuple_scrutinee() {
if !c_backend_ready() {
eprintln!("skipping tuple-scalar-result e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let pair = (3, 4);\n\
let r = match pair {\n\
(1, 2) => 100,\n\
(3, 4) => 200,\n\
_ => 999,\n\
};\n\
println(\"{}\", r);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_tuple_scalar");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("tuple_scalar.bld");
std::fs::write(&path, src).expect("write tuple_scalar.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "200\n",
"scalar match arms over a tuple scrutinee must produce a scalar result, not an aggregate"
);
}
#[test]
fn match_nested_tuple_pattern_tests_inner_elements() {
if !c_backend_ready() {
eprintln!("skipping nested-tuple e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let p = ((1, 2), 9);\n\
let r = match p {\n\
((1, 3), 9) => \"wrongA\",\n\
((1, 2), 9) => \"right\",\n\
_ => \"other\",\n\
};\n\
println(\"{}\", r);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_nested_tuple");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("nested_tuple.bld");
std::fs::write(&path, src).expect("write nested_tuple.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "right\n",
"a nested tuple pattern must test inner elements, not silently always match"
);
}
#[test]
fn match_tuple_pattern_binds_elements() {
if !c_backend_ready() {
eprintln!("skipping tuple-binding e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let p = (7, 8);\n\
match p { (a, b) => println(\"{}\", a + b), }\n\
let q = ((3, 4), 5);\n\
match q { ((a, b), c) => println(\"{}\", a + b + c), }\n\
let m = (1, 20);\n\
match m { (1, x) => println(\"{}\", x), _ => println(\"{}\", 0), }\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_tuple_binds");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("tuple_binds.bld");
std::fs::write(&path, src).expect("write tuple_binds.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "15\n12\n20\n",
"tuple, nested-tuple, and mixed literal/binding patterns must bind their element variables"
);
}
#[test]
fn match_tuple_guard_references_bindings() {
if !c_backend_ready() {
eprintln!("skipping tuple-guard e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let p = (3, 4);\n\
let r = match p {\n\
(a, b) if a < b => a * 10 + b,\n\
(a, b) => a + b,\n\
};\n\
println(\"{}\", r);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_match_tuple_guard");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("tuple_guard.bld");
std::fs::write(&path, src).expect("write tuple_guard.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "34\n",
"a guard clause must see the tuple pattern's bound elements"
);
}
#[test]
fn match_slice_pattern_fails_closed() {
let dir = std::env::temp_dir().join(format!(
"buildlang_match_slice_closed_{}",
std::process::id()
));
std::fs::create_dir_all(&dir).expect("create temp dir");
let fixture = dir.join("slice_pattern.bld");
fs::write(
&fixture,
"fn main() ~ Console {\n\
let a = [1, 2, 3];\n\
let r = match a {\n\
[1, 2, 3] => \"a\",\n\
_ => \"other\",\n\
};\n\
println(\"{}\", r);\n\
}\n",
)
.expect("write slice-pattern fixture");
let out_c = dir.join("slice_pattern.c");
let output = buildc()
.arg(&fixture)
.args(["--target", "c", "-o"])
.arg(&out_c)
.output()
.expect("run buildc --target c");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"a slice pattern in match must fail closed, not compile as always-true\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.to_lowercase().contains("slice pattern"),
"diagnostic should name the unsupported slice pattern:\n{}",
stderr
);
}
#[test]
fn unicode_math_operators_run_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping unicode-math e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let a = 6 \u{00D7} 7;\n\
let b = 84 \u{00F7} 2;\n\
let c = 10 \u{2212} 3;\n\
println(\"{} {} {}\", a, b, c);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_unicode_math_ops");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("unicode_math.bld");
std::fs::write(&path, src).expect("write unicode_math.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "42 42 7\n",
"Unicode math operators must alias to * / - and run end-to-end"
);
}
#[test]
fn power_operator_runs_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping power-operator e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
println(\"{}\", 2 ** 10);\n\
println(\"{}\", 2 ** 3 ** 2);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_power_operator");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("power.bld");
std::fs::write(&path, src).expect("write power.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "1024\n512\n",
"`**` must compute power and be right-associative (2 ** 3 ** 2 == 512)"
);
}
#[test]
fn neg_power_semantics() {
if !c_backend_ready() {
eprintln!("skipping neg-power e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
println(\"{}\", -2 ** 2);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_neg_power");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("neg_power.bld");
std::fs::write(&path, src).expect("write neg_power.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "-4\n",
"-2 ** 2 must be -(2 ** 2) == -4 (unary minus binds looser than **)"
);
}
#[test]
fn array_broadcast_runs_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping array-broadcast e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let a = [1.0, 2.0, 3.0];\n\
let b = [10.0, 20.0, 30.0];\n\
let sum = a .+ b;\n\
println(\"{} {} {}\", sum[0], sum[1], sum[2]);\n\
let scaled = a .* 2.0;\n\
println(\"{} {} {}\", scaled[0], scaled[1], scaled[2]);\n\
let shifted = 2.0 .+ a;\n\
println(\"{} {} {}\", shifted[0], shifted[1], shifted[2]);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_array_broadcast");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("array_broadcast.bld");
std::fs::write(&path, src).expect("write array_broadcast.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "11 22 33\n2 4 6\n3 4 5\n",
"`.+` must add elementwise, `.* 2.0` scale each element, `2.0 .+ a` broadcast scalar-left"
);
}
#[test]
fn array_broadcast_length_mismatch_is_rejected() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_array_broadcast_mismatch_{}.bld",
std::process::id()
));
fs::write(
&fixture,
"fn main() ~ Console {\n\
let a = [1.0, 2.0];\n\
let b = [1.0, 2.0, 3.0];\n\
let c = a .+ b;\n\
println(\"{}\", c[0]);\n\
}\n",
)
.expect("write array-broadcast mismatch fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"broadcasting arrays of different lengths must fail buildc check"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.to_lowercase().contains("length"),
"diagnostic should mention the length mismatch:\n{}",
stderr
);
}
#[test]
fn array_broadcast_sub_div_run_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping array-broadcast sub/div e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn print3(a: [f64; 3]) ~ Console {\n\
println(\"{} {} {}\", a[0], a[1], a[2]);\n\
}\n\
fn print2(p: [f64; 2]) ~ Console {\n\
println(\"{} {}\", p[0], p[1]);\n\
}\n\
fn main() ~ Console {\n\
let a = [10.0, 20.0, 30.0];\n\
let b = [1.0, 2.0, 3.0];\n\
let diff = a .- b;\n\
print3(diff);\n\
let p = [10.0, 20.0];\n\
let q = [2.0, 4.0];\n\
let quot = p ./ q;\n\
print2(quot);\n\
let half = p ./ 2.0;\n\
print2(half);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_array_broadcast_subdiv");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("array_broadcast_subdiv.bld");
std::fs::write(&path, src).expect("write array_broadcast_subdiv.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "9 18 27\n5 5\n5 10\n",
"`.-` must subtract elementwise, `./` divide elementwise, `./ 2.0` broadcast scalar-right"
);
}
#[test]
fn typed_array_kernel_signature_runs_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping typed-array kernel e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn axpy(a: f64, x: [f64; 3], y: [f64; 3]) -> [f64; 3] {\n\
let scaled = a .* x;\n\
scaled .+ y\n\
}\n\
fn main() ~ Console {\n\
let x = [1.0, 2.0, 3.0];\n\
let y = [10.0, 20.0, 30.0];\n\
let r = axpy(2.0, x, y);\n\
println(\"{} {} {}\", r[0], r[1], r[2]);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_typed_array_kernel");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("typed_array_kernel.bld");
std::fs::write(&path, src).expect("write typed_array_kernel.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "12 24 36\n",
"axpy(2, [1,2,3], [10,20,30]) must broadcast through a `[f64; 3]` signature: 2*1+10, 2*2+20, 2*3+30"
);
}
#[test]
fn typed_array_kernel_arg_length_mismatch_is_rejected() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_typed_array_arg_mismatch_{}.bld",
std::process::id()
));
fs::write(
&fixture,
"fn scale(x: [f64; 3]) -> [f64; 3] {\n\
x .* 2.0\n\
}\n\
fn main() ~ Console {\n\
let wide = [1.0, 2.0, 3.0, 4.0];\n\
let r = scale(wide);\n\
println(\"{}\", r[0]);\n\
}\n",
)
.expect("write typed-array arg-mismatch fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"passing a `[f64; 4]` where a `[f64; 3]` parameter is declared must fail buildc check"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.to_lowercase().contains("length"),
"diagnostic should name the array length mismatch at the call site:\n{}",
stderr
);
assert!(
!stderr.to_lowercase().contains("panic"),
"shape mismatch must be a compile-time diagnostic, never a runtime panic:\n{}",
stderr
);
}
#[test]
fn typed_array_kernel_return_length_mismatch_is_rejected() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_typed_array_ret_mismatch_{}.bld",
std::process::id()
));
fs::write(
&fixture,
"fn widen(x: [f64; 3]) -> [f64; 2] {\n\
x .+ 1.0\n\
}\n\
fn main() ~ Console {\n\
let r = widen([1.0, 2.0, 3.0]);\n\
println(\"{}\", r[0]);\n\
}\n",
)
.expect("write typed-array return-mismatch fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"returning a `[f64; 3]` body from a `-> [f64; 2]` signature must fail buildc check"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("[f64; 3]") && stderr.contains("[f64; 2]"),
"diagnostic should name both the produced `[f64; 3]` and expected `[f64; 2]` shapes:\n{}",
stderr
);
}
#[test]
fn println_varying_placeholder_counts_run_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping println-arity e2e: no C backend available (buildc doctor)");
return;
}
let src = "fn main() ~ Console {\n\
let a = 1;\n\
let b = 2;\n\
let c = 3;\n\
println(\"{} {} {}\", a, b, c);\n\
println(\"{} {}\", a, b);\n\
println(\"{}\", c);\n\
}\n";
let dir = std::env::temp_dir().join("buildlang_println_arity");
std::fs::create_dir_all(&dir).expect("create temp dir");
let path = dir.join("println_arity.bld");
std::fs::write(&path, src).expect("write println_arity.bld");
let result = c_backend_run(&path);
assert_eq!(
result.stdout, "1 2 3\n1 2\n3\n",
"function-style println must accept any placeholder count across one function body"
);
}
#[test]
fn local_module_self_recursive_fn_no_false_ambiguity() {
if !c_backend_ready() {
eprintln!("skipping local-module self-recursion e2e: no C backend available");
return;
}
let dir = std::env::temp_dir().join("buildlang_local_mod_selfrec");
std::fs::create_dir_all(&dir).expect("create temp dir");
std::fs::write(
dir.join("helper.bld"),
"fn fact(n: i32) -> i32 { if n <= 1 { 1 } else { n * fact(n - 1) } }\n",
)
.expect("write helper.bld");
let main_path = dir.join("main.bld");
std::fs::write(
&main_path,
"mod helper;\nfn main() ~ Console { let x = fact(5); println(\"{}\", x); }\n",
)
.expect("write main.bld");
let result = c_backend_run(&main_path);
assert_eq!(
result.stdout, "120\n",
"a self-recursive fn in a local module must not be a false dispatch ambiguity"
);
}
#[test]
fn imported_module_fn_resolves_inside_loop_body() {
if !c_backend_ready() {
eprintln!("skipping imported-fn-in-loop e2e: no C backend available");
return;
}
let dir = std::env::temp_dir().join("buildlang_imported_fn_in_loop");
std::fs::create_dir_all(&dir).expect("create temp dir");
std::fs::write(
dir.join("helper.bld"),
"fn square(n: i32) -> i32 { n * n }\n",
)
.expect("write helper.bld");
let main_path = dir.join("main.bld");
std::fs::write(
&main_path,
"mod helper;\nfn main() ~ Console {\n \
let mut i: i32 = 1;\n let mut acc: i32 = 0;\n \
while i <= 3 {\n acc = acc + square(i);\n i = i + 1;\n }\n \
println(\"{}\", acc);\n}\n",
)
.expect("write main.bld");
let result = c_backend_run(&main_path);
assert_eq!(
result.stdout, "14\n",
"an imported module fn must resolve when called inside a loop body"
);
}
#[test]
fn shadowing_fn_pointer_param_is_not_rewritten_to_module_fn() {
if !c_backend_ready() {
eprintln!("skipping shadow-rewrite e2e: no C backend available");
return;
}
let dir = std::env::temp_dir().join("buildlang_shadow_fn_ptr_param");
std::fs::create_dir_all(&dir).expect("create temp dir");
std::fs::write(
dir.join("helper.bld"),
"pub fn square(x: i32) -> i32 { x * x }\n",
)
.expect("write helper.bld");
let main_path = dir.join("main.bld");
std::fs::write(
&main_path,
"mod helper;\n\
fn triple(x: i32) -> i32 { x + x + x }\n\
fn run(square: fn(i32) -> i32, x: i32) -> i32 {\n \
let mut acc = x;\n let mut i = 0;\n \
while i < 2 {\n acc = square(acc);\n i = i + 1;\n }\n \
acc\n}\n\
fn main() ~ Console {\n println(\"{}\", run(triple, 2));\n}\n",
)
.expect("write main.bld");
let result = c_backend_run(&main_path);
assert_eq!(
result.stdout, "18\n",
"a fn-pointer parameter shadowing an imported fn must call the parameter, not the module fn"
);
}
#[test]
fn array_broadcast_nonnumeric_element_is_rejected() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_array_broadcast_nonnumeric_{}.bld",
std::process::id()
));
fs::write(
&fixture,
"fn main() ~ Console {\n\
let a = [\"a\", \"b\"];\n\
let b = [\"c\", \"d\"];\n\
let c = a .+ b;\n\
println(\"{}\", c[0]);\n\
}\n",
)
.expect("write array-broadcast non-numeric fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"broadcasting non-numeric (string) element arrays must fail buildc check"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
!stderr.contains("C2088") && !stderr.to_lowercase().contains("c compilation"),
"rejection must be a clean type diagnostic, not a leaked C compiler error:\n{}",
stderr
);
}
#[test]
fn transpile_preservation_c_and_rust_backends_agree_on_stdout() {
if !c_backend_ready() {
eprintln!(
"skipping transpile-preservation cross-check: no C backend available (buildc doctor)"
);
return;
}
if !rustc_available() {
eprintln!("skipping transpile-preservation cross-check: rustc not available");
return;
}
let corpus = load_preservation_corpus();
let mut cross_checked = 0usize;
for program in &corpus.programs {
if !program
.rust_execution_test
.starts_with("generated_rust_runs_for_")
{
continue;
}
let program_path = semantic_corpus_root().join(&program.path);
let source = fs::read_to_string(&program_path)
.unwrap_or_else(|err| panic!("read corpus program {}: {}", program.id, err));
let c_result = c_backend_run(&program_path);
let rust_source = lower_source_to_rust(&source);
let rust_result = rustc_compile_and_run(&program.id, &rust_source);
assert_eq!(
c_result.stdout, rust_result.stdout,
"transpile-preservation DIVERGENCE for {}: C and Rust backends disagree on stdout\n\
C stdout: {:?}\n\
Rust stdout: {:?}",
program.id, c_result.stdout, rust_result.stdout
);
assert_eq!(
c_result.exit_code, rust_result.exit_code,
"transpile-preservation DIVERGENCE for {}: C and Rust backends disagree on exit status\n\
C exit: {:?}\n\
Rust exit: {:?}",
program.id, c_result.exit_code, rust_result.exit_code
);
cross_checked += 1;
}
assert!(
cross_checked > 0,
"transpile-preservation harness cross-checked zero programs; \
the Rust-supported corpus subset should be non-empty"
);
eprintln!(
"transpile-preservation: C and Rust backends agree on stdout + exit status \
for {cross_checked} corpus program(s)"
);
}
#[test]
fn rust_backend_lowers_float_and_int_println_end_to_end() {
if !rustc_available() {
eprintln!("skipping rust-backend numeric-print control: rustc not available");
return;
}
let source = r#"
fn main() ~ Console {
let n: i32 = 1234567;
let whole: f64 = 2.0;
let tenth: f64 = 0.1;
let sum: f64 = 0.1 + 0.2;
println!("{}", n);
println!("{}", whole);
println!("{}", tenth);
println!("{}", sum);
}
"#;
let rust_source = lower_source_to_rust(source);
let result = rustc_compile_and_run("rust_numeric_println", &rust_source);
assert_eq!(
result.stdout, "1234567\n2\n0.1\n0.30000000000000004\n",
"Rust backend must define build_f64_to_string and project `.ptr` off a \
runtime string so float printing compiles and round-trips"
);
assert_eq!(result.exit_code, Some(0), "generated program must exit 0");
}
fn write_dispatch_fixture(label: &str, src: &str) -> PathBuf {
let path = std::env::temp_dir().join(format!(
"buildlang_dispatch_{}_{}.bld",
label,
std::process::id()
));
fs::write(&path, src).unwrap_or_else(|e| panic!("write dispatch fixture {label}: {e}"));
path
}
#[test]
fn dispatch_selects_overload_by_argument_type_tuple() {
if !c_backend_ready() {
eprintln!("skipping multiple-dispatch run test because no C backend is available");
return;
}
let src = r#"
fn add(a: i32, b: i32) -> i32 { a + b }
fn add(a: f64, b: f64) -> f64 { a * b }
fn combo(a: i32, b: i32) -> i32 { a + b }
fn combo(a: i32, b: f64) -> i32 { a * 100 }
fn main() ~ Console {
let w: i32 = add(3, 5);
let x: f64 = add(2.5, 4.0);
let y: i32 = combo(7, 9);
let z: i32 = combo(7, 9.0);
println!("{}", w);
println!("{}", x);
println!("{}", y);
println!("{}", z);
}
"#;
let fixture = write_dispatch_fixture("run_select", src);
let output = buildc()
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run on dispatch fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"dispatch program should run successfully\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
let want = "8\n10\n16\n700\n";
assert!(
stdout.contains(want),
"dispatch stdout should show each overload's result; want to contain {want:?}, got:\n{}",
stdout
);
}
#[test]
fn dispatch_reports_no_matching_method() {
let src = r#"
fn add(a: i32, b: i32) -> i32 { a + b }
fn add(a: f64, b: f64) -> f64 { a * b }
fn main() {
let s: str = "x";
add(s, s);
}
"#;
let fixture = write_dispatch_fixture("no_match", src);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check on no-match fixture");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"a call with no matching overload should fail type checking"
);
let combined = format!(
"{}{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(
combined.contains("no method `add` matches"),
"check should report NoMatchingMethod:\n{}",
combined
);
}
#[test]
fn dispatch_reports_ambiguous_method() {
let src = r#"
fn add<T>(a: i32, b: T) -> i32 { a }
fn add<T>(a: T, b: i32) -> i32 { b }
fn main() {
add(1, 2);
}
"#;
let fixture = write_dispatch_fixture("ambiguous", src);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check on ambiguous fixture");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"an equally-specific overload pair should fail type checking as ambiguous"
);
let combined = format!(
"{}{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(
combined.contains("is ambiguous"),
"check should report AmbiguousMethod:\n{}",
combined
);
}
#[test]
fn dispatch_single_definition_names_are_unaffected() {
let src = r#"
fn double(x: i32) -> i32 { x * 2 }
fn main() ~ Console {
println!("{}", double(21));
}
"#;
let fixture = write_dispatch_fixture("single_def", src);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check on single-def fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"a non-overloaded program should check cleanly\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn dispatch_generic_and_concrete_overload_compose() {
if !c_backend_ready() {
eprintln!("skipping generic+concrete dispatch run test: no C backend available");
return;
}
let src = r#"
fn h<T>(a: T) -> T { a }
fn h(a: i32) -> i32 { a }
fn main() ~ Console {
let x: i32 = h(3);
let y: str = h("hello");
println!("{}", x);
println!("{}", y);
}
"#;
let fixture = write_dispatch_fixture("generic_concrete", src);
let output = buildc()
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run on generic+concrete dispatch fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"generic+concrete overload program should compile and run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("3\n") && stdout.contains("hello"),
"each call should select the correct overload (concrete `3`, generic `hello`); got:\n{}",
stdout
);
}
#[test]
fn dispatch_generic_only_call_still_monomorphizes() {
if !c_backend_ready() {
eprintln!("skipping generic-only dispatch run test: no C backend available");
return;
}
let src = r#"
fn identity<T>(a: T) -> T { a }
fn main() ~ Console {
let x: i32 = identity(42);
let z: i32 = identity(7);
println!("{}", x);
println!("{}", z);
}
"#;
let fixture = write_dispatch_fixture("generic_only", src);
let output = buildc()
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run on generic-only fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"generic-only program should compile and run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert!(
stdout.contains("42\n") && stdout.contains("7\n"),
"generic-only monomorphization should print both results; got:\n{}",
stdout
);
}
#[test]
fn linalg_module_runs_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping linalg module e2e test because no C backend is available");
return;
}
let src = r#"
mod core;
mod math;
mod linalg;
fn main() ~ Console {
let mut a = vec_new_f64();
vec_push_f64(a, 1.0);
vec_push_f64(a, 2.0);
vec_push_f64(a, 3.0);
let mut b = vec_new_f64();
vec_push_f64(b, 4.0);
vec_push_f64(b, 5.0);
vec_push_f64(b, 6.0);
let dot = vec_dot(a, b);
let sum = vec_sum(a);
let mut c = vec_new_f64();
vec_push_f64(c, 3.0);
vec_push_f64(c, 4.0);
let norm = vec_norm(c);
println!("{}", dot);
println!("{}", sum);
println!("{}", norm);
}
"#;
let fixture = write_dispatch_fixture("linalg_module", src);
let output = buildc()
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run on linalg module fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"linalg module program should compile and run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert_eq!(
stdout, "32\n6\n5\n",
"linalg dot/sum/norm should print 32, 6, 5; got:\n{}",
stdout
);
}
#[test]
fn linalg_elementwise_and_scalar_builders_run_end_to_end() {
if !c_backend_ready() {
eprintln!("skipping linalg elementwise/scalar builders e2e: no C backend available");
return;
}
let src = r#"
mod core;
mod math;
mod linalg;
fn main() ~ Console {
let mut a = vec_new_f64();
vec_push_f64(a, 1.0);
vec_push_f64(a, 2.0);
let mut b = vec_new_f64();
vec_push_f64(b, 3.0);
vec_push_f64(b, 4.0);
let sum = vec_add(a, b);
let sum0 = vec_get_f64(sum, 0);
let sum1 = vec_get_f64(sum, 1);
let scaled = vec_scale(a, 10.0);
let scaled0 = vec_get_f64(scaled, 0);
let scaled1 = vec_get_f64(scaled, 1);
println!("{} {}", sum0, sum1);
println!("{} {}", scaled0, scaled1);
}
"#;
let fixture = write_dispatch_fixture("linalg_builders", src);
let output = buildc()
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run on linalg builders fixture");
let _ = fs::remove_file(&fixture);
assert!(
output.status.success(),
"linalg elementwise/scalar builders should compile and run\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
let stdout = String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n");
assert_eq!(
stdout, "4 6\n10 20\n",
"linalg vec_add/vec_scale should print `4 6` then `10 20`; got:\n{}",
stdout
);
}
fn repo_example(name: &str) -> PathBuf {
repo_root().join("examples").join(name)
}
#[test]
fn conservation_invariant_round_trips_positive_and_negative() {
if !c_backend_ready() {
eprintln!("skipping conservation_invariant_round_trips_positive_and_negative: C backend not ready");
return;
}
let dir =
std::env::temp_dir().join(format!("buildlang_sci_conservation_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create conservation fixture dir");
let pass_receipt = dir.join("rotation.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("conservation_rotation.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"conservation",
"--metric",
"r2",
"--problem",
"rotational-radius",
])
.output()
.expect("emit conservation PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the conservation PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "conserved_quantity_constant");
assert_eq!(pass["oracle"]["name"], "conserved_quantity_constant");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify conservation PASS receipt");
assert!(
verify_pass.status.success(),
"the conservation PASS receipt must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stdout),
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("decay.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("conservation_decay.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"conservation",
"--negative-fixture",
"--metric",
"q",
"--problem",
"leak",
])
.output()
.expect("emit conservation negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify conservation negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn bounded_invariant_round_trips_positive_negative_and_is_distinct() {
if !c_backend_ready() {
eprintln!(
"skipping bounded_invariant_round_trips_positive_negative_and_is_distinct: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_bounded_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create bounded fixture dir");
let pass_receipt = dir.join("oscillation.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("bounded_oscillation.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"bounded",
"--metric",
"x2",
"--problem",
"undamped-oscillator",
])
.output()
.expect("emit bounded PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the bounded PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "bounded_by_initial_maximum");
assert_eq!(pass["oracle"]["name"], "bounded_by_initial_maximum");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify bounded PASS receipt");
assert!(
verify_pass.status.success(),
"the bounded PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let mono_receipt = dir.join("oscillation_mono.json");
let emit_mono = buildc()
.arg("run")
.arg(repo_example("bounded_oscillation.bld"))
.args(["--emit-receipt"])
.arg(&mono_receipt)
.args([
"--invariant",
"energy-monotone",
"--metric",
"x2",
"--problem",
"undamped-oscillator",
])
.output()
.expect("emit monotone receipt from the oscillation kernel");
assert!(emit_mono.status.success());
let mono: serde_json::Value =
serde_json::from_slice(&fs::read(&mono_receipt).expect("read monotone receipt")).unwrap();
assert_eq!(
mono["receipt_status"], "FAIL_UNEXPECTED",
"the oscillation that PASSES bounded must FAIL monotone"
);
let fail_receipt = dir.join("overshoot.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("bounded_overshoot.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"bounded",
"--negative-fixture",
"--metric",
"energy",
"--problem",
"explicit-euler-oscillator",
])
.output()
.expect("emit bounded negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify bounded negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn energy_identity_invariant_round_trips_positive_and_negative() {
if !c_backend_ready() {
eprintln!(
"skipping energy_identity_invariant_round_trips_positive_and_negative: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_energy_identity_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create energy-identity fixture dir");
let pass_receipt = dir.join("balance.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("energy_identity.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"energy-identity",
"--metric",
"residual",
"--problem",
"heat-energy-balance",
])
.output()
.expect("emit energy-identity PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the energy-identity PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "energy_identity_residual");
assert_eq!(pass["oracle"]["name"], "energy_identity_residual");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify energy-identity PASS receipt");
assert!(
verify_pass.status.success(),
"the energy-identity PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("energy_identity_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"energy-identity",
"--negative-fixture",
"--metric",
"residual",
"--problem",
"broken-balance",
])
.output()
.expect("emit energy-identity negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert_eq!(fail["invariant"]["observed"]["first_violation_step"], 0);
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify energy-identity negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn relation_invariant_round_trips_positive_negative_and_validates_columns() {
if !c_backend_ready() {
eprintln!(
"skipping relation_invariant_round_trips_positive_negative_and_validates_columns: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_relation_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create relation fixture dir");
let pass_receipt = dir.join("double_angle.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("relation_double_angle.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"relation",
"--columns",
"2",
"--metric",
"sin2t",
"--problem",
"double-angle",
])
.output()
.expect("emit relation PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the relation PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "relation_columns_agree");
assert_eq!(pass["oracle"]["name"], "relation_columns_agree");
assert_eq!(pass["measurement"]["column_count"], 2);
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify relation PASS receipt");
assert!(
verify_pass.status.success(),
"the relation PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("relation_double_angle_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"relation",
"--columns",
"2",
"--negative-fixture",
"--metric",
"sin2t",
"--problem",
"broken",
])
.output()
.expect("emit relation negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify relation negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let bad = buildc()
.arg("run")
.arg(repo_example("relation_double_angle.bld"))
.args(["--emit-receipt"])
.arg(dir.join("bad.json"))
.args(["--invariant", "relation"])
.output()
.expect("emit relation without columns");
assert!(
!bad.status.success(),
"relation without --columns >= 2 must be rejected"
);
assert!(String::from_utf8_lossy(&bad.stderr).contains("--columns >= 2"));
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn reaction_atom_balance_round_trips_positive_and_negative() {
if !c_backend_ready() {
eprintln!(
"skipping reaction_atom_balance_round_trips_positive_and_negative: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_reaction_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create reaction fixture dir");
let pass_receipt = dir.join("reaction.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("reaction_atom_balance.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"conservation",
"--metric",
"atom-balance",
"--problem",
"reaction-A-B-C",
])
.output()
.expect("emit reaction PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the reaction PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "conserved_quantity_constant");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify reaction PASS receipt");
assert!(
verify_pass.status.success(),
"the reaction PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("reaction_broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("reaction_atom_balance_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"conservation",
"--negative-fixture",
"--metric",
"atom-balance",
"--problem",
"reaction-broken",
])
.output()
.expect("emit reaction negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify reaction negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn non_negative_invariant_round_trips_a_result_bearing_bound() {
if !c_backend_ready() {
eprintln!("skipping non_negative_invariant_round_trips_a_result_bearing_bound: C backend not ready");
return;
}
let dir =
std::env::temp_dir().join(format!("buildlang_sci_non_negative_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create non-negative fixture dir");
let pass_receipt = dir.join("binary.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("search_bound_binary.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"binary-search-probe-bound",
])
.output()
.expect("emit non-negative PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the non-negative PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "non_negative");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify non-negative PASS receipt");
assert!(
verify_pass.status.success(),
"the non-negative PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("linear.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("search_bound_linear.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"non-negative",
"--negative-fixture",
"--metric",
"slack",
"--problem",
"linear-search-probe-bound",
])
.output()
.expect("emit non-negative negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify non-negative negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn born_rule_normalization_round_trips_conservation() {
if !c_backend_ready() {
eprintln!("skipping born_rule_normalization_round_trips_conservation: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_born_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create born-rule fixture dir");
let pass_receipt = dir.join("unitary.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("born_rule_normalization.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"conservation",
"--problem",
"born-rule-normalization",
])
.output()
.expect("emit born-rule PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the born-rule PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "conserved_quantity_constant");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify born-rule PASS receipt");
assert!(
verify_pass.status.success(),
"the born-rule PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("leaky.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("born_rule_leaky.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"conservation",
"--negative-fixture",
"--problem",
"born-rule-leaky",
])
.output()
.expect("emit born-rule negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify born-rule negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn funnel_hashing_round_trips_a_probe_bound() {
if !c_backend_ready() {
eprintln!("skipping funnel_hashing_round_trips_a_probe_bound: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_funnel_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create funnel fixture dir");
let pass_receipt = dir.join("funnel.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("funnel_probe.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"funnel-hashing-probe-bound",
])
.output()
.expect("emit funnel PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the funnel PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "non_negative");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify funnel PASS receipt");
assert!(
verify_pass.status.success(),
"the funnel PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("linear.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("funnel_probe_linear.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"non-negative",
"--negative-fixture",
"--metric",
"slack",
"--problem",
"linear-probing-probe-bound",
])
.output()
.expect("emit funnel negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify funnel negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn seeded_random_walk_round_trips_and_pins_the_seed_contract() {
if !c_backend_ready() {
eprintln!("skipping seeded_random_walk_round_trips_and_pins_the_seed_contract: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_random_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create random fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("random_walk_bound.bld"))
.args(["--emit-receipt"])
.arg(dir.join("no-seed.json"))
.args(["--invariant", "non-negative"])
.output()
.expect("run seedless random kernel");
assert!(
!refused.status.success(),
"a Random-using kernel with no --seed must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("requires an explicit seed"),
"the refusal must name the missing seed\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let unconsumed = buildc()
.arg("run")
.arg(repo_example("search_bound_binary.bld"))
.args(["--emit-receipt"])
.arg(dir.join("unconsumed.json"))
.args(["--invariant", "non-negative", "--seed", "7"])
.output()
.expect("run seedless program with a seed");
assert!(
!unconsumed.status.success(),
"a seed on a program with no Random capability must be refused"
);
assert!(
String::from_utf8_lossy(&unconsumed.stderr).contains("no Random capability"),
"the refusal must name the unconsumed seed\nstderr:\n{}",
String::from_utf8_lossy(&unconsumed.stderr)
);
let emit = |source: &str, receipt: &std::path::Path, seed: &str, negative: bool| {
let mut cmd = buildc();
cmd.arg("run")
.arg(repo_example(source))
.args(["--emit-receipt"])
.arg(receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"seeded-random-walk-envelope",
"--seed",
seed,
]);
if negative {
cmd.arg("--negative-fixture");
}
cmd.output().expect("emit seeded receipt")
};
let pass_receipt = dir.join("walk.json");
let emit_pass = emit("random_walk_bound.bld", &pass_receipt, "42", false);
assert!(
emit_pass.status.success(),
"emitting the seeded PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["seed_value"], 42);
assert_eq!(pass["seed"]["status"], "SEALED");
assert!(
pass["effect_policy"]["observed_capabilities"]
.as_array()
.unwrap()
.iter()
.any(|c| c == "Random"),
"the effect policy must observe the Random capability"
);
assert_eq!(pass["determinism"]["deterministic_modulo_args"], true);
assert!(
pass["determinism"]["grounds"]
.as_str()
.unwrap()
.contains("seeded"),
"determinism grounds must name the seeded qualification"
);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify seeded PASS receipt");
assert!(
verify_pass.status.success(),
"the seeded PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let again_receipt = dir.join("walk-again.json");
let other_receipt = dir.join("walk-other.json");
assert!(emit("random_walk_bound.bld", &again_receipt, "42", false)
.status
.success());
assert!(emit("random_walk_bound.bld", &other_receipt, "43", false)
.status
.success());
let digest = |path: &std::path::Path| -> String {
let v: serde_json::Value = serde_json::from_slice(&fs::read(path).unwrap()).unwrap();
v["measurement"]["raw_stdout_digest"]["hex"]
.as_str()
.unwrap()
.to_string()
};
assert_eq!(
digest(&pass_receipt),
digest(&again_receipt),
"the same seed must reproduce the stream byte-for-byte"
);
assert_ne!(
digest(&pass_receipt),
digest(&other_receipt),
"a different seed must produce a different stream"
);
let fail_receipt = dir.join("walk-broken.json");
let emit_fail = emit("random_walk_bound_broken.bld", &fail_receipt, "42", true);
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_fail.stderr)
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify seeded negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn monte_carlo_declaration_round_trips_and_pins_the_admission_contract() {
if !c_backend_ready() {
eprintln!("skipping monte_carlo_declaration_round_trips_and_pins_the_admission_contract: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_mc_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create mc fixture dir");
let mc_flags = [
"--mc-estimator",
"mean",
"--mc-samples",
"2000",
"--mc-interval",
"normal-approx-95",
];
let pass_receipt = dir.join("mcpi.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"mc-pi-rejection",
"--seed",
"42",
])
.args(mc_flags)
.output()
.expect("emit mc PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the mc PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["monte_carlo"]["estimator"], "mean");
assert_eq!(pass["monte_carlo"]["samples"], 2000);
assert_eq!(pass["monte_carlo"]["interval_method"], "normal-approx-95");
assert_eq!(pass["monte_carlo"]["status"], "DECLARED");
assert_eq!(pass["seed_value"], 42);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify mc PASS receipt");
assert!(
verify_pass.status.success(),
"the mc PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("mcpi-broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"non-negative",
"--negative-fixture",
"--metric",
"slack",
"--problem",
"mc-pi-rejection",
"--seed",
"42",
])
.args(mc_flags)
.output()
.expect("emit mc negative fixture");
assert!(
emit_fail.status.success(),
"emitting the mc negative fixture should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_fail.stderr)
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify mc negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
for partial in [
&["--mc-estimator", "mean", "--mc-samples", "2000"][..],
&[
"--mc-estimator",
"mean",
"--mc-interval",
"normal-approx-95",
][..],
&["--mc-samples", "2000", "--mc-interval", "normal-approx-95"][..],
&["--mc-estimator", "mean"][..],
] {
let refused = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection.bld"))
.args(["--emit-receipt"])
.arg(dir.join("partial.json"))
.args(["--invariant", "non-negative", "--seed", "42"])
.args(partial)
.output()
.expect("run partial mc declaration");
assert!(
!refused.status.success(),
"a partial mc declaration must be refused: {partial:?}"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("together"),
"the refusal must name the all-or-nothing contract\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
}
let zero = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection.bld"))
.args(["--emit-receipt"])
.arg(dir.join("zero.json"))
.args([
"--invariant",
"non-negative",
"--seed",
"42",
"--mc-estimator",
"mean",
"--mc-samples",
"0",
"--mc-interval",
"normal-approx-95",
])
.output()
.expect("run zero-sample mc declaration");
assert!(
!zero.status.success(),
"a zero mc denominator must be refused"
);
assert!(
String::from_utf8_lossy(&zero.stderr).contains("unpriceable"),
"the refusal must name the unpriceable denominator\nstderr:\n{}",
String::from_utf8_lossy(&zero.stderr)
);
let unbacked = buildc()
.arg("run")
.arg(repo_example("search_bound_binary.bld"))
.args(["--emit-receipt"])
.arg(dir.join("unbacked.json"))
.args(["--invariant", "non-negative"])
.args(mc_flags)
.output()
.expect("run mc declaration on a seedless program");
assert!(
!unbacked.status.success(),
"an mc declaration on a non-Random program must be refused"
);
assert!(
String::from_utf8_lossy(&unbacked.stderr).contains("no Random capability"),
"the refusal must name the missing capability\nstderr:\n{}",
String::from_utf8_lossy(&unbacked.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_pi_rejection_executed_round_trip_and_negative_fixture() {
if !c_backend_ready() {
eprintln!(
"skipping mc_pi_rejection_executed_round_trip_and_negative_fixture: C backend not ready"
);
return;
}
let dir =
std::env::temp_dir().join(format!("buildlang_sci_mc_executed_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create mc-executed fixture dir");
let mc_executed_flags = [
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"wilson-95",
];
let pass_receipt = dir.join("mcpi_executed.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_executed.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"mc-pi-rejection-executed",
"--seed",
"42",
])
.args(mc_executed_flags)
.output()
.expect("emit mc-executed PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the mc-executed PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["monte_carlo"]["status"], "EXECUTED");
assert_eq!(pass["monte_carlo"]["n_effective"], 2000);
let successes = pass["monte_carlo"]["successes"]
.as_u64()
.expect("successes must be present");
assert!(successes <= 2000);
let estimate = pass["monte_carlo"]["estimate"].as_f64().unwrap();
let low = pass["monte_carlo"]["interval_low"].as_f64().unwrap();
let high = pass["monte_carlo"]["interval_high"].as_f64().unwrap();
assert!(
low < estimate && estimate < high,
"interval_low < estimate < interval_high must hold: {low} < {estimate} < {high}"
);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify mc-executed PASS receipt");
assert!(
verify_pass.status.success(),
"the mc-executed PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("mcpi_executed_broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_executed_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"non-negative",
"--negative-fixture",
"--metric",
"slack",
"--problem",
"mc-pi-rejection-executed",
"--seed",
"42",
])
.args(mc_executed_flags)
.output()
.expect("emit mc-executed negative fixture");
assert!(
emit_fail.status.success(),
"emitting the mc-executed negative fixture should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_fail.stderr)
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert_eq!(
fail["monte_carlo"]["status"], "EXECUTED",
"the wrong-area estimator still yields a coherent, re-deriving EXECUTED interval"
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify mc-executed negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_without_full_declaration_is_refused() {
if !c_backend_ready() {
eprintln!("skipping mc_executed_without_full_declaration_is_refused: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_partial_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_executed.bld"))
.args(["--emit-receipt"])
.arg(dir.join("partial.json"))
.args([
"--invariant",
"non-negative",
"--seed",
"42",
"--mc-executed",
])
.output()
.expect("run --mc-executed with no other mc flags");
assert!(
!refused.status.success(),
"--mc-executed alone must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr)
.contains("requires the full Monte Carlo declaration"),
"the refusal must name the all-or-nothing contract\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_clopper_pearson_is_refused() {
if !c_backend_ready() {
eprintln!("skipping mc_executed_clopper_pearson_is_refused: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_clopper_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_executed.bld"))
.args(["--emit-receipt"])
.arg(dir.join("clopper.json"))
.args(["--invariant", "non-negative", "--seed", "42"])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"clopper-pearson-95",
])
.output()
.expect("run --mc-executed with clopper-pearson-95");
assert!(
!refused.status.success(),
"clopper-pearson-95 must be refused (not executable in v1)"
);
let stderr = String::from_utf8_lossy(&refused.stderr);
assert!(
stderr.contains("not in the EXECUTED executable vocabulary")
|| stderr.contains("inverse incomplete beta"),
"the refusal must name the unexecutable method\nstderr:\n{}",
stderr
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_declared_samples_mismatching_witnessed_trials_is_refused() {
if !c_backend_ready() {
eprintln!(
"skipping mc_executed_declared_samples_mismatching_witnessed_trials_is_refused: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_denominator_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let src = "fn main() ~ Console + Random {\n\
let n: i32 = 5;\n\
let mut inside: i32 = 0;\n\
let mut k: i32 = 0;\n\
while k < n {\n\
let x: f64 = random_f64();\n\
if x < 0.5 { inside = inside + 1; }\n\
k = k + 1;\n\
println!(\"{} {} {}\", 1.0, inside, k);\n\
}\n\
}\n";
let path = dir.join("mc_five_rows.bld");
fs::write(&path, src).expect("write mc_five_rows.bld");
let refused = buildc()
.arg("run")
.arg(&path)
.args(["--emit-receipt"])
.arg(dir.join("mismatch.json"))
.args(["--invariant", "non-negative", "--seed", "42"])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"wilson-95",
])
.output()
.expect("run --mc-executed on a kernel with fewer draws than declared");
assert!(
!refused.status.success(),
"a witnessed/declared denominator mismatch must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("does not equal the declared samples"),
"the refusal must name the denominator mismatch\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_incoherent_successes_jump_is_refused() {
if !c_backend_ready() {
eprintln!("skipping mc_executed_incoherent_successes_jump_is_refused: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_jump_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let src = "fn main() ~ Console + Random {\n\
let mut k: i32 = 0;\n\
while k < 3 {\n\
let x: f64 = random_f64();\n\
let _unused: f64 = x;\n\
k = k + 1;\n\
let mut succ: i32 = 0;\n\
if k >= 2 { succ = k; }\n\
println!(\"{} {} {}\", 1.0, succ, k);\n\
}\n\
}\n";
let path = dir.join("mc_jump.bld");
fs::write(&path, src).expect("write mc_jump.bld");
let refused = buildc()
.arg("run")
.arg(&path)
.args(["--emit-receipt"])
.arg(dir.join("jump.json"))
.args(["--invariant", "non-negative", "--seed", "42"])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"3",
"--mc-interval",
"wilson-95",
])
.output()
.expect("run --mc-executed on a kernel with an incoherent successes jump");
assert!(
!refused.status.success(),
"a successes column jumping by 2 must be refused"
);
let stderr = String::from_utf8_lossy(&refused.stderr);
assert!(
stderr.contains("does not follow") && stderr.contains("by 0 or 1"),
"the refusal must name the incoherent jump\nstderr:\n{}",
stderr
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_explicit_columns_other_than_three_is_refused() {
if !c_backend_ready() {
eprintln!(
"skipping mc_executed_explicit_columns_other_than_three_is_refused: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_columns_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection_executed.bld"))
.args(["--emit-receipt"])
.arg(dir.join("columns.json"))
.args([
"--invariant",
"non-negative",
"--seed",
"42",
"--columns",
"2",
])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"wilson-95",
])
.output()
.expect("run --mc-executed with an explicit --columns 2");
assert!(
!refused.status.success(),
"an explicit --columns other than 3 must be refused under --mc-executed"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("needs --columns 3"),
"the refusal must name the required column count\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_normal_approx_degenerate_boundary_is_refused() {
if !c_backend_ready() {
eprintln!(
"skipping mc_executed_normal_approx_degenerate_boundary_is_refused: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_degenerate_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let src = "fn main() ~ Console + Random {\n\
let n: i32 = 5;\n\
let mut k: i32 = 0;\n\
while k < n {\n\
let x: f64 = random_f64();\n\
let _unused: f64 = x;\n\
k = k + 1;\n\
println!(\"{} {} {}\", 1.0, k, k);\n\
}\n\
}\n";
let path = dir.join("mc_always_succeeds.bld");
fs::write(&path, src).expect("write mc_always_succeeds.bld");
let refused = buildc()
.arg("run")
.arg(&path)
.args(["--emit-receipt"])
.arg(dir.join("degenerate.json"))
.args(["--invariant", "non-negative", "--seed", "42"])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"5",
"--mc-interval",
"normal-approx-95",
])
.output()
.expect("run --mc-executed on a boundary-proportion kernel with normal-approx-95");
assert!(
!refused.status.success(),
"a boundary proportion under normal-approx-95 must be refused"
);
let stderr = String::from_utf8_lossy(&refused.stderr);
assert!(
stderr.contains("degenerate") && stderr.contains("wilson-95"),
"the refusal must name the degeneracy and point at wilson-95\nstderr:\n{}",
stderr
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_refused_with_gpu() {
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_gpu_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args([
"--gpu",
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"wilson-95",
])
.output()
.expect("run --gpu --mc-executed together");
assert!(
!refused.status.success(),
"--gpu combined with --mc-executed must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr)
.contains("--mc-* flags are not supported with --gpu"),
"the refusal must name the gpu/mc composition\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn mc_executed_refused_with_cross_backend() {
if !c_backend_ready() {
eprintln!("skipping mc_executed_refused_with_cross_backend: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_mc_executed_refuse_cross_backend_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let refused = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("cb_mc_executed.json"))
.args(["--cross-backend", "rust", "--invariant", "cross-backend"])
.args([
"--mc-executed",
"--mc-estimator",
"proportion",
"--mc-samples",
"2000",
"--mc-interval",
"wilson-95",
])
.output()
.expect("run --cross-backend --mc-executed together");
assert!(
!refused.status.success(),
"--cross-backend combined with --mc-executed must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr)
.contains("--invariant cross-backend needs --columns 2"),
"the refusal must name the cross-backend column contract\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn budget_declaration_round_trips_and_pins_the_admission_contract() {
if !c_backend_ready() {
eprintln!("skipping budget_declaration_round_trips_and_pins_the_admission_contract: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_budget_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create budget fixture dir");
let budget_flags = ["--budget-steps", "60000", "--budget-consumed", "495"];
let pass_receipt = dir.join("greedy.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"greedy-change-budget",
])
.args(budget_flags)
.output()
.expect("emit budget PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the budget PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["budget"]["steps_limit"], 60000);
assert_eq!(pass["budget"]["steps_consumed"], 495);
assert_eq!(pass["budget"]["exhausted"], false);
assert_eq!(pass["budget"]["status"], "DECLARED");
assert!(pass["labels"]
.as_array()
.unwrap()
.iter()
.any(|l| l == "BEST_FOUND_WITHIN_BUDGET"));
assert!(pass["scope"]
.as_array()
.unwrap()
.iter()
.any(|c| c == "best_found_within_budget"));
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify budget PASS receipt");
assert!(
verify_pass.status.success(),
"the budget PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
let fail_receipt = dir.join("greedy-broken.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget_broken.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"non-negative",
"--negative-fixture",
"--metric",
"slack",
"--problem",
"greedy-change-budget",
])
.args(budget_flags)
.output()
.expect("emit budget negative fixture");
assert!(
emit_fail.status.success(),
"emitting the budget negative fixture should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_fail.stderr)
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify budget negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
for partial in [
&["--budget-steps", "60000"][..],
&["--budget-consumed", "495"][..],
] {
let refused = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("partial.json"))
.args(["--invariant", "non-negative"])
.args(partial)
.output()
.expect("run partial budget declaration");
assert!(
!refused.status.success(),
"a partial budget declaration must be refused: {partial:?}"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("together"),
"the refusal must name the all-or-nothing contract\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
}
let zero = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("zero.json"))
.args(["--invariant", "non-negative"])
.args(["--budget-steps", "0", "--budget-consumed", "0"])
.output()
.expect("run zero-ceiling budget declaration");
assert!(
!zero.status.success(),
"a zero budget ceiling must be refused"
);
assert!(
String::from_utf8_lossy(&zero.stderr).contains("ceiling"),
"the refusal must name the ceiling\nstderr:\n{}",
String::from_utf8_lossy(&zero.stderr)
);
let over = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("over.json"))
.args(["--invariant", "non-negative"])
.args(["--budget-steps", "10", "--budget-consumed", "11"])
.output()
.expect("run over-consumed budget declaration");
assert!(
!over.status.success(),
"a consumption above the ceiling must be refused"
);
assert!(
String::from_utf8_lossy(&over.stderr).contains("incoherent"),
"the refusal must name the incoherence\nstderr:\n{}",
String::from_utf8_lossy(&over.stderr)
);
let claims_optimal = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("optimal.json"))
.args(["--invariant", "non-negative"])
.args(budget_flags)
.args(["--problem", "greedy-optimal-change"])
.output()
.expect("run budget declaration with optimal-claiming problem text");
assert!(
!claims_optimal.status.success(),
"free text claiming optimality on a budgeted run must be refused"
);
assert!(
String::from_utf8_lossy(&claims_optimal.stderr)
.contains("cannot contain the word `optimal`"),
"the refusal must name the word it refuses\nstderr:\n{}",
String::from_utf8_lossy(&claims_optimal.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn wall_metering_seals_and_reports() {
if !c_backend_ready() {
eprintln!("skipping wall_metering_seals_and_reports: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_wall_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create wall-metering fixture dir");
let receipt_path = dir.join("greedy-wall.json");
let emit = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(&receipt_path)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"greedy-change-budget",
])
.args(["--budget-steps", "60000", "--budget-consumed", "495"])
.args(["--budget-wall-seconds", "300"])
.output()
.expect("emit wall-metering receipt");
assert!(
emit.status.success(),
"emitting the wall-metering receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit.stderr)
);
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read wall-metering receipt"))
.unwrap();
let wall_seconds = receipt["runtime_state"]["wall_seconds"]
.as_f64()
.expect("runtime_state.wall_seconds must be a number");
assert!(
wall_seconds.is_finite() && wall_seconds >= 0.0,
"runtime_state.wall_seconds must be a finite, non-negative number, got {wall_seconds}"
);
assert_eq!(receipt["budget"]["wall_seconds_limit"], 300.0);
assert_eq!(receipt["budget"]["wall_exceeded"], false);
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt_path)
.output()
.expect("verify wall-metering receipt");
assert!(
verify.status.success(),
"the wall-metering receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr)
);
assert!(
String::from_utf8_lossy(&verify.stdout).contains("wall_seconds"),
"verify stdout must mention wall_seconds\nstdout:\n{}",
String::from_utf8_lossy(&verify.stdout)
);
let unpaired = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("unpaired.json"))
.args(["--invariant", "non-negative"])
.args(["--budget-wall-seconds", "300"])
.output()
.expect("run wall ceiling without the steps pair");
assert!(
!unpaired.status.success(),
"--budget-wall-seconds without the steps pair must be refused"
);
assert!(
String::from_utf8_lossy(&unpaired.stderr).contains("budget declaration"),
"the refusal must name the missing budget declaration\nstderr:\n{}",
String::from_utf8_lossy(&unpaired.stderr)
);
let zero = buildc()
.arg("run")
.arg(repo_example("greedy_change_budget.bld"))
.args(["--emit-receipt"])
.arg(dir.join("zero-wall.json"))
.args(["--invariant", "non-negative"])
.args(["--budget-steps", "60000", "--budget-consumed", "495"])
.args(["--budget-wall-seconds", "0"])
.output()
.expect("run zero wall ceiling");
assert!(
!zero.status.success(),
"a zero wall ceiling must be refused"
);
assert!(
String::from_utf8_lossy(&zero.stderr).contains("positive"),
"the refusal must name the positive/finite contract\nstderr:\n{}",
String::from_utf8_lossy(&zero.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn cross_backend_receipt_round_trips_and_pins_the_pairing() {
if !c_backend_ready() {
eprintln!(
"skipping cross_backend_receipt_round_trips_and_pins_the_pairing: C backend not ready"
);
return;
}
if !rustc_available() {
eprintln!(
"skipping cross_backend_receipt_round_trips_and_pins_the_pairing: rustc not available"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_cross_backend_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create cross-backend fixture dir");
let receipt_path = dir.join("decay_cross_backend.json");
let emit = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(&receipt_path)
.args(["--cross-backend", "rust", "--invariant", "cross-backend"])
.args(["--problem", "decay-cross-backend"])
.output()
.expect("emit cross-backend receipt");
assert!(
emit.status.success(),
"emitting the cross-backend receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit.stderr)
);
let receipt: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt_path).expect("read cross-backend receipt"))
.unwrap();
assert_eq!(receipt["receipt_status"], "PASS");
assert_eq!(receipt["invariant"]["name"], "cross_backend_columns_agree");
assert_eq!(receipt["measurement"]["column_count"], 2);
assert_eq!(receipt["measurement"]["count"], 80);
assert_eq!(receipt["cross_backend"]["secondary_target"], "rust");
assert_eq!(receipt["cross_backend"]["status"], "EXECUTED");
assert_eq!(receipt["cross_backend"]["secondary_exit_code"], 0);
for digest_field in [
"secondary_toolchain_digest",
"secondary_executable_digest",
"secondary_raw_stdout_digest",
] {
let digest = &receipt["cross_backend"][digest_field];
assert_eq!(digest["algorithm"], "sha256");
assert_eq!(
digest["hex"].as_str().map(|h| h.len()),
Some(64),
"{digest_field} must be a well-formed sha256"
);
}
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt_path)
.output()
.expect("verify cross-backend receipt");
assert!(
verify.status.success(),
"the cross-backend receipt must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let missing_invariant = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("missing_invariant.json"))
.args(["--cross-backend", "rust"])
.output()
.expect("run cross-backend without the paired invariant");
assert!(
!missing_invariant.status.success(),
"--cross-backend without --invariant cross-backend must be refused"
);
assert!(
String::from_utf8_lossy(&missing_invariant.stderr).contains("--invariant cross-backend"),
"the refusal must name the pairing\nstderr:\n{}",
String::from_utf8_lossy(&missing_invariant.stderr)
);
let missing_flag = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("missing_flag.json"))
.args(["--invariant", "cross-backend"])
.output()
.expect("run cross-backend invariant without the flag");
assert!(
!missing_flag.status.success(),
"--invariant cross-backend without --cross-backend must be refused"
);
assert!(
String::from_utf8_lossy(&missing_flag.stderr).contains("--cross-backend"),
"the refusal must name the pairing\nstderr:\n{}",
String::from_utf8_lossy(&missing_flag.stderr)
);
let with_seed = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("with_seed.json"))
.args([
"--cross-backend",
"rust",
"--invariant",
"cross-backend",
"--seed",
"7",
])
.output()
.expect("run cross-backend with --seed");
assert!(
!with_seed.status.success(),
"--cross-backend with --seed must be refused"
);
assert!(
String::from_utf8_lossy(&with_seed.stderr).contains("--seed"),
"the refusal must name --seed\nstderr:\n{}",
String::from_utf8_lossy(&with_seed.stderr)
);
let random_kernel = buildc()
.arg("run")
.arg(repo_example("random_walk_bound.bld"))
.args(["--emit-receipt"])
.arg(dir.join("random_kernel.json"))
.args(["--cross-backend", "rust", "--invariant", "cross-backend"])
.output()
.expect("run cross-backend on a Random-observing kernel");
assert!(
!random_kernel.status.success(),
"--cross-backend on a Random-observing kernel must be refused"
);
assert!(
String::from_utf8_lossy(&random_kernel.stderr).contains("Random"),
"the refusal must name the Random capability\nstderr:\n{}",
String::from_utf8_lossy(&random_kernel.stderr)
);
let bad_target = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("bad_target.json"))
.args(["--cross-backend", "vulkan", "--invariant", "cross-backend"])
.output()
.expect("run cross-backend with an unsupported target");
assert!(
!bad_target.status.success(),
"--cross-backend vulkan must be refused"
);
assert!(
String::from_utf8_lossy(&bad_target.stderr).contains("vulkan"),
"the refusal must name the unsupported target\nstderr:\n{}",
String::from_utf8_lossy(&bad_target.stderr)
);
let gpu_composition = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("gpu_composition.json"))
.args([
"--gpu",
"--cross-backend",
"rust",
"--invariant",
"cross-backend",
])
.output()
.expect("run --gpu --cross-backend together");
assert!(
!gpu_composition.status.success(),
"--gpu combined with --cross-backend must be refused"
);
assert!(
String::from_utf8_lossy(&gpu_composition.stderr)
.contains("--cross-backend is not supported with --gpu"),
"the refusal must name the gpu/cross-backend composition\nstderr:\n{}",
String::from_utf8_lossy(&gpu_composition.stderr)
);
let gpu_budget_wall = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--gpu", "--budget-wall-seconds", "300"])
.output()
.expect("run --gpu --budget-wall-seconds together");
assert!(
!gpu_budget_wall.status.success(),
"--gpu combined with --budget-wall-seconds must be refused"
);
assert!(
String::from_utf8_lossy(&gpu_budget_wall.stderr)
.contains("--budget-* flags are not supported with --gpu"),
"the refusal must name the gpu/budget composition\nstderr:\n{}",
String::from_utf8_lossy(&gpu_budget_wall.stderr)
);
let missing_rustc = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(dir.join("missing_rustc.json"))
.args(["--cross-backend", "rust", "--invariant", "cross-backend"])
.env("RUSTC", "buildlang-cross-backend-missing-rustc-probe")
.output()
.expect("run cross-backend with rustc unreachable");
assert!(
!missing_rustc.status.success(),
"a missing rustc must be refused"
);
assert!(
String::from_utf8_lossy(&missing_rustc.stderr).contains("rustc"),
"the refusal must name rustc\nstderr:\n{}",
String::from_utf8_lossy(&missing_rustc.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn permitted_secondary_block_compositions_mc_plus_budget_and_budget_plus_cross_backend() {
if !c_backend_ready() {
eprintln!(
"skipping permitted_secondary_block_compositions_mc_plus_budget_and_budget_plus_cross_backend: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_permitted_combos_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create permitted-combos fixture dir");
let budget_flags = ["--budget-steps", "60000", "--budget-consumed", "495"];
let mc_flags = [
"--mc-estimator",
"mean",
"--mc-samples",
"2000",
"--mc-interval",
"normal-approx-95",
];
let mc_budget_receipt = dir.join("mc_plus_budget.json");
let emit_mc_budget = buildc()
.arg("run")
.arg(repo_example("mc_pi_rejection.bld"))
.args(["--emit-receipt"])
.arg(&mc_budget_receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"mc-pi-rejection",
"--seed",
"42",
])
.args(mc_flags)
.args(budget_flags)
.output()
.expect("emit mc + budget receipt");
assert!(
emit_mc_budget.status.success(),
"emitting mc + budget together should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_mc_budget.stderr)
);
let mc_budget: serde_json::Value =
serde_json::from_slice(&fs::read(&mc_budget_receipt).expect("read mc + budget receipt"))
.unwrap();
assert_eq!(mc_budget["receipt_status"], "PASS");
assert_eq!(mc_budget["monte_carlo"]["estimator"], "mean");
assert_eq!(mc_budget["monte_carlo"]["samples"], 2000);
assert_eq!(mc_budget["monte_carlo"]["status"], "DECLARED");
assert_eq!(mc_budget["budget"]["steps_limit"], 60000);
assert_eq!(mc_budget["budget"]["steps_consumed"], 495);
assert_eq!(mc_budget["budget"]["status"], "DECLARED");
assert_eq!(mc_budget["seed_value"], 42);
let verify_mc_budget = buildc()
.args(["receipt", "verify"])
.arg(&mc_budget_receipt)
.output()
.expect("verify mc + budget receipt");
assert!(
verify_mc_budget.status.success(),
"the mc + budget receipt must verify (exit 0)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_mc_budget.stdout),
String::from_utf8_lossy(&verify_mc_budget.stderr)
);
if !rustc_available() {
eprintln!(
"skipping the budget + cross-backend half of permitted_secondary_block_compositions_mc_plus_budget_and_budget_plus_cross_backend: rustc not available"
);
let _ = fs::remove_dir_all(&dir);
return;
}
let budget_cross_backend_receipt = dir.join("budget_plus_cross_backend.json");
let emit_budget_cross_backend = buildc()
.arg("run")
.arg(repo_example("decay_cross_backend.bld"))
.args(["--emit-receipt"])
.arg(&budget_cross_backend_receipt)
.args(["--cross-backend", "rust", "--invariant", "cross-backend"])
.args(["--problem", "decay-cross-backend"])
.args(budget_flags)
.output()
.expect("emit budget + cross-backend receipt");
assert!(
emit_budget_cross_backend.status.success(),
"emitting budget + cross-backend together should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_budget_cross_backend.stderr)
);
let budget_cross_backend: serde_json::Value = serde_json::from_slice(
&fs::read(&budget_cross_backend_receipt).expect("read budget + cross-backend receipt"),
)
.unwrap();
assert_eq!(budget_cross_backend["receipt_status"], "PASS");
assert_eq!(budget_cross_backend["budget"]["steps_limit"], 60000);
assert_eq!(budget_cross_backend["budget"]["steps_consumed"], 495);
assert_eq!(budget_cross_backend["budget"]["status"], "DECLARED");
assert_eq!(
budget_cross_backend["cross_backend"]["secondary_target"],
"rust"
);
assert_eq!(budget_cross_backend["cross_backend"]["status"], "EXECUTED");
assert!(
budget_cross_backend["labels"]
.as_array()
.unwrap()
.iter()
.any(|l| l == "BEST_FOUND_WITHIN_BUDGET"),
"the budget block's BEST_FOUND_WITHIN_BUDGET label must be present"
);
let verify_budget_cross_backend = buildc()
.args(["receipt", "verify"])
.arg(&budget_cross_backend_receipt)
.output()
.expect("verify budget + cross-backend receipt");
assert!(
verify_budget_cross_backend.status.success(),
"the budget + cross-backend receipt must verify (exit 0)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_budget_cross_backend.stdout),
String::from_utf8_lossy(&verify_budget_cross_backend.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn receipt_verify_self_test_proves_the_verifier_can_fail() {
if !c_backend_ready() {
eprintln!(
"skipping receipt_verify_self_test_proves_the_verifier_can_fail: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_selftest_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create self-test fixture dir");
let receipt = dir.join("funnel.json");
let emit = buildc()
.arg("run")
.arg(repo_example("funnel_probe.bld"))
.args(["--emit-receipt"])
.arg(&receipt)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"p",
])
.output()
.expect("emit receipt for self-test");
assert!(emit.status.success(), "emitting the receipt should succeed");
let self_test = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.arg("--self-test")
.output()
.expect("run receipt verify --self-test");
assert!(
self_test.status.success(),
"self-test must pass (every tamper rejected with its expected class)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&self_test.stdout),
String::from_utf8_lossy(&self_test.stderr)
);
let stdout = String::from_utf8_lossy(&self_test.stdout);
assert!(
stdout.contains("10/10 tampers rejected with the expected failure_class"),
"self-test should report all ten tampers rejected\nstdout:\n{}",
stdout
);
for class in [
"COMPILER_MISMATCH",
"SEAL_MISMATCH",
"MALFORMED",
"FIELD_CONTRACT_VIOLATION",
"INVARIANT_UNSUPPORTED",
] {
assert!(
stdout.contains(class),
"self-test report must exercise {class}\nstdout:\n{stdout}"
);
}
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn receipt_chain_build_and_verify_is_tamper_evident() {
if !c_backend_ready() {
eprintln!("skipping receipt_chain_build_and_verify_is_tamper_evident: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_chain_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create chain fixture dir");
let emit = |src: &str, out: &std::path::Path, problem: &str| {
let status = buildc()
.arg("run")
.arg(repo_example(src))
.args(["--emit-receipt"])
.arg(out)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
problem,
])
.output()
.expect("emit member receipt");
assert!(status.status.success(), "emitting {src} should succeed");
};
let a = dir.join("a.json");
let b = dir.join("b.json");
emit("funnel_probe.bld", &a, "a");
emit("search_bound_binary.bld", &b, "b");
let b_original = fs::read(&b).expect("snapshot member b");
let chain = dir.join("chain.json");
let build = buildc()
.args(["receipt", "chain", "build"])
.arg(&a)
.arg(&b)
.arg("-o")
.arg(&chain)
.output()
.expect("build chain");
assert!(build.status.success(), "chain build should succeed");
let verify = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify chain");
assert!(
verify.status.success(),
"the clean chain must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr)
);
let mut manifest: serde_json::Value =
serde_json::from_slice(&fs::read(&chain).expect("read chain")).unwrap();
let links = manifest["links"].as_array().unwrap().clone();
manifest["links"] = serde_json::Value::Array(vec![links[1].clone(), links[0].clone()]);
let reordered = dir.join("reorder.json");
fs::write(&reordered, serde_json::to_vec_pretty(&manifest).unwrap()).unwrap();
let verify_reorder = buildc()
.args(["receipt", "chain", "verify"])
.arg(&reordered)
.output()
.expect("verify reordered chain");
assert!(
!verify_reorder.status.success(),
"a reordered chain must fail"
);
assert!(
String::from_utf8_lossy(&verify_reorder.stderr).contains("CHAIN_SEAL_MISMATCH"),
"reordering must report CHAIN_SEAL_MISMATCH\nstderr:\n{}",
String::from_utf8_lossy(&verify_reorder.stderr)
);
let mut body: serde_json::Value = serde_json::from_slice(&b_original).unwrap();
let vc = body["invariant"]["observed"]["violation_count"]
.as_i64()
.unwrap_or(0);
body["invariant"]["observed"]["violation_count"] = serde_json::Value::from(vc + 1);
fs::write(&b, serde_json::to_vec_pretty(&body).unwrap()).unwrap();
let verify_unverified = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify unverifiable-member chain");
assert!(
!verify_unverified.status.success(),
"an unverifiable member must fail"
);
assert!(
String::from_utf8_lossy(&verify_unverified.stderr).contains("CHAIN_LINK_UNVERIFIED"),
"a member that does not re-verify must report CHAIN_LINK_UNVERIFIED\nstderr:\n{}",
String::from_utf8_lossy(&verify_unverified.stderr)
);
let mut member: serde_json::Value = serde_json::from_slice(&b_original).unwrap();
member["seal"]["hex"] = serde_json::Value::String("0".repeat(64));
fs::write(&b, serde_json::to_vec_pretty(&member).unwrap()).unwrap();
let verify_tampered = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify tampered-member chain");
assert!(
!verify_tampered.status.success(),
"a tampered member must fail"
);
assert!(
String::from_utf8_lossy(&verify_tampered.stderr).contains("CHAIN_LINK_TAMPERED"),
"a substituted member must report CHAIN_LINK_TAMPERED\nstderr:\n{}",
String::from_utf8_lossy(&verify_tampered.stderr)
);
fs::remove_file(&b).expect("delete member");
let verify_missing = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify missing-member chain");
assert!(
!verify_missing.status.success(),
"a missing member must fail"
);
assert!(
String::from_utf8_lossy(&verify_missing.stderr).contains("CHAIN_LINK_MISSING"),
"a deleted member must report CHAIN_LINK_MISSING\nstderr:\n{}",
String::from_utf8_lossy(&verify_missing.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn receipt_corpus_asserts_declared_classifications() {
if !c_backend_ready() {
eprintln!("skipping receipt_corpus_asserts_declared_classifications: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_corpus_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create corpus fixture dir");
let shipped: serde_json::Value = serde_json::from_slice(
&fs::read(repo_example("scientific-corpus.json")).expect("read shipped corpus"),
)
.expect("shipped corpus parses");
assert_eq!(shipped["schema"], "buildlang-scientific-receipt-corpus/v0");
assert_eq!(
shipped["members"].as_array().unwrap().len(),
29,
"the shipped corpus should cover all fourteen kernel pairs plus the cross-backend singleton"
);
let bin = repo_example("search_bound_binary.bld");
let lin = repo_example("search_bound_linear.bld");
let manifest = serde_json::json!({
"schema": "buildlang-scientific-receipt-corpus/v0",
"members": [
{"source": bin.to_string_lossy(), "invariant": "non-negative", "expected_status": "PASS"},
{"source": lin.to_string_lossy(), "invariant": "non-negative", "negative_fixture": true, "expected_status": "FAIL_EXPECTED"}
]
});
let good = dir.join("good.json");
fs::write(&good, serde_json::to_vec_pretty(&manifest).unwrap()).unwrap();
let run_good = buildc()
.args(["receipt", "corpus"])
.arg(&good)
.output()
.expect("run corpus (good)");
assert!(
run_good.status.success(),
"a correct corpus must pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&run_good.stdout),
String::from_utf8_lossy(&run_good.stderr)
);
assert!(
String::from_utf8_lossy(&run_good.stdout).contains("2/2 members classified"),
"corpus should report 2/2\nstdout:\n{}",
String::from_utf8_lossy(&run_good.stdout)
);
let mut wrong = manifest.clone();
wrong["members"][0]["expected_status"] = serde_json::Value::String("FAIL_EXPECTED".to_string());
let wrong_path = dir.join("wrong.json");
fs::write(&wrong_path, serde_json::to_vec_pretty(&wrong).unwrap()).unwrap();
let run_wrong = buildc()
.args(["receipt", "corpus"])
.arg(&wrong_path)
.output()
.expect("run corpus (wrong)");
assert!(
!run_wrong.status.success(),
"a mis-declared corpus must fail"
);
assert!(
String::from_utf8_lossy(&run_wrong.stderr)
.contains("did NOT match their declared classification"),
"a mis-declared corpus must report the mismatch\nstderr:\n{}",
String::from_utf8_lossy(&run_wrong.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn conserved_band_invariant_round_trips_and_is_distinct() {
if !c_backend_ready() {
eprintln!(
"skipping conserved_band_invariant_round_trips_and_is_distinct: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_conserved_band_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create conserved-band fixture dir");
let pass_receipt = dir.join("symplectic.json");
let emit_pass = buildc()
.arg("run")
.arg(repo_example("symplectic_oscillator.bld"))
.args(["--emit-receipt"])
.arg(&pass_receipt)
.args([
"--invariant",
"conserved-band",
"--metric",
"energy",
"--problem",
"leapfrog",
])
.output()
.expect("emit conserved-band PASS receipt");
assert!(
emit_pass.status.success(),
"emitting the conserved-band PASS receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit_pass.stderr)
);
let pass: serde_json::Value =
serde_json::from_slice(&fs::read(&pass_receipt).expect("read PASS receipt")).unwrap();
assert_eq!(pass["invariant"]["name"], "conserved_within_band");
assert_eq!(pass["receipt_status"], "PASS");
assert_eq!(pass["invariant"]["observed"]["violation_count"], 0);
let verify_pass = buildc()
.args(["receipt", "verify"])
.arg(&pass_receipt)
.output()
.expect("verify conserved-band PASS receipt");
assert!(
verify_pass.status.success(),
"the conserved-band PASS receipt must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify_pass.stderr)
);
for (inv, why) in [
("bounded", "energy rises above H_0"),
("conservation", "energy deviates"),
] {
let r = dir.join(format!("symp_{inv}.json"));
let emit = buildc()
.arg("run")
.arg(repo_example("symplectic_oscillator.bld"))
.args(["--emit-receipt"])
.arg(&r)
.args([
"--invariant",
inv,
"--metric",
"energy",
"--problem",
"leapfrog",
])
.output()
.expect("emit symplectic under a tighter invariant");
assert!(emit.status.success());
let v: serde_json::Value =
serde_json::from_slice(&fs::read(&r).expect("read receipt")).unwrap();
assert_eq!(
v["receipt_status"], "FAIL_UNEXPECTED",
"the symplectic series must FAIL {inv} ({why}), so conserved-band is distinct"
);
}
let fail_receipt = dir.join("euler.json");
let emit_fail = buildc()
.arg("run")
.arg(repo_example("euler_oscillator.bld"))
.args(["--emit-receipt"])
.arg(&fail_receipt)
.args([
"--invariant",
"conserved-band",
"--negative-fixture",
"--metric",
"energy",
"--problem",
"euler",
])
.output()
.expect("emit conserved-band negative fixture");
assert!(
emit_fail.status.success(),
"emitting the negative fixture should succeed"
);
let fail: serde_json::Value =
serde_json::from_slice(&fs::read(&fail_receipt).expect("read FAIL receipt")).unwrap();
assert_eq!(fail["receipt_status"], "FAIL_EXPECTED");
assert!(
fail["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap()
> 0
);
let verify_fail = buildc()
.args(["receipt", "verify"])
.arg(&fail_receipt)
.output()
.expect("verify conserved-band negative fixture");
assert!(
verify_fail.status.success(),
"a faithfully reproduced FAIL_EXPECTED must verify (exit 0)\nstderr:\n{}",
String::from_utf8_lossy(&verify_fail.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn run_emit_receipt_stable_kernel_is_pass() {
if !c_backend_ready() {
eprintln!("skipping run_emit_receipt_stable_kernel_is_pass: C backend not ready");
return;
}
let output = buildc()
.arg("run")
.arg(repo_example("heat_equation_energy.bld"))
.arg("--emit-receipt")
.arg("-")
.arg("--problem")
.arg("1d-heat-equation-energy")
.output()
.expect("run buildc run --emit-receipt - on stable kernel");
assert!(
output.status.success(),
"emitting a receipt for the stable kernel should succeed\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["schema"], "buildlang-scientific-runtime-receipt/v1");
assert_eq!(receipt["compiler"], "buildc");
assert_eq!(receipt["receipt_status"], "PASS");
assert_eq!(receipt["invariant"]["status"], "PASS");
assert_eq!(receipt["invariant"]["observed"]["violation_count"], 0);
assert_eq!(receipt["problem"]["label"], "1d-heat-equation-energy");
assert_eq!(receipt["measurement"]["count"], 400);
let seal = receipt["seal"]["hex"].as_str().expect("seal hex string");
assert_eq!(seal.len(), 64, "seal must be 64 hex chars");
assert!(
seal.chars()
.all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase()),
"seal must be lowercase hex: {seal}"
);
let labels = receipt["labels"].as_array().expect("labels array");
assert!(
labels.iter().any(|label| label == "NUMERICAL_RESULT"),
"every receipt must carry NUMERICAL_RESULT; got {labels:?}"
);
let digest = receipt["source_digest"]["hex"]
.as_str()
.expect("source digest hex");
assert_eq!(digest.len(), 64);
}
#[test]
fn run_emit_receipt_unstable_negative_fixture_is_fail_expected() {
if !c_backend_ready() {
eprintln!(
"skipping run_emit_receipt_unstable_negative_fixture_is_fail_expected: C backend not ready"
);
return;
}
let output = buildc()
.arg("run")
.arg(repo_example("heat_equation_energy_unstable.bld"))
.arg("--emit-receipt")
.arg("-")
.arg("--negative-fixture")
.output()
.expect("run buildc run --emit-receipt - --negative-fixture on unstable kernel");
assert!(
output.status.success(),
"emitting a negative-fixture receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["receipt_status"], "FAIL_EXPECTED");
assert_eq!(receipt["invariant"]["status"], "FAIL");
assert_eq!(receipt["negative_fixture"], true);
assert!(
receipt["invariant"]["observed"]["violation_count"]
.as_u64()
.unwrap_or(0)
> 0,
"the unstable kernel must record at least one energy increase"
);
let labels = receipt["labels"].as_array().expect("labels array");
assert!(labels.iter().any(|label| label == "NUMERICAL_RESULT"));
assert!(labels.iter().any(|label| label == "NEGATIVE_FIXTURE"));
}
#[test]
fn run_emit_receipt_unstable_without_fixture_is_fail_unexpected() {
if !c_backend_ready() {
eprintln!(
"skipping run_emit_receipt_unstable_without_fixture_is_fail_unexpected: C backend not ready"
);
return;
}
let output = buildc()
.arg("run")
.arg(repo_example("heat_equation_energy_unstable.bld"))
.arg("--emit-receipt")
.arg("-")
.output()
.expect("run buildc run --emit-receipt - on unstable kernel (no fixture)");
assert!(output.status.success());
let receipt = receipt_from_stdout(&output);
assert_eq!(receipt["receipt_status"], "FAIL_UNEXPECTED");
assert_eq!(receipt["invariant"]["status"], "FAIL");
assert_eq!(receipt["negative_fixture"], false);
}
#[test]
fn run_emit_receipt_unknown_invariant_errors() {
let output = buildc()
.arg("run")
.arg(repo_example("heat_equation_energy.bld"))
.arg("--emit-receipt")
.arg("-")
.arg("--invariant")
.arg("does-not-exist")
.output()
.expect("run buildc run --emit-receipt - --invariant does-not-exist");
assert!(
!output.status.success(),
"an unknown --invariant must fail before compiling"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Unknown --invariant"),
"error should name the unknown invariant; got:\n{stderr}"
);
}
#[test]
fn run_emit_receipt_to_file_still_echoes_program_stdout() {
if !c_backend_ready() {
eprintln!(
"skipping run_emit_receipt_to_file_still_echoes_program_stdout: C backend not ready"
);
return;
}
let kernel = repo_example("heat_equation_energy.bld");
let baseline = buildc()
.arg("run")
.arg(&kernel)
.output()
.expect("baseline buildc run");
assert!(baseline.status.success());
let baseline_stdout = String::from_utf8_lossy(&baseline.stdout).replace("\r\n", "\n");
let receipt_path =
std::env::temp_dir().join(format!("buildlang_sci_receipt_{}.json", std::process::id()));
let emitted = buildc()
.arg("run")
.arg(&kernel)
.arg("--emit-receipt")
.arg(&receipt_path)
.output()
.expect("buildc run --emit-receipt <file>");
assert!(
emitted.status.success(),
"emit-to-file run should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emitted.stderr)
);
let emitted_stdout = String::from_utf8_lossy(&emitted.stdout).replace("\r\n", "\n");
assert_eq!(
emitted_stdout, baseline_stdout,
"emit-to-file must echo the program stdout identically to plain run"
);
let bytes = fs::read(&receipt_path).expect("read emitted receipt file");
let _ = fs::remove_file(&receipt_path);
let receipt: serde_json::Value =
serde_json::from_slice(&bytes).expect("receipt file is valid JSON");
assert_eq!(receipt["receipt_status"], "PASS");
assert_eq!(receipt["seal"]["hex"].as_str().map(str::len), Some(64));
}
fn stage_stable_kernel(label: &str) -> (PathBuf, PathBuf) {
let dir = std::env::temp_dir().join(format!(
"buildlang_sci_verify_{}_{}",
label,
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create scientific verify fixture dir");
let src = repo_example("heat_equation_energy.bld");
let staged = dir.join("heat_equation_energy.bld");
fs::copy(&src, &staged).expect("copy stable kernel into fixture dir");
(dir, staged)
}
fn emit_stable_receipt(staged: &Path, receipt: &Path) {
let emitted = buildc()
.arg("run")
.arg(staged)
.arg("--emit-receipt")
.arg(receipt)
.arg("--problem")
.arg("1d-heat-equation-energy")
.output()
.expect("emit stable scientific receipt");
assert!(
emitted.status.success(),
"emitting the stable receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emitted.stderr)
);
}
#[test]
fn receipt_verify_scientific_stable_receipt_matches() {
if !c_backend_ready() {
eprintln!("skipping receipt_verify_scientific_stable_receipt_matches: C backend not ready");
return;
}
let (dir, staged) = stage_stable_kernel("match");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify stable scientific receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
verify.status.success(),
"a valid stable scientific receipt must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let stdout = String::from_utf8_lossy(&verify.stdout);
assert!(
stdout.contains("MATCH"),
"human output should report MATCH:\n{stdout}"
);
}
#[test]
fn receipt_verify_scientific_json_reports_match() {
if !c_backend_ready() {
eprintln!("skipping receipt_verify_scientific_json_reports_match: C backend not ready");
return;
}
let (dir, staged) = stage_stable_kernel("json");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let verify = buildc()
.args(["receipt", "verify", "--json"])
.arg(&receipt)
.output()
.expect("verify stable scientific receipt (--json)");
let _ = fs::remove_dir_all(&dir);
assert!(
verify.status.success(),
"valid scientific receipt must verify (--json)\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let report: serde_json::Value =
serde_json::from_slice(&verify.stdout).expect("json verify output is JSON");
assert_eq!(report["status"], "match");
assert_eq!(report["schema"], "buildlang-scientific-runtime-receipt/v1");
}
#[test]
fn receipt_verify_scientific_detects_invariant_status_tamper() {
if !c_backend_ready() {
eprintln!(
"skipping receipt_verify_scientific_detects_invariant_status_tamper: C backend not ready"
);
return;
}
let (dir, staged) = stage_stable_kernel("invtamper");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let raw = fs::read_to_string(&receipt).expect("read emitted receipt");
let mut value: serde_json::Value = serde_json::from_str(&raw).expect("parse receipt");
assert_eq!(value["invariant"]["status"], "PASS");
value["invariant"]["status"] = serde_json::Value::String("FAIL".to_string());
fs::write(&receipt, serde_json::to_string_pretty(&value).unwrap())
.expect("write tampered receipt");
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify tampered scientific receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify.status.success(),
"an invariant-status tamper must fail verification\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
}
#[test]
fn receipt_verify_scientific_detects_source_tamper() {
if !c_backend_ready() {
eprintln!("skipping receipt_verify_scientific_detects_source_tamper: C backend not ready");
return;
}
let (dir, staged) = stage_stable_kernel("srctamper");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let original = fs::read_to_string(&staged).expect("read staged kernel");
let tampered = format!("{original}\n// tamper: appended after sealing\n");
fs::write(&staged, tampered).expect("write tampered source");
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify receipt against tampered source");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify.status.success(),
"a source-file tamper must fail verification\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
}
#[test]
fn scientific_runtime_receipt_emit_and_verify_round_trip() {
if !c_backend_ready() {
eprintln!(
"skipping scientific_runtime_receipt_emit_and_verify_round_trip: C backend not ready"
);
return;
}
let (dir, staged) = stage_stable_kernel("roundtrip");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let emitted: serde_json::Value = {
let bytes = fs::read(&receipt).expect("read emitted round-trip receipt");
serde_json::from_slice(&bytes).expect("emitted receipt is valid JSON")
};
assert_eq!(emitted["schema"], "buildlang-scientific-runtime-receipt/v1");
assert_eq!(emitted["receipt_status"], "PASS");
assert_eq!(emitted["invariant"]["status"], "PASS");
assert_eq!(emitted["invariant"]["observed"]["violation_count"], 0);
let seal = emitted["seal"]["hex"].as_str().expect("seal hex string");
assert_eq!(seal.len(), 64, "seal must be 64 hex chars");
assert!(
seal.chars()
.all(|ch| ch.is_ascii_hexdigit() && !ch.is_ascii_uppercase()),
"seal must be lowercase hex: {seal}"
);
assert!(
emitted["labels"]
.as_array()
.expect("labels array")
.iter()
.any(|label| label == "NUMERICAL_RESULT"),
"every receipt must carry NUMERICAL_RESULT"
);
let verify_ok = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify untouched round-trip receipt");
assert!(
verify_ok.status.success(),
"the untouched receipt must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_ok.stdout),
String::from_utf8_lossy(&verify_ok.stderr)
);
assert!(
String::from_utf8_lossy(&verify_ok.stdout).contains("MATCH"),
"human verify output should report MATCH"
);
let mut tampered: serde_json::Value = emitted.clone();
tampered["invariant"]["status"] = serde_json::Value::String("FAIL".to_string());
fs::write(&receipt, serde_json::to_string_pretty(&tampered).unwrap())
.expect("write tampered round-trip receipt");
let verify_tampered = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify tampered round-trip receipt");
assert!(
!verify_tampered.status.success(),
"a tampered receipt must fail verification\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify_tampered.stdout),
String::from_utf8_lossy(&verify_tampered.stderr)
);
assert!(
String::from_utf8_lossy(&verify_tampered.stderr).contains("failure_class: SEAL_MISMATCH"),
"an unsealed hand-edit must be caught by the integrity gate\nstderr:\n{}",
String::from_utf8_lossy(&verify_tampered.stderr)
);
let pretty = serde_json::to_string_pretty(&emitted).unwrap();
let with_dup = pretty.replacen(
"\"receipt_status\":",
"\"receipt_status\": \"PASS\",\n \"receipt_status\":",
1,
);
assert_ne!(pretty, with_dup, "duplication must have been injected");
fs::write(&receipt, with_dup).expect("write duplicate-key receipt");
let verify_dup = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify duplicate-key receipt");
assert!(
!verify_dup.status.success(),
"a duplicate-key receipt must be rejected"
);
assert!(
String::from_utf8_lossy(&verify_dup.stderr).contains("duplicate object key"),
"rejection must name the duplicate key\nstderr:\n{}",
String::from_utf8_lossy(&verify_dup.stderr)
);
let _ = fs::remove_dir_all(&dir);
let negative = buildc()
.arg("run")
.arg(repo_example("heat_equation_energy_unstable.bld"))
.arg("--emit-receipt")
.arg("-")
.arg("--negative-fixture")
.output()
.expect("emit negative-fixture receipt for the unstable kernel");
assert!(
negative.status.success(),
"emitting a negative-fixture receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&negative.stderr)
);
let negative_receipt = receipt_from_stdout(&negative);
assert_eq!(negative_receipt["receipt_status"], "FAIL_EXPECTED");
assert_eq!(negative_receipt["invariant"]["status"], "FAIL");
assert_eq!(negative_receipt["negative_fixture"], true);
let negative_labels = negative_receipt["labels"].as_array().expect("labels array");
assert!(
negative_labels
.iter()
.any(|label| label == "NUMERICAL_RESULT"),
"the negative fixture is still labelled NUMERICAL_RESULT"
);
assert!(
negative_labels
.iter()
.any(|label| label == "NEGATIVE_FIXTURE"),
"the negative fixture must be labelled NEGATIVE_FIXTURE"
);
}
#[test]
fn receipt_export_emits_a_witnessed_crucible_measurement() {
if !c_backend_ready() {
eprintln!(
"skipping receipt_export_emits_a_witnessed_crucible_measurement: C backend not ready"
);
return;
}
let (dir, staged) = stage_stable_kernel("export_bridge");
let receipt = dir.join("receipt.json");
emit_stable_receipt(&staged, &receipt);
let out = dir.join("measurement.json");
let export = buildc()
.args(["receipt", "export"])
.arg(&receipt)
.arg("-o")
.arg(&out)
.args(["--claim-id", "heat-energy-monotone"])
.args(["--claim-sha256", &"a".repeat(64)])
.output()
.expect("run receipt export");
assert!(
export.status.success(),
"export of a faithful receipt must succeed\nstderr:\n{}",
String::from_utf8_lossy(&export.stderr)
);
let envelope: serde_json::Value =
serde_json::from_slice(&fs::read(&out).expect("read export")).expect("parse export");
assert_eq!(
envelope["schema"],
"buildlang-crucible-measurement-export/v0"
);
assert_eq!(envelope["invariant_held"], true);
let row = &envelope["measurements"][0];
assert_eq!(row["deviation"], 0.0);
assert_eq!(row["tolerance"], 0.5);
assert_eq!(row["claim_id"], "heat-energy-monotone");
assert_eq!(row["method"], "buildc-receipt-verify/reexecuted-v1");
assert_eq!(row["recheck"]["oracle"], "buildc.receipt.verify");
assert_eq!(row["recheck"]["expected"]["receipt_status"], "PASS");
assert!(
row["recheck"]["receipt_sha256"].as_str().unwrap().len() == 64,
"the replayed artifact must be hash-bound"
);
let source_text = fs::read_to_string(&staged).expect("read staged kernel");
fs::write(&staged, format!("{source_text}\n// tamper\n")).expect("tamper staged kernel");
let out2 = dir.join("measurement2.json");
let export_tampered = buildc()
.args(["receipt", "export"])
.arg(&receipt)
.arg("-o")
.arg(&out2)
.output()
.expect("run receipt export on tampered source");
assert!(
!export_tampered.status.success(),
"a non-reproducing receipt must export nothing"
);
assert!(
!out2.exists(),
"no measurement file may be written on failure"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scientific_receipt_large_value_series_reseals_and_verifies() {
if !c_backend_ready() {
eprintln!("skipping scientific_receipt_large_value_series_reseals: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_largeval_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create large-value fixture dir");
let staged = dir.join("heat_equation_energy_unstable.bld");
fs::copy(repo_example("heat_equation_energy_unstable.bld"), &staged)
.expect("copy unstable kernel");
let receipt = dir.join("receipt.json");
let emit = buildc()
.arg("run")
.arg(&staged)
.arg("--emit-receipt")
.arg(&receipt)
.arg("--negative-fixture")
.output()
.expect("emit large-value receipt");
assert!(
emit.status.success(),
"emitting the unstable receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit.stderr)
);
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify large-value receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
verify.status.success(),
"a large-value FAIL_EXPECTED receipt must re-seal and verify clean\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
}
#[test]
fn scientific_receipt_verify_fails_on_unexpected_invariant_violation() {
if !c_backend_ready() {
eprintln!("skipping scientific_receipt_verify_fails_unexpected: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_unexpected_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create unexpected fixture dir");
let staged = dir.join("heat_equation_energy_unstable.bld");
fs::copy(repo_example("heat_equation_energy_unstable.bld"), &staged)
.expect("copy unstable kernel");
let receipt = dir.join("receipt.json");
let emit = buildc()
.arg("run")
.arg(&staged)
.arg("--emit-receipt")
.arg(&receipt)
.output()
.expect("emit FAIL_UNEXPECTED receipt");
assert!(emit.status.success(), "emit should succeed");
let value: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read receipt")).expect("parse receipt");
assert_eq!(value["receipt_status"], "FAIL_UNEXPECTED");
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify FAIL_UNEXPECTED receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify.status.success(),
"verify must exit nonzero on a faithful FAIL_UNEXPECTED receipt\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
}
#[test]
fn scientific_receipt_nonfinite_run_is_unverifiable() {
if !c_backend_ready() {
eprintln!("skipping scientific_receipt_nonfinite_run_is_unverifiable: C backend not ready");
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_nonfinite_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create nonfinite fixture dir");
let src = dir.join("diverge.bld");
fs::write(
&src,
"fn main() ~ Console {\n \
println(\"{}\", 4.0);\n println(\"{}\", 3.0);\n \
let z = 0.0;\n let bad = z / z;\n println(\"{}\", bad);\n}\n",
)
.expect("write diverging kernel");
let receipt = dir.join("receipt.json");
let emit = buildc()
.arg("run")
.arg(&src)
.arg("--emit-receipt")
.arg(&receipt)
.output()
.expect("emit diverging receipt");
assert!(emit.status.success(), "emit should succeed");
let bytes = fs::read(&receipt).expect("read receipt");
let text = String::from_utf8_lossy(&bytes);
assert!(
!text.contains("null"),
"observed_values must be finite (no JSON null):\n{text}"
);
let value: serde_json::Value = serde_json::from_slice(&bytes).expect("parse receipt");
assert_eq!(
value["receipt_status"], "UNVERIFIABLE",
"a diverged run must be UNVERIFIABLE, not a false PASS"
);
assert!(
value["labels"]
.as_array()
.expect("labels array")
.iter()
.any(|label| label == "NONFINITE_OBSERVED"),
"a diverged receipt must be labelled NONFINITE_OBSERVED"
);
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify diverging receipt");
let _ = fs::remove_dir_all(&dir);
assert!(
!verify.status.success(),
"a diverged (UNVERIFIABLE) receipt must not verify as a pass\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
}
#[test]
fn run_units_flag_seals_canonicalized_unit_in_receipt() {
if !c_backend_ready() {
eprintln!(
"skipping run_units_flag_seals_canonicalized_unit_in_receipt: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_sci_units_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create units fixture dir");
let receipt = dir.join("with_units.json");
let emit = buildc()
.arg("run")
.arg(repo_example("energy_identity.bld"))
.args(["--emit-receipt"])
.arg(&receipt)
.args([
"--invariant",
"energy-identity",
"--metric",
"residual",
"--units",
"m*s^-1",
])
.output()
.expect("emit receipt with --units");
assert!(
emit.status.success(),
"emitting a receipt with a valid --units should succeed\nstderr:\n{}",
String::from_utf8_lossy(&emit.stderr)
);
let value: serde_json::Value =
serde_json::from_slice(&fs::read(&receipt).expect("read units receipt")).unwrap();
assert_eq!(
value["measurement"]["units"], "m/s",
"the receipt must seal the CANONICAL unit `m/s`, not the raw `m*s^-1`"
);
let verify = buildc()
.args(["receipt", "verify"])
.arg(&receipt)
.output()
.expect("verify units receipt");
assert!(
verify.status.success(),
"a receipt carrying a canonicalized unit must still verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn run_units_flag_rejects_unknown_unit_before_compile() {
let dir = std::env::temp_dir().join(format!("buildlang_sci_bad_units_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create bad-units fixture dir");
let receipt = dir.join("should_not_exist.json");
let output = buildc()
.arg("run")
.arg(repo_example("energy_identity.bld"))
.args(["--emit-receipt"])
.arg(&receipt)
.args(["--invariant", "energy-identity", "--units", "furlong"])
.output()
.expect("run with an unknown --units");
assert!(
!output.status.success(),
"an unknown unit must fail the command\nstdout:\n{}",
String::from_utf8_lossy(&output.stdout)
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("furlong"),
"the error must name the offending unit `furlong`, got:\n{stderr}"
);
assert!(
!receipt.exists(),
"no receipt should be written when the unit is rejected"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn model_capability_is_fail_closed_and_inadmissible_on_the_receipt_path() {
if !c_backend_ready() {
eprintln!("skipping model_capability_is_fail_closed_and_inadmissible_on_the_receipt_path: C backend not ready");
return;
}
let no_endpoint = buildc()
.arg("run")
.arg(repo_example("model_propose.bld"))
.env_remove("BUILD_MODEL_ENDPOINT")
.output()
.expect("run model kernel with no endpoint");
assert!(
!no_endpoint.status.success(),
"a Model-observing kernel with no endpoint must be refused"
);
assert!(
String::from_utf8_lossy(&no_endpoint.stderr).contains("no endpoint provided"),
"the refusal must name the missing endpoint\nstderr:\n{}",
String::from_utf8_lossy(&no_endpoint.stderr)
);
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind ephemeral TCP port");
listener
.set_nonblocking(true)
.expect("set listener nonblocking so the accept loop can honor a deadline");
let port = listener.local_addr().expect("listener local_addr").port();
let server = std::thread::spawn(move || {
use std::io::{BufRead, BufReader, Write};
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30);
let (stream, _) = loop {
match listener.accept() {
Ok(accepted) => break accepted,
Err(err) if err.kind() == std::io::ErrorKind::WouldBlock => {
assert!(
std::time::Instant::now() < deadline,
"timed out after 30s waiting for the model kernel to connect to the TCP shim"
);
std::thread::sleep(std::time::Duration::from_millis(10));
}
Err(err) => panic!("accept model kernel connection: {err}"),
}
};
stream
.set_nonblocking(false)
.expect("set accepted stream back to blocking for the read/write below");
let mut received_line = String::new();
BufReader::new(&stream)
.read_line(&mut received_line)
.expect("read prompt line up to the newline terminator");
(&stream)
.write_all(b"four\n")
.expect("write completion line");
drop(stream);
received_line
});
let shimmed = buildc()
.arg("run")
.arg(repo_example("model_propose.bld"))
.env("BUILD_MODEL_ENDPOINT", format!("127.0.0.1:{port}"))
.output()
.expect("run model kernel against the TCP shim");
let received_line = server.join().expect("shim thread should not panic");
assert_eq!(
received_line, "propose: 2 + 2 =\n",
"the shim must receive the kernel's EXACT prompt line, newline-terminated"
);
assert!(
shimmed.status.success(),
"a shimmed model kernel should exit 0\nstderr:\n{}",
String::from_utf8_lossy(&shimmed.stderr)
);
assert!(
String::from_utf8_lossy(&shimmed.stdout).contains("four"),
"stdout should contain the shim's completion\nstdout:\n{}",
String::from_utf8_lossy(&shimmed.stdout)
);
let dir = std::env::temp_dir().join(format!("buildlang_model_receipt_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create model receipt fixture dir");
let receipt = dir.join("model.json");
let refused = buildc()
.arg("run")
.arg(repo_example("model_propose.bld"))
.args(["--emit-receipt"])
.arg(&receipt)
.args(["--invariant", "non-negative"])
.env_remove("BUILD_MODEL_ENDPOINT")
.output()
.expect("run model kernel with --emit-receipt");
assert!(
!refused.status.success(),
"--emit-receipt on a Model-observing kernel must be refused"
);
assert!(
String::from_utf8_lossy(&refused.stderr).contains("uses the Model capability"),
"the refusal must name the Model capability\nstderr:\n{}",
String::from_utf8_lossy(&refused.stderr)
);
assert!(
!receipt.exists(),
"no receipt should be written when the Model capability is refused"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_reports_capability_effect_for_model_call() {
let fixture = std::env::temp_dir().join(format!(
"buildlang_model_capability_gate_{}.bld",
std::process::id()
));
fs::write(&fixture, r#"fn main() { model_complete("x"); }"#)
.expect("write model capability fixture");
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let _ = fs::remove_file(&fixture);
assert!(
!output.status.success(),
"model_complete call should fail without Model effect"
);
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
stderr.contains("Model"),
"diagnostic should name Model effect:\n{}",
stderr
);
assert!(
stderr.contains("model_complete"),
"diagnostic should name triggering ambient call:\n{}",
stderr
);
}
#[test]
fn five_modes_bind_into_one_chain() {
if !c_backend_ready() {
eprintln!("skipping five_modes_bind_into_one_chain: C backend not ready");
return;
}
let dir =
std::env::temp_dir().join(format!("buildlang_five_modes_chain_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create five-modes chain fixture dir");
let emit_member = |label: &str, src: &str, out: &Path, metric: Option<&str>, extra: &[&str]| {
let mut cmd = buildc();
cmd.arg("run")
.arg(repo_example(src))
.args(["--emit-receipt"])
.arg(out);
if let Some(metric) = metric {
cmd.args(["--metric", metric]);
}
cmd.args(extra);
let output = cmd
.output()
.unwrap_or_else(|err| panic!("emit {label} receipt: {err}"));
assert!(
output.status.success(),
"emitting the {label} receipt should succeed\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
let receipt: serde_json::Value = serde_json::from_slice(
&fs::read(out).unwrap_or_else(|err| panic!("read {label} receipt: {err}")),
)
.unwrap_or_else(|err| panic!("parse {label} receipt: {err}"));
assert_eq!(
receipt["receipt_status"], "PASS",
"the {label} receipt must PASS\nreceipt:\n{receipt}"
);
};
let deterministic = dir.join("01-deterministic.json");
emit_member(
"deterministic",
"heat_equation_energy.bld",
&deterministic,
Some("energy"),
&[
"--invariant",
"energy-monotone",
"--problem",
"1d-heat-equation-energy",
],
);
let probabilistic_exact = dir.join("02-probabilistic-exact.json");
emit_member(
"probabilistic-exact",
"born_rule_normalization.bld",
&probabilistic_exact,
None,
&[
"--invariant",
"conservation",
"--problem",
"born-rule-normalization",
],
);
let stochastic = dir.join("03-stochastic.json");
emit_member(
"stochastic",
"random_walk_bound.bld",
&stochastic,
Some("slack"),
&[
"--invariant",
"non-negative",
"--problem",
"seeded-random-walk-envelope",
"--seed",
"42",
],
);
let monte_carlo = dir.join("04-monte-carlo.json");
emit_member(
"monte-carlo",
"mc_pi_rejection.bld",
&monte_carlo,
Some("slack"),
&[
"--invariant",
"non-negative",
"--problem",
"mc-pi-rejection",
"--seed",
"42",
"--mc-estimator",
"mean",
"--mc-samples",
"2000",
"--mc-interval",
"normal-approx-95",
],
);
let heuristic = dir.join("05-heuristic.json");
emit_member(
"heuristic",
"greedy_change_budget.bld",
&heuristic,
Some("slack"),
&[
"--invariant",
"non-negative",
"--problem",
"greedy-change-budget",
"--budget-steps",
"60000",
"--budget-consumed",
"495",
],
);
let mut members = vec![
deterministic.clone(),
probabilistic_exact.clone(),
stochastic.clone(),
monte_carlo.clone(),
heuristic.clone(),
];
let cross_backend_included = rustc_available();
if cross_backend_included {
let cross_backend = dir.join("06-cross-backend.json");
emit_member(
"cross-backend",
"decay_cross_backend.bld",
&cross_backend,
None,
&[
"--cross-backend",
"rust",
"--invariant",
"cross-backend",
"--problem",
"decay-cross-backend",
],
);
members.push(cross_backend);
} else {
eprintln!(
"five_modes_bind_into_one_chain: skipping the cross-backend link, rustc not available; chaining five members instead of six"
);
}
let chain = dir.join("chain.json");
let mut build_cmd = buildc();
build_cmd
.args(["receipt", "chain", "build"])
.args(&members)
.arg("-o")
.arg(&chain);
let build = build_cmd.output().expect("build the five-modes chain");
assert!(
build.status.success(),
"chain build should succeed\nstderr:\n{}",
String::from_utf8_lossy(&build.stderr)
);
let verify = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify the clean five-modes chain");
assert!(
verify.status.success(),
"the clean five-modes chain must verify\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr)
);
let mut body: serde_json::Value =
serde_json::from_slice(&fs::read(&stochastic).expect("read stochastic receipt"))
.expect("parse stochastic receipt");
let violation_count = body["invariant"]["observed"]["violation_count"]
.as_i64()
.unwrap_or(0);
body["invariant"]["observed"]["violation_count"] = serde_json::Value::from(violation_count + 1);
fs::write(&stochastic, serde_json::to_vec_pretty(&body).unwrap())
.expect("write tampered stochastic receipt");
let verify_tampered = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify the tampered five-modes chain");
assert!(
!verify_tampered.status.success(),
"a chain with a tampered member must fail"
);
assert!(
String::from_utf8_lossy(&verify_tampered.stderr).contains("CHAIN_LINK_UNVERIFIED"),
"editing a witnessed field without re-sealing must report CHAIN_LINK_UNVERIFIED\nstderr:\n{}",
String::from_utf8_lossy(&verify_tampered.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
fn units_fixture(name: &str) -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests")
.join("units")
.join(name)
}
#[test]
fn units_annotation_erases_to_byte_identical_c() {
let dir = std::env::temp_dir().join(format!("buildlang_units_byte_id_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create units byte-identity fixture dir");
let annotated_c = dir.join("annotated.c");
let plain_c = dir.join("plain.c");
let annotated = buildc()
.arg(units_fixture("units_velocity.bld"))
.args(["--target", "c", "-o"])
.arg(&annotated_c)
.output()
.expect("compile the unit-annotated fixture to C");
assert!(
annotated.status.success(),
"the unit-annotated fixture must compile to C\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&annotated.stdout),
String::from_utf8_lossy(&annotated.stderr)
);
let plain = buildc()
.arg(units_fixture("units_velocity_plain.bld"))
.args(["--target", "c", "-o"])
.arg(&plain_c)
.output()
.expect("compile the plain fixture to C");
assert!(
plain.status.success(),
"the plain fixture must compile to C\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&plain.stdout),
String::from_utf8_lossy(&plain.stderr)
);
let annotated_bytes = fs::read(&annotated_c).expect("read annotated C output");
let plain_bytes = fs::read(&plain_c).expect("read plain C output");
assert_eq!(
annotated_bytes, plain_bytes,
"a unit annotation must have ZERO codegen impact: the emitted C for \
`units_velocity.bld` and `units_velocity_plain.bld` must be byte-identical"
);
if c_backend_ready() {
let run_annotated = buildc()
.arg("run")
.arg(units_fixture("units_velocity.bld"))
.output()
.expect("run the unit-annotated fixture");
let run_plain = buildc()
.arg("run")
.arg(units_fixture("units_velocity_plain.bld"))
.output()
.expect("run the plain fixture");
assert!(
run_annotated.status.success() && run_plain.status.success(),
"both fixtures must run successfully\nannotated stderr:\n{}\nplain stderr:\n{}",
String::from_utf8_lossy(&run_annotated.stderr),
String::from_utf8_lossy(&run_plain.stderr)
);
assert_eq!(
run_annotated.stdout, run_plain.stdout,
"both fixtures must run with identical stdout"
);
} else {
eprintln!(
"skipping the run-output half of units_annotation_erases_to_byte_identical_c: \
C backend not ready"
);
}
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn units_check_receipt_clean_and_mismatch() {
let clean = buildc()
.arg("check")
.arg(units_fixture("units_velocity.bld"))
.args(["--receipt", "-"])
.output()
.expect("check the unit-annotated fixture with a receipt");
assert!(
clean.status.success(),
"the unit-annotated fixture must check clean\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&clean.stdout),
String::from_utf8_lossy(&clean.stderr)
);
let clean_receipt = receipt_from_stdout(&clean);
assert_eq!(clean_receipt["schema"], "buildlang-check-receipt/v1");
assert_eq!(clean_receipt["status"], "passed");
assert_eq!(
clean_receipt["diagnostics"].as_array().map(Vec::len),
Some(0),
"a program using the new syntax that checks OK must have no \
diagnostics: {clean_receipt:#?}"
);
let mismatch = buildc()
.arg("check")
.arg(units_fixture("units_mismatch.bld"))
.args(["--receipt", "-"])
.output()
.expect("check the mismatched-add fixture with a receipt");
assert!(
!mismatch.status.success(),
"a mismatched-dimension add must fail the check"
);
let mismatch_receipt = receipt_from_stdout(&mismatch);
assert_eq!(mismatch_receipt["schema"], "buildlang-check-receipt/v1");
assert_eq!(mismatch_receipt["status"], "failed");
let diagnostics = mismatch_receipt["diagnostics"]
.as_array()
.expect("diagnostics array");
assert_eq!(
diagnostics.len(),
1,
"expected exactly one diagnostic: {mismatch_receipt:#?}"
);
assert_eq!(diagnostics[0]["stage"], "type");
assert_eq!(diagnostics[0]["kind"], "UnitOperationMismatch");
assert_eq!(
diagnostics[0]["message"],
"unit mismatch: cannot add `m` and `s` (dimensions differ)"
);
}
fn model_receipt_golden_fixture_path() -> PathBuf {
repo_root()
.join("compiler")
.join("tests")
.join("fixtures")
.join("model-receipt-golden.json")
}
#[test]
fn model_receipt_golden_fixture_verifies_byte_identically() {
let verify = buildc()
.args(["receipt", "verify"])
.arg(model_receipt_golden_fixture_path())
.output()
.expect("verify golden model receipt");
assert!(
verify.status.success(),
"the golden model receipt must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let stdout = String::from_utf8_lossy(&verify.stdout);
assert!(
stdout.contains("VERIFIED"),
"human output should report VERIFIED\nstdout:\n{stdout}"
);
let verify_json = buildc()
.args(["receipt", "verify"])
.arg(model_receipt_golden_fixture_path())
.arg("--json")
.output()
.expect("verify golden model receipt --json");
assert!(
verify_json.status.success(),
"--json verify must also succeed"
);
let report = receipt_from_stdout(&verify_json);
assert_eq!(report["schema"], "buildlang-model-boundary-receipt/v0");
assert_eq!(report["status"], "verified");
assert_eq!(
report["seal"]["hex"],
"6bb2a09c47f5eaa2e3208a5eadcd6d57d1faffa74a567e024e920571c3794035"
);
}
#[test]
fn model_receipt_seal_mismatch_is_rejected() {
let mut receipt: serde_json::Value =
serde_json::from_slice(&fs::read(model_receipt_golden_fixture_path()).unwrap()).unwrap();
receipt["session"]["nonce"] = serde_json::Value::String("ffffffff".to_string());
let dir = std::env::temp_dir().join(format!("buildlang_model_seal_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let path = dir.join("tampered.json");
fs::write(&path, serde_json::to_vec_pretty(&receipt).unwrap()).unwrap();
let verify = buildc()
.args(["receipt", "verify"])
.arg(&path)
.output()
.expect("verify tampered model receipt");
assert!(
!verify.status.success(),
"an unsealed edit must fail verify"
);
assert!(
String::from_utf8_lossy(&verify.stderr).contains("failure_class: SEAL_MISMATCH"),
"an unsealed edit must report SEAL_MISMATCH\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn model_receipt_resealed_field_shape_violation_is_rejected() {
let mut receipt: serde_json::Value =
serde_json::from_slice(&fs::read(model_receipt_golden_fixture_path()).unwrap()).unwrap();
receipt["reply"] = serde_json::Value::Null;
let canonical = concat!(
r#"{"schema":"buildlang-model-boundary-receipt/v0","source":"model:echo:echo/v1","#,
r#""shim":{"name":"model_shim.py","version":"0.1.0","mode":"echo"},"#,
r#""session":{"listen":"127.0.0.1:8931","nonce":"a1b2c3d4","#,
r#""request_received_utc":"2026-07-29T00:00:00Z","reply_written_utc":"2026-07-29T00:00:00Z"},"#,
r#""prompt":{"sha256":"758d61f26a44448384e5c4468a0dcb7a2abe456067b0f7b505bc28b9411fe931","bytes":4},"#,
r#""reply":null,"model":{"name":"echo/v1"},"seed":{"status":"NOT_SENT"},"#,
r#""outcome":"COMPLETED","seal":{"algorithm":"sha256","hex":""}}"#,
);
receipt["seal"]["hex"] = serde_json::Value::String(sha256_hex(canonical.as_bytes()));
let dir = std::env::temp_dir().join(format!("buildlang_model_fcv_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let path = dir.join("resealed_bad_shape.json");
fs::write(&path, serde_json::to_vec_pretty(&receipt).unwrap()).unwrap();
let verify = buildc()
.args(["receipt", "verify"])
.arg(&path)
.output()
.expect("verify resealed field-shape violation");
assert!(
!verify.status.success(),
"a re-sealed COMPLETED-with-null-reply receipt must still fail verify"
);
assert!(
String::from_utf8_lossy(&verify.stderr).contains("failure_class: FIELD_CONTRACT_VIOLATION"),
"must report FIELD_CONTRACT_VIOLATION\nstderr:\n{}",
String::from_utf8_lossy(&verify.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn model_receipt_chain_build_refuses_before_the_allowlist_widening_check() {
let dir = std::env::temp_dir().join(format!(
"buildlang_model_chain_refuse_{}",
std::process::id()
));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let bogus = serde_json::json!({
"schema": "not-a-real-schema/v0",
"source": "nowhere",
"seal": { "algorithm": "sha256", "hex": "0".repeat(64) },
});
let a = dir.join("bogus.json");
fs::write(&a, serde_json::to_vec_pretty(&bogus).unwrap()).unwrap();
let b = model_receipt_golden_fixture_path();
let out = dir.join("chain.json");
let build = buildc()
.args(["receipt", "chain", "build"])
.arg(&a)
.arg(&b)
.arg("-o")
.arg(&out)
.output()
.expect("attempt chain build with a bogus schema member");
assert!(
!build.status.success(),
"chain build must refuse a member whose schema is neither allowlisted schema"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn model_receipt_chains_beside_a_scientific_receipt_and_tamper_breaks_it() {
if !c_backend_ready() {
eprintln!(
"skipping model_receipt_chains_beside_a_scientific_receipt_and_tamper_breaks_it: C backend not ready"
);
return;
}
let dir = std::env::temp_dir().join(format!("buildlang_model_chain_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
fs::create_dir_all(&dir).expect("create fixture dir");
let model_member = dir.join("model.json");
fs::copy(model_receipt_golden_fixture_path(), &model_member)
.expect("copy golden model receipt as chain member 0");
let model_member_original = fs::read(&model_member).expect("snapshot model member");
let sci_member = dir.join("sci.json");
let emit = buildc()
.arg("run")
.arg(repo_example("funnel_probe.bld"))
.args(["--emit-receipt"])
.arg(&sci_member)
.args([
"--invariant",
"non-negative",
"--metric",
"slack",
"--problem",
"disposer",
])
.output()
.expect("emit disposer receipt");
assert!(
emit.status.success(),
"emitting the disposer receipt should succeed"
);
let chain = dir.join("chain.json");
let build = buildc()
.args(["receipt", "chain", "build"])
.arg(&model_member)
.arg(&sci_member)
.arg("-o")
.arg(&chain)
.output()
.expect("build propose/dispose chain");
assert!(
build.status.success(),
"chaining a model receipt beside a scientific receipt must succeed\nstderr:\n{}",
String::from_utf8_lossy(&build.stderr)
);
let verify = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify propose/dispose chain");
assert!(
verify.status.success(),
"the clean propose/dispose chain must verify\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&verify.stdout),
String::from_utf8_lossy(&verify.stderr)
);
let mut tampered: serde_json::Value = serde_json::from_slice(&model_member_original).unwrap();
tampered["prompt"]["bytes"] = serde_json::Value::from(999);
fs::write(&model_member, serde_json::to_vec_pretty(&tampered).unwrap()).unwrap();
let verify_tampered = buildc()
.args(["receipt", "chain", "verify"])
.arg(&chain)
.output()
.expect("verify chain with a tampered model member");
assert!(
!verify_tampered.status.success(),
"a tampered model member must break the chain"
);
assert!(
String::from_utf8_lossy(&verify_tampered.stderr).contains("CHAIN_LINK_UNVERIFIED"),
"a model member whose body no longer re-seals must report CHAIN_LINK_UNVERIFIED\nstderr:\n{}",
String::from_utf8_lossy(&verify_tampered.stderr)
);
let _ = fs::remove_dir_all(&dir);
}
fn check_within(file: &Path, timeout_secs: u64) -> (std::process::ExitStatus, String, String) {
use std::io::Read;
let mut child = buildc()
.arg("check")
.arg(file)
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()
.expect("spawn buildc check");
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout_secs);
let status = loop {
if let Some(status) = child.try_wait().expect("poll buildc check") {
break status;
}
if std::time::Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
panic!(
"buildc check '{}' did not terminate within {timeout_secs}s -- \
module resolution likely regressed into unbounded recursion",
file.display()
);
}
std::thread::sleep(std::time::Duration::from_millis(20));
};
let mut stdout = String::new();
let mut stderr = String::new();
if let Some(mut out) = child.stdout.take() {
let _ = out.read_to_string(&mut stdout);
}
if let Some(mut err) = child.stderr.take() {
let _ = err.read_to_string(&mut stderr);
}
(status, stdout, stderr)
}
#[test]
fn check_file_module_named_after_its_file_terminates() {
let dir = std::env::temp_dir().join(format!("buildlang_filemod_{}", std::process::id()));
let _ = fs::create_dir_all(&dir);
let file = dir.join("benchmarks.bld");
fs::write(
&file,
"module benchmarks\n\npub fn main() -> i32 {\n return 0\n}\n",
)
.expect("write file-module fixture");
let (status, stdout, stderr) = check_within(&file, 30);
assert!(
status.success(),
"a file declaring `module <own filename>` must type-check, not hang or error\n\
stdout:\n{stdout}\nstderr:\n{stderr}"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_mod_self_import_cycle_fails_closed() {
let dir = std::env::temp_dir().join(format!("buildlang_modcycle_{}", std::process::id()));
let _ = fs::create_dir_all(&dir);
let file = dir.join("selfref.bld");
fs::write(
&file,
"mod selfref;\n\npub fn main() -> i32 {\n return 0\n}\n",
)
.expect("write mod-cycle fixture");
let (status, _stdout, stderr) = check_within(&file, 30);
assert!(
!status.success(),
"a self-importing `mod` must fail closed, not succeed"
);
assert!(
stderr.contains("cycle detected"),
"a module import cycle must report a diagnostic\nstderr:\n{stderr}"
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn check_parse_error_reports_line_and_column() {
let dir = std::env::temp_dir().join(format!("buildlang_parseloc_{}", std::process::id()));
let _ = fs::create_dir_all(&dir);
let file = dir.join("parseloc.bld");
fs::write(
&file,
"fn main() ~ Console {\n let x = 5\n println!(\"{}\", x);\n}\n",
)
.expect("write parse-location fixture");
let (status, _stdout, stderr) = check_within(&file, 30);
assert!(
!status.success(),
"a missing semicolon must fail closed\nstderr:\n{stderr}"
);
assert!(
stderr.contains(":3:5]:"),
"check must report the parse error at line 3, column 5\nstderr:\n{stderr}"
);
assert!(
stderr.contains("expected `;`"),
"the diagnostic must name the missing semicolon\nstderr:\n{stderr}"
);
assert!(
stderr.contains('^'),
"check must underline the offending token with a caret\nstderr:\n{stderr}"
);
let output = buildc()
.arg("check")
.arg(&file)
.arg("--receipt")
.arg("-")
.output()
.expect("run buildc check --receipt -");
let receipt: serde_json::Value =
serde_json::from_slice(&output.stdout).expect("stdout should be JSON receipt");
let parse_diag = receipt["diagnostics"]
.as_array()
.expect("diagnostics array")
.iter()
.find(|d| d["stage"] == "parse")
.expect("a parse diagnostic in the receipt");
assert_eq!(parse_diag["line"], 3, "receipt parse diagnostic line");
assert_eq!(parse_diag["col"], 5, "receipt parse diagnostic column");
assert_eq!(parse_diag["kind"], "ParseError");
assert!(
parse_diag["message"]
.as_str()
.unwrap_or_default()
.contains("expected `;`"),
"receipt message must name the missing semicolon: {parse_diag}"
);
let _ = fs::remove_dir_all(&dir);
}
fn format_macro_fixture(label: &str, source: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!(
"buildlang_format_first_arg_{}_{}",
label,
std::process::id()
));
fs::create_dir_all(&dir).expect("create format-macro fixture dir");
fs::write(dir.join("ops.toml"), "key = \"value-from-file\"\n").expect("write ops.toml");
let path = dir.join("main.bld");
fs::write(&path, source).expect("write format-macro fixture");
path
}
#[test]
fn check_rejects_format_macro_with_expression_first_arg() {
for (label, call) in [
("println", "println!(read_file(\"ops.toml\"));"),
("print", "print!(read_file(\"ops.toml\"));"),
("eprintln", "eprintln!(read_file(\"ops.toml\"));"),
("eprint", "eprint!(read_file(\"ops.toml\"));"),
(
"format",
"let s = format!(read_file(\"ops.toml\")); println!(\"{}\", s);",
),
] {
let source = format!("fn main() ~ Console + FileSystem {{\n {call}\n}}\n");
let fixture = format_macro_fixture(label, &source);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let stderr = String::from_utf8_lossy(&output.stderr);
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
!output.status.success(),
"{label}: a non-literal format argument must be rejected\nstdout:\n{stdout}\nstderr:\n{stderr}"
);
let all = format!("{stdout}{stderr}");
assert!(
all.contains(&format!("`{label}!` needs a plain string literal as its first argument, found an expression")),
"{label}: missing the format-argument diagnostic\n{all}"
);
assert!(
all.contains("placeholder"),
"{label}: missing the fix suggestion\n{all}"
);
}
}
#[test]
fn check_rejects_raw_string_format_string() {
let fixture = format_macro_fixture(
"raw",
"fn main() ~ Console {\n println!(r#\"raw text\"#);\n}\n",
);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
let all = format!(
"{}{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(
!output.status.success(),
"raw format string must be rejected\n{all}"
);
assert!(
all.contains("found a raw string literal"),
"missing raw-string diagnostic\n{all}"
);
}
#[test]
fn check_accepts_literal_format_strings_and_empty_println() {
let fixture = format_macro_fixture(
"ok",
"fn main() ~ Console + FileSystem {\n println!(\"{}\", read_file(\"ops.toml\"));\n let s = format!(\"{}-{}\", 1, 2);\n print!(\"{}\", s);\n println!();\n eprintln!(\"done\");\n}\n",
);
let output = buildc()
.arg("check")
.arg(&fixture)
.output()
.expect("run buildc check");
assert!(
output.status.success(),
"literal format strings must still check\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
}
#[test]
fn run_prints_file_contents_through_placeholder() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = format_macro_fixture(
"run",
"fn main() ~ Console + FileSystem {\n println!(\"{}\", read_file(\"ops.toml\"));\n}\n",
);
let output = buildc()
.current_dir(fixture.parent().unwrap())
.arg("run")
.arg(&fixture)
.output()
.expect("run buildc run");
let stdout = String::from_utf8_lossy(&output.stdout);
assert!(
output.status.success(),
"run failed\nstdout:\n{stdout}\nstderr:\n{}",
String::from_utf8_lossy(&output.stderr)
);
assert!(
stdout.contains("value-from-file"),
"file contents missing:\n{stdout}"
);
assert!(!stdout.contains("ops.toml"), "printed the path:\n{stdout}");
}
fn m1_fixture(label: &str, source: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("buildlang_m1_{}_{}", label, std::process::id()));
fs::create_dir_all(&dir).expect("create m1 fixture dir");
let path = dir.join("main.bld");
fs::write(&path, source).expect("write m1 fixture");
path
}
fn check_output(path: &Path) -> (bool, String) {
let output = buildc()
.arg("check")
.arg(path)
.output()
.expect("run buildc check");
let text = format!(
"{}{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
(output.status.success(), text)
}
fn run_stdout(path: &Path) -> String {
let output = buildc()
.current_dir(path.parent().unwrap())
.arg("run")
.arg(path)
.output()
.expect("run buildc run");
assert!(
output.status.success(),
"run failed\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
String::from_utf8_lossy(&output.stdout).replace("\r\n", "\n")
}
#[test]
fn check_rejects_a_method_the_c_backend_cannot_compile() {
let fixture = m1_fixture(
"parse",
"fn main() ~ Console {\n let s = \"42\";\n let n: i32 = s.parse().unwrap();\n println!(\"{}\", n);\n}\n",
);
let (ok, text) = check_output(&fixture);
assert!(
!ok,
"check must reject .parse() with no target type:\n{text}"
);
assert!(text.contains("`parse` needs its target type"), "{text}");
assert!(
text.contains("3:"),
"diagnostic should point at line 3:\n{text}"
);
assert!(
text.contains("help: write the type: `s.parse::<i32>()`"),
"{text}"
);
}
#[test]
fn for_over_iter_references_and_chars_runs_like_rust() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"forforms",
"fn main() ~ Console {\n let v = vec![1, 2, 3];\n let mut s = 0;\n for x in v.iter() { s += x; }\n for x in &v { s += x; }\n println!(\"{}\", s);\n for c in \"h\u{e9}!\".chars() { print!(\"{}|\", c); }\n println!(\"\");\n}\n",
);
assert_eq!(run_stdout(&fixture), "12\nh|\u{e9}|!|\n");
}
#[test]
fn while_let_pop_and_option_matches_stop_at_none() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"whilelet",
"use std::collections::HashMap;\nfn main() ~ Console {\n let mut v = vec![1, 2];\n while let Some(x) = v.pop() { println!(\"{}\", x); }\n match v.get(5) { Some(x) => println!(\"{}\", x), None => println!(\"none\") }\n let mut m: HashMap<String, i32> = HashMap::new();\n m.insert(String::from(\"a\"), 1);\n match m.get(\"b\") { Some(x) => println!(\"{}\", x), None => println!(\"missing\") }\n}\n",
);
assert_eq!(run_stdout(&fixture), "2\n1\nnone\nmissing\n");
}
#[test]
fn format_strings_print_like_rust() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"fmt",
"fn main() ~ Console {\n let x = 7;\n let name = \"bo\";\n println!(\"[{:>4}] [{:<4}] [{:04}] [{x}] [{0}{0}]\", x, x, x);\n println!(\"[{:5}] [{:>5}] [{name:?}]\", name, name);\n println!(\"{:x} {:#X} {:o} {:+}\", 255, 255, 8, 3);\n println!(\"{:?} {:?} {:.2}\", vec![1, 2], 2.0, 3.14159);\n let v = vec![\"a\", \"b\"];\n println!(\"{:?} {}\", v, true);\n}\n",
);
assert_eq!(
run_stdout(&fixture),
"[ 7] [7 ] [0007] [7] [77]\n[bo ] [ bo] [\"bo\"]\nff 0xFF 10 +3\n[1, 2] 2.0 3.14\n[\"a\", \"b\"] true\n"
);
}
#[test]
fn check_rejects_format_specs_the_c_backend_cannot_print() {
for (label, call) in [
("center", "println!(\"{:^5}\", 1);"),
("fill", "println!(\"{:*<5}\", 1);"),
("binary", "println!(\"{:b}\", 5);"),
("missing", "println!(\"{} {}\", 1);"),
("display_vec", "let v = vec![1];\n println!(\"{}\", v);"),
] {
let fixture = m1_fixture(
&format!("badfmt_{label}"),
&format!("fn main() ~ Console {{\n {call}\n}}\n"),
);
let (ok, text) = check_output(&fixture);
assert!(!ok, "{label}: check must reject\n{text}");
assert!(text.contains("help:"), "{label}: missing hint\n{text}");
}
}
#[test]
fn check_rejects_pushing_a_string_into_an_untyped_vector() {
let fixture = m1_fixture(
"vecpush",
"fn main() ~ Console {\n let mut nums = vec_new();\n vec_push(nums, 1);\n vec_push(nums, \"a\");\n println!(\"{}\", vec_len(nums));\n}\n",
);
let (ok, text) = check_output(&fixture);
assert!(
!ok,
"check must reject a str pushed into an i32 vector:\n{text}"
);
assert!(
text.contains("adds a `str` to a vector of `i32` elements"),
"{text}"
);
assert!(text.contains("let mut v: Vec<str> = vec_new();"), "{text}");
}
#[test]
fn annotated_vec_new_builds_a_string_vector() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"vecstr",
"fn main() ~ Console {\n let mut words: Vec<str> = vec_new();\n vec_push(words, \"alpha\");\n vec_push(words, \"beta\");\n let mut i = vec_len(words);\n while i > 0 {\n i -= 1;\n let w: str = vec_get(words, i);\n print!(\"{} \", w);\n }\n println!(\"\");\n}\n",
);
assert_eq!(run_stdout(&fixture).trim_end(), "beta alpha");
}
#[test]
fn string_ordering_and_borrowed_concat_compile_and_run() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"strops",
"fn main() ~ Console {\n let a = \"apple\";\n let b = \"banana\";\n if a < b { println!(\"lt\"); }\n if b >= a { println!(\"ge\"); }\n if \"ab\" < \"abc\" { println!(\"prefix\"); }\n let mut out = String::new();\n let w = \"x\".to_string();\n out = out + &w;\n out = out + &w;\n println!(\"{}\", out);\n}\n",
);
assert_eq!(run_stdout(&fixture), "lt\nge\nprefix\nxx\n");
}
#[test]
fn user_functions_named_like_c_macros_or_keywords_are_called() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"names",
"fn max(a: i32, b: i32) -> i32 { if a > b { a + 1000 } else { b + 1000 } }\nfn double(x: i32) -> i32 { x * 2 }\nfn main() ~ Console {\n println!(\"{}\", max(1, 2));\n println!(\"{}\", double(21));\n}\n",
);
assert_eq!(run_stdout(&fixture), "1002\n42\n");
}
#[test]
fn trait_with_a_self_returning_method_compiles() {
if !c_backend_ready() {
eprintln!("skipping: C backend not ready");
return;
}
let fixture = m1_fixture(
"selfret",
"trait Grow { fn grow(self, f: f64) -> Self; }\ntrait Val { fn val(self) -> f64; }\nstruct S { v: f64 }\nimpl Grow for S { fn grow(self, f: f64) -> S { S { v: self.v * f } } }\nimpl Val for S { fn val(self) -> f64 { self.v } }\nfn twice<T: Grow + Val>(x: T) -> f64 { let y = x.grow(2.0); y.val() }\nfn main() ~ Console {\n let s = S { v: 1.5 };\n println!(\"{}\", twice(s));\n}\n",
);
assert_eq!(run_stdout(&fixture), "3\n");
}