- CHANGELOG.md:v2.8.0 条目(中英双语); - README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明); - doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制); - skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/ require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过); - 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
839 lines
24 KiB
Rust
Executable File
839 lines
24 KiB
Rust
Executable File
//! `marqdo prove` P0 集成测试(roadmap/prove.md §6 A–H 矩阵的 P0 部分)。
|
||
//!
|
||
//! 全部不依赖 Lean:判定在 P1 接入,P0 只验「装载 → 降级 → 定型 → 确定性生成」。
|
||
//! 每个用例在 `target/` 下的独立临时目录里跑 CLI(与 `Commands::Check` 同款)。
|
||
|
||
use std::fs;
|
||
use std::path::{Path, PathBuf};
|
||
use std::process::Command;
|
||
|
||
struct Scratch {
|
||
dir: PathBuf,
|
||
}
|
||
|
||
impl Scratch {
|
||
fn new(name: &str) -> Self {
|
||
let target = std::env::var_os("CARGO_TARGET_DIR")
|
||
.map(PathBuf::from)
|
||
.unwrap_or_else(|| PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target"));
|
||
let dir = target.join("prove-tests").join(name);
|
||
let _ = fs::remove_dir_all(&dir);
|
||
fs::create_dir_all(&dir).expect("create scratch dir");
|
||
Self { dir }
|
||
}
|
||
|
||
/// 把 lib/result.mq.md 拷进临时项目(import 相对文档解析)。
|
||
fn provision_lib(&self) {
|
||
let src = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib/result.mq.md");
|
||
let dst = self.dir.join("lib/result.mq.md");
|
||
fs::create_dir_all(self.dir.join("lib")).expect("create lib dir");
|
||
fs::copy(&src, &dst).expect("copy lib/result.mq.md");
|
||
}
|
||
|
||
fn write(&self, rel: &str, content: &str) -> PathBuf {
|
||
let path = self.dir.join(rel);
|
||
if let Some(parent) = path.parent() {
|
||
fs::create_dir_all(parent).expect("create fixture parent");
|
||
}
|
||
fs::write(&path, content).expect("write fixture");
|
||
path
|
||
}
|
||
|
||
fn run(&self, args: &[&str]) -> Run {
|
||
let exe: &Path = Path::new(env!("CARGO_BIN_EXE_marqdo"));
|
||
let output = Command::new(exe)
|
||
.args(args)
|
||
.current_dir(&self.dir)
|
||
.env("MARQDO_RUNTIME_DIR", self.dir.join("runtime"))
|
||
.output()
|
||
.expect("run marqdo");
|
||
Run {
|
||
code: output.status.code().unwrap_or(1),
|
||
stdout: String::from_utf8_lossy(&output.stdout).to_string(),
|
||
stderr: String::from_utf8_lossy(&output.stderr).to_string(),
|
||
}
|
||
}
|
||
}
|
||
|
||
struct Run {
|
||
code: i32,
|
||
stdout: String,
|
||
stderr: String,
|
||
}
|
||
|
||
/// 审批样例(roadmap §7 / 设计 §2.5):分支 + 内联 result + 不透明 import。
|
||
const APPROVAL: &str = r#"---
|
||
markup: occlusion
|
||
import:
|
||
result: lib/result.mq.md
|
||
---
|
||
|
||
审批一个报销申请:大额必须人工审核,小额自动通过。
|
||
|
||
# 审批台
|
||
|
||
## 审批
|
||
+ `金额`
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
|---|---|---|
|
||
| 金额 | int | 申请金额(元) |
|
||
|
||
1. `金额` > 10000
|
||
**回执 = [提交人工审核](人工审核(金额=`金额`))**
|
||
**结果 = [保留结论](result.ok(value=[取值](access(`回执`, "value"))))**
|
||
2. *
|
||
**结果 = [自动通过](result.ok(value="auto"))**
|
||
|
||
*结果*
|
||
|
||
## 人工审核
|
||
+ `金额`
|
||
|
||
**回执 = [请求送审](工程.送审(金额=`金额`))**
|
||
|
||
*回执*
|
||
"#;
|
||
|
||
/// 倒计时:while 循环 → P0 拒绝(proof.while)。
|
||
const COUNTDOWN: &str = r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 倒计时器
|
||
|
||
## 倒数
|
||
+ `n`
|
||
|
||
**剩余 = `n`**
|
||
- `剩余` > 0
|
||
**剩余 = `剩余` - 1**
|
||
|
||
*剩余*
|
||
"#;
|
||
|
||
/// 分支后还有 return:两臂都必须带上后续(续延丢失回归测试)。
|
||
const BRANCH_THEN_RETURN: &str = r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 盒子
|
||
|
||
## 挑选
|
||
+ `n`
|
||
|
||
1. `n` > 0
|
||
**输出 = "正"**
|
||
2. *
|
||
**输出 = "负"**
|
||
|
||
*输出*
|
||
"#;
|
||
|
||
/// 裸未知名:动态调用 → 拒绝。
|
||
const UNKNOWN_CALL: &str = r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 神秘
|
||
|
||
## 执行
|
||
|
||
**回执 = [召唤](不存在的函数(`1`))**
|
||
|
||
*回执*
|
||
"#;
|
||
|
||
/// 带定理表的审批样例(roadmap §3 / 设计 §7.1;与设计文档示例同形)。
|
||
const APPROVAL_WITH_CLAIMS: &str = r#"---
|
||
markup: occlusion
|
||
import:
|
||
result: lib/result.mq.md
|
||
---
|
||
|
||
# 审批台
|
||
|
||
## 审批
|
||
+ `金额`
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
|---|---|---|
|
||
| 金额 | int | 申请金额(元) |
|
||
|
||
| 定理 | 结论 | 前提 | 策略 |
|
||
|---|---|---|---|
|
||
| 大额必经人工 | 包含(轨迹, "人工审核") | 金额 > 10000 | auto |
|
||
| 恒有结果 | 结果.ok = True | | auto |
|
||
|
||
1. `金额` > 10000
|
||
**回执 = [提交人工审核](人工审核(金额=`金额`))**
|
||
**结果 = [保留结论](result.ok(value=[取值](access(`回执`, "value"))))**
|
||
2. *
|
||
**结果 = [自动通过](result.ok(value="auto"))**
|
||
|
||
*结果*
|
||
|
||
## 人工审核
|
||
+ `金额`
|
||
|
||
**回执 = [请求送审](工程.送审(金额=`金额`))**
|
||
|
||
*回执*
|
||
"#;
|
||
|
||
fn read(dir: &Path, rel: &str) -> String {
|
||
fs::read_to_string(dir.join(rel)).unwrap_or_else(|e| panic!("read {rel}: {e}"))
|
||
}
|
||
|
||
#[test]
|
||
fn p0_a_emit_writes_deterministic_artifacts() {
|
||
let s = Scratch::new("a_deterministic");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r1 = s.run(&["prove", "approval.mq.md", "--emit", "out1"]);
|
||
assert_eq!(r1.code, 0, "emit1 stderr={}", r1.stderr);
|
||
let r2 = s.run(&["prove", "approval.mq.md", "--emit", "out2"]);
|
||
assert_eq!(r2.code, 0, "emit2 stderr={}", r2.stderr);
|
||
|
||
for rel in ["out1/plan.json", "out1/Generated/approval_mq.lean"] {
|
||
assert!(s.dir.join(&rel).is_file(), "missing {rel}");
|
||
}
|
||
// 确定性:两次 emit 字节一致(plan + lean)。
|
||
assert_eq!(
|
||
read(&s.dir, "out1/plan.json"),
|
||
read(&s.dir, "out2/plan.json"),
|
||
"plan.json must be byte-identical"
|
||
);
|
||
assert_eq!(
|
||
read(&s.dir, "out1/Generated/approval_mq.lean"),
|
||
read(&s.dir, "out2/Generated/approval_mq.lean"),
|
||
"lean module must be byte-identical"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn p0_b_json_contract_shape() {
|
||
let s = Scratch::new("b_json_shape");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&["prove", "approval.mq.md", "--report-only", "--json"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["schema"], 1);
|
||
assert_eq!(v["status"], "unverified");
|
||
assert_eq!(v["file"], "approval.mq.md");
|
||
assert!(v["source_sha256"].as_str().is_some_and(|h| h.len() == 64));
|
||
let functions = v["functions"].as_array().expect("functions array");
|
||
assert_eq!(functions.len(), 2, "对象不进报告,只有两个函数");
|
||
let names: Vec<&str> = functions
|
||
.iter()
|
||
.map(|f| f["name"].as_str().expect("name"))
|
||
.collect();
|
||
assert_eq!(names, vec!["审批台.审批", "审批台.人工审核"]);
|
||
for f in functions {
|
||
assert_eq!(f["tier"], "none", "P0 无判定层");
|
||
assert_eq!(f["status"], "unverified");
|
||
assert_eq!(f["claims"].as_array().map(Vec::len), Some(0));
|
||
}
|
||
// lean 尚未接入(P0 判定在 P1)。
|
||
assert!(v["lean"].is_null());
|
||
// emitted 为空(report-only)。
|
||
assert_eq!(v["emitted"].as_array().map(Vec::len), Some(0));
|
||
}
|
||
|
||
#[test]
|
||
fn p0_c_while_loop_rejected_with_code() {
|
||
let s = Scratch::new("c_while_rejected");
|
||
s.write("countdown.mq.md", COUNTDOWN);
|
||
let r = s.run(&["prove", "countdown.mq.md", "--report-only", "--json"]);
|
||
// 拒绝是建议性(exit 0),不阻断 agent。
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["status"], "rejected");
|
||
let f = &v["functions"][0];
|
||
assert_eq!(f["name"], "倒计时器.倒数");
|
||
assert_eq!(f["status"], "rejected");
|
||
let rejected = f["rejected"].as_array().expect("rejected array");
|
||
assert!(
|
||
rejected
|
||
.iter()
|
||
.any(|d| d["code"] == "proof.while"),
|
||
"expected proof.while, got {rejected:?}"
|
||
);
|
||
// 文本面也列出拒绝原因。
|
||
let t = s.run(&["prove", "countdown.mq.md", "--report-only"]);
|
||
assert!(t.stdout.contains("proof.while"), "text: {}", t.stdout);
|
||
}
|
||
|
||
#[test]
|
||
fn p0_d_side_effect_import_is_opaque_op() {
|
||
let s = Scratch::new("d_opaque_op");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||
// 工程外部调用:Op 构造器 + Env 查询 + 追踪,不展开。
|
||
assert!(lean.contains("«调用_工程.送审»"), "op ctor missing:\n{lean}");
|
||
assert!(lean.contains("env (Op.«调用_工程.送审»"), "env query missing");
|
||
assert!(lean.contains("[Op.«调用_工程.送审»"), "trace append missing");
|
||
// result.ok 内联为 Val 构造器,不是 Op。
|
||
assert!(!lean.contains("result.ok»"), "result.ok must inline, not be an Op");
|
||
assert!(lean.contains("mqResultOk"), "result.ok → mqResultOk");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_e_allow_opaque_downgrades_whole_function() {
|
||
let s = Scratch::new("e_allow_opaque");
|
||
s.write("countdown.mq.md", COUNTDOWN);
|
||
let r = s.run(&[
|
||
"prove",
|
||
"countdown.mq.md",
|
||
"--report-only",
|
||
"--json",
|
||
"--allow-opaque",
|
||
"倒计时器.倒数",
|
||
]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["status"], "unverified");
|
||
let f = &v["functions"][0];
|
||
assert_eq!(f["status"], "unverified");
|
||
let ops = f["ops"].as_array().expect("ops");
|
||
assert_eq!(ops.len(), 1, "整函数降级 = 单个 Op");
|
||
assert_eq!(ops[0]["id"], "调用:倒计时器.倒数");
|
||
assert_eq!(ops[0]["effect"], "opaque");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_f_branch_continuation_not_swallowed() {
|
||
let s = Scratch::new("f_continuation");
|
||
s.write("box.mq.md", BRANCH_THEN_RETURN);
|
||
let r = s.run(&["prove", "box.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/box_mq.lean");
|
||
// 分支后的 return 必须出现在两个臂里(回归:此前续延被分支吞掉)。
|
||
assert_eq!(
|
||
lean.matches("(«输出», «轨迹»)").count(),
|
||
2,
|
||
"return must appear in both arms:\n{lean}"
|
||
);
|
||
// 两臂各自绑定。
|
||
assert!(lean.contains("let «输出» := (Val.text \"正\")"), "{lean}");
|
||
assert!(lean.contains("let «输出» := (Val.text \"负\")"), "{lean}");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_g_mq_line_comments_and_guillemets() {
|
||
let s = Scratch::new("g_comments");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||
assert!(lean.contains("-- mq: "), "溯源注释缺失");
|
||
// 含点标识符用 guillemets。
|
||
assert!(lean.contains("«审批台.审批»"), "{lean}");
|
||
// 确定性来源:无时间戳、无绝对路径。
|
||
assert!(!lean.contains("marqdo/prove/"), "must not leak default dir");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_h_unknown_call_rejected() {
|
||
let s = Scratch::new("h_unknown");
|
||
s.write("mystery.mq.md", UNKNOWN_CALL);
|
||
let r = s.run(&["prove", "mystery.mq.md", "--report-only", "--json"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["status"], "rejected");
|
||
let rejected = v["functions"][0]["rejected"]
|
||
.as_array()
|
||
.expect("rejected array");
|
||
assert!(
|
||
rejected.iter().any(|d| d["code"] == "proof.dynamic_call"),
|
||
"expected proof.dynamic_call, got {rejected:?}"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn p0_i_report_only_writes_nothing() {
|
||
let s = Scratch::new("i_report_only");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&["prove", "approval.mq.md", "--report-only"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
assert!(
|
||
!s.dir.join(".marqdo").exists(),
|
||
"report-only must not create artifacts"
|
||
);
|
||
assert!(!r.stdout.contains("emitted:"), "no emitted lines");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_j_clean_removes_default_dir() {
|
||
let s = Scratch::new("j_clean");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&["prove", "approval.mq.md"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
assert!(s.dir.join(".marqdo/prove").exists(), "default emit dir");
|
||
let r = s.run(&["prove", "clean", "--json"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
assert!(r.stdout.contains("\"ok\":true"), "{}", r.stdout);
|
||
assert!(!s.dir.join(".marqdo/prove").exists(), "clean must remove dir");
|
||
}
|
||
|
||
#[test]
|
||
fn p0_k_branch_type_conflict_is_error() {
|
||
let s = Scratch::new("k_type_conflict");
|
||
s.write(
|
||
"conflict.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 冲突
|
||
|
||
## 挑选
|
||
+ `n`
|
||
|
||
| 参数 | 类型 | 说明 |
|
||
|---|---|---|
|
||
| n | int | 数值 |
|
||
|
||
1. `n` > 0
|
||
**输出 = `n`**
|
||
2. *
|
||
**输出 = "文字"**
|
||
|
||
*输出*
|
||
"#,
|
||
);
|
||
let r = s.run(&["prove", "conflict.mq.md", "--report-only", "--json"]);
|
||
// error → exit 1(§3.3)。
|
||
assert_eq!(r.code, 1, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["status"], "error");
|
||
let codes: Vec<&str> = v["diagnostics"]
|
||
.as_array()
|
||
.expect("diagnostics")
|
||
.iter()
|
||
.filter_map(|d| d["code"].as_str())
|
||
.collect();
|
||
assert!(
|
||
codes.iter().any(|c| *c == "proof.type_mismatch"),
|
||
"expected proof.type_mismatch, got {codes:?}"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn p0_l_only_filters_report() {
|
||
let s = Scratch::new("l_only");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL);
|
||
let r = s.run(&[
|
||
"prove",
|
||
"approval.mq.md",
|
||
"--report-only",
|
||
"--json",
|
||
"--only",
|
||
"审批台.人工审核",
|
||
]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
let functions = v["functions"].as_array().expect("functions");
|
||
assert_eq!(functions.len(), 1);
|
||
assert_eq!(functions[0]["name"], "审批台.人工审核");
|
||
}
|
||
|
||
// ============================================================ P1 · 定理表与 check --proof
|
||
|
||
/// 提取后的定理表:claims 非空、body 无该表(roadmap §3 第 1 周验收)。
|
||
#[test]
|
||
fn p1_a_claim_table_extracted_and_removed_from_body() {
|
||
let s = Scratch::new("p1_extract");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||
let r = s.run(&["prove", "approval.mq.md", "--report-only", "--json"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
let f = &v["functions"][0];
|
||
assert_eq!(f["name"], "审批台.审批");
|
||
let claims = f["claims"].as_array().expect("claims array");
|
||
assert_eq!(claims.len(), 2, "{claims:?}");
|
||
assert_eq!(claims[0]["id"], "大额必经人工");
|
||
assert_eq!(claims[0]["premise"], "金额 > 10000");
|
||
assert_eq!(claims[0]["conclusion"], "包含(轨迹, \"人工审核\")");
|
||
assert_eq!(claims[1]["id"], "恒有结果");
|
||
assert!(claims[1]["premise"].is_null(), "空前提 = 全称命题");
|
||
// 表从 body 移除:plan 的 steps 里没有表(函数照常降级)。
|
||
assert_eq!(f["status"], "unverified");
|
||
}
|
||
|
||
/// 定理脚手架进 Lean:受限文法命题 → theorem 陈述 + sorry 占位。
|
||
#[test]
|
||
fn p1_b_emit_theorem_scaffold() {
|
||
let s = Scratch::new("p1_theorem");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||
let r = s.run(&["prove", "approval.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/approval_mq.lean");
|
||
assert!(
|
||
lean.contains("theorem «审批台.审批.大额必经人工»"),
|
||
"{lean}"
|
||
);
|
||
// 前提进绑定;包含(轨迹, …) 翻成操作名成员测试。
|
||
assert!(lean.contains("(«h_前提» : mqTruth (mqGt «金额» (Val.int 10000)))"), "{lean}");
|
||
assert!(
|
||
lean.contains("((«轨迹».map Op.name).contains \"人工审核\")"),
|
||
"{lean}"
|
||
);
|
||
// 结果.ok → mqAccess 字段读取。
|
||
assert!(lean.contains("(mqAccess «结果» \"ok\")"), "{lean}");
|
||
// 策略脚本(§7.2):unfold → split → simp_all/omega。
|
||
assert!(lean.contains("unfold «审批台.审批» at h_run"), "{lean}");
|
||
assert!(
|
||
lean.contains("try split at h_run")
|
||
&& lean.contains("all_goals\n simp_all [mqTruth, Op.name, mqAccess, mqResultOk, mqResultError, mqValueOr, mqAnd, mqOr, mqNot, mqEq]"),
|
||
"{lean}"
|
||
);
|
||
}
|
||
|
||
/// check --proof(默认关):不传 --proof 时定理问题不报。
|
||
#[test]
|
||
fn p1_c_check_proof_off_by_default() {
|
||
let s = Scratch::new("p1_default_off");
|
||
s.write(
|
||
"bad.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 核对
|
||
+ `金额`
|
||
|
||
| 定理 | 结论 |
|
||
|---|---|
|
||
| 引用未知 | 额度 > 0 |
|
||
|
||
**x = `金额`**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["check", "bad.mq.md", "--json"]);
|
||
assert_eq!(r.code, 0, "默认关:{} {}", r.stdout, r.stderr);
|
||
assert!(
|
||
!r.stdout.contains("proof.claim_unknown_symbol"),
|
||
"默认必须不报:{}",
|
||
r.stdout
|
||
);
|
||
}
|
||
|
||
/// check --proof:unknown_symbol + duplicate + misplaced + malformed。
|
||
#[test]
|
||
fn p1_d_check_proof_diagnostic_codes() {
|
||
let s = Scratch::new("p1_codes");
|
||
s.write(
|
||
"bad.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 核对
|
||
+ `金额`
|
||
|
||
| 定理 | 结论 | 前提 | 策略 |
|
||
|---|---|---|---|
|
||
| 引用未知 | 长度(轨迹) = 额度 | 金额 > 0 | auto |
|
||
| 引用未知 | 长度(轨迹) = 额度 | 金额 > 0 | auto |
|
||
| 坏策略 | 结果.ok = True | | manual |
|
||
|
||
**x = `金额`**
|
||
|
||
| 定理 | 结论 |
|
||
|---|---|
|
||
| 错位表 | 结果.ok = True |
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["check", "bad.mq.md", "--proof", "--json"]);
|
||
assert_eq!(r.code, 1, "error 级诊断 → 退出 1:{}", r.stdout);
|
||
assert!(r.stdout.contains("proof.claim_unknown_symbol"), "{}", r.stdout);
|
||
assert!(r.stdout.contains("proof.claim_duplicate"), "{}", r.stdout);
|
||
assert!(r.stdout.contains("proof.claim_misplaced"), "{}", r.stdout);
|
||
assert!(r.stdout.contains("proof.claim_malformed"), "{}", r.stdout);
|
||
// 不该误报:策略 auto/none 之外的 malformed 只出现一次(坏策略行)。
|
||
assert_eq!(r.stdout.matches("proof.claim_malformed").count(), 1, "{}", r.stdout);
|
||
}
|
||
|
||
/// check --proof:保留名遮蔽(§7.3.4)。
|
||
#[test]
|
||
fn p1_e_check_proof_name_shadow() {
|
||
let s = Scratch::new("p1_shadow");
|
||
s.write(
|
||
"shadow.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 核对
|
||
+ `结果`
|
||
|
||
| 定理 | 结论 |
|
||
|---|---|
|
||
| 恒真 | 结果.ok = True |
|
||
|
||
**x = `结果`**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["check", "shadow.mq.md", "--proof", "--json"]);
|
||
assert_eq!(r.code, 1, "{}", r.stdout);
|
||
assert!(r.stdout.contains("proof.name_shadow"), "{}", r.stdout);
|
||
}
|
||
|
||
/// check --proof:歧义表(类型+结论)与谓词元数(§7.1 规则 5 / §7.3.5)。
|
||
#[test]
|
||
fn p1_f_check_proof_ambiguous_and_unsupported() {
|
||
let s = Scratch::new("p1_amb");
|
||
s.write(
|
||
"amb.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 核对
|
||
+ `金额`
|
||
|
||
| 定理 | 类型 | 结论 |
|
||
|---|---|---|
|
||
| 歧义 | int | 结果.ok = True |
|
||
|
||
**x = `金额`**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["check", "amb.mq.md", "--proof", "--json"]);
|
||
assert!(r.stdout.contains("proof.claim_ambiguous"), "{}", r.stdout);
|
||
|
||
let s2 = Scratch::new("p1_unsupported");
|
||
s2.write(
|
||
"bad2.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 核对
|
||
+ `金额`
|
||
|
||
| 定理 | 结论 | 策略 |
|
||
|---|---|---|
|
||
| 元数错 | 包含(轨迹, "a", "b") | auto |
|
||
|
||
**x = `金额`**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s2.run(&["check", "bad2.mq.md", "--proof", "--json"]);
|
||
assert!(r.stdout.contains("proof.claim_unsupported"), "{}", r.stdout);
|
||
}
|
||
|
||
/// 带定理的文件:emit 输出仍然确定性(plan.json + lean 两次一致)。
|
||
#[test]
|
||
fn p1_g_emit_with_claims_is_deterministic() {
|
||
let s = Scratch::new("p1_det");
|
||
s.provision_lib();
|
||
s.write("approval.mq.md", APPROVAL_WITH_CLAIMS);
|
||
s.run(&["prove", "approval.mq.md", "--emit", "out1"]);
|
||
s.run(&["prove", "approval.mq.md", "--emit", "out2"]);
|
||
assert_eq!(
|
||
read(&s.dir, "out1/Generated/approval_mq.lean"),
|
||
read(&s.dir, "out2/Generated/approval_mq.lean")
|
||
);
|
||
assert_eq!(read(&s.dir, "out1/plan.json"), read(&s.dir, "out2/plan.json"));
|
||
// plan.json 里定理声明带行号锚点。
|
||
let plan = read(&s.dir, "out1/plan.json");
|
||
assert!(plan.contains("\"claims\":[{"), "{plan}");
|
||
assert!(plan.contains("\"line\":16"), "{plan}");
|
||
}
|
||
|
||
// ============================================================ 审查修复的回归测试
|
||
|
||
/// 缺陷 1:表格单元格里的副作用调用必须被拒绝,不许静默丢弃
|
||
/// (静默丢弃会让含副作用的函数在 Lean 里伪装成"无操作")。
|
||
#[test]
|
||
fn p2_a_impure_call_in_table_cell_is_rejected() {
|
||
let s = Scratch::new("p2_impure_tbl");
|
||
s.write(
|
||
"record.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 副作用实验
|
||
|
||
## 记录
|
||
+ `名`
|
||
|
||
**数据 =**
|
||
| 步骤 |
|
||
|---|
|
||
| [落笔](工程.写(名=`名`)) |
|
||
| [收笔](工程.收(名=`名`)) |
|
||
|
||
**x = [取值](access(`数据`, "步骤"))**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["prove", "record.mq.md", "--report-only", "--json"]);
|
||
assert_eq!(r.code, 0, "拒绝是 advisory,exit 0:{}", r.stderr);
|
||
let v: serde_json::Value = serde_json::from_str(&r.stdout).expect("valid JSON");
|
||
assert_eq!(v["status"], "rejected", "{v}");
|
||
let rejected = serde_json::to_string(&v["functions"][0]["rejected"]).unwrap();
|
||
assert!(
|
||
rejected.contains("proof.unsupported"),
|
||
"必须有 proof.unsupported:{v}"
|
||
);
|
||
// 关键:函数里没有任何 Op(调用没被当作不透明操作处理)→ 整个函数拒绝。
|
||
assert_eq!(v["functions"][0]["ops"].as_array().map(Vec::len), Some(0));
|
||
}
|
||
|
||
/// 缺陷 2:同名不同元数的调用点 → `/元数` 后缀的独立 Op,构造器与使用一致。
|
||
#[test]
|
||
fn p2_b_op_arity_mismatch_gets_suffixed_ctor() {
|
||
let s = Scratch::new("p2_arity");
|
||
s.write(
|
||
"machine.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 机器
|
||
|
||
## 可选参数
|
||
+ `a`
|
||
+ `b` = 1
|
||
|
||
**r = [加一](自身.加一(a=`a`))**
|
||
**s = [加一](自身.加一(a=`a`, b=`b`))**
|
||
|
||
*r*
|
||
|
||
## 加一
|
||
+ `a`
|
||
+ `b` = 1
|
||
|
||
**t = `a` + `b`**
|
||
|
||
*t*
|
||
"#,
|
||
);
|
||
let r = s.run(&["prove", "machine.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/machine_mq.lean");
|
||
// 两个构造器,元数各自正确。
|
||
assert!(
|
||
lean.contains("| «调用_自身.加一» («参数1» : Val)"),
|
||
"{lean}"
|
||
);
|
||
assert!(
|
||
lean.contains("| «调用_自身.加一/2» («参数1» : Val) («参数2» : Val)"),
|
||
"{lean}"
|
||
);
|
||
// 使用点各自带对个数的实参。
|
||
assert!(lean.contains("Op.«调用_自身.加一» a)"), "{lean}");
|
||
assert!(lean.contains("Op.«调用_自身.加一/2» a b)"), "{lean}");
|
||
}
|
||
|
||
/// 缺陷 3:`长度(轨迹) = 2` 必须生成 Nat 比较,不是 mqEq(Nat≠Val)。
|
||
#[test]
|
||
fn p2_c_trace_length_claim_uses_nat_operators() {
|
||
let s = Scratch::new("p2_len");
|
||
s.provision_lib();
|
||
s.write(
|
||
"count.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
import:
|
||
result: lib/result.mq.md
|
||
---
|
||
|
||
# 轨迹计数
|
||
|
||
## 纯计算
|
||
+ `金额`
|
||
|
||
| 定理 | 结论 | 策略 |
|
||
|---|---|---|
|
||
| 空轨迹 | 长度(轨迹) = 0 | auto |
|
||
|
||
**a = [一步](result.ok(value=1))**
|
||
**b = [两步](result.ok(value=2))**
|
||
|
||
*b*
|
||
"#,
|
||
);
|
||
let r = s.run(&["prove", "count.mq.md", "--emit", "out"]);
|
||
assert_eq!(r.code, 0, "stderr={}", r.stderr);
|
||
let lean = read(&s.dir, "out/Generated/count_mq.lean");
|
||
assert!(
|
||
lean.contains("((«轨迹».length : Nat) = 0)"),
|
||
"Nat 比较:{lean}"
|
||
);
|
||
assert!(!lean.contains("mqEq («轨迹».length"), "不许出现类型不匹配:{lean}");
|
||
}
|
||
|
||
/// 缺陷 4:谓词名遮蔽整个模块只报一次;无关函数的形参不误报。
|
||
#[test]
|
||
fn p2_d_name_shadow_reported_once() {
|
||
let s = Scratch::new("p2_shadow");
|
||
s.write(
|
||
"audit.mq.md",
|
||
r#"---
|
||
markup: occlusion
|
||
---
|
||
|
||
# 审计
|
||
|
||
## 包含
|
||
+ `n`
|
||
|
||
**y = `n`**
|
||
|
||
*y*
|
||
|
||
## 核对
|
||
+ `金额`
|
||
|
||
| 定理 | 结论 |
|
||
|---|---|
|
||
| 恒真 | 结果.ok = True |
|
||
|
||
**x = `金额`**
|
||
|
||
*x*
|
||
"#,
|
||
);
|
||
let r = s.run(&["check", "audit.mq.md", "--proof", "--json"]);
|
||
assert_eq!(r.code, 1, "{}", r.stdout);
|
||
let count = r.stdout.matches("proof.name_shadow").count();
|
||
assert_eq!(count, 1, "只报一次:{}", r.stdout);
|
||
}
|