Files
cflmy 9331af78e2 release(2.8.0): 合入 CHANGELOG/README/发版说明/skills prove 任务;CI 链接指向 doc/releases
- 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。
2026-11-18 10:29:26 +08:00

4001 lines
103 KiB
Rust
Executable File
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use std::io::Write;
use std::process::{Command, Stdio};
fn run(args: &[&str]) -> (i32, String, String) {
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(args)
.output()
.expect("failed to run marqdo");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
(code, stdout, stderr)
}
fn run_with_stdin(args: &[&str], stdin: &str) -> (i32, String, String) {
let mut child = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("failed to spawn marqdo");
{
let mut pipe = child.stdin.take().expect("stdin");
pipe.write_all(stdin.as_bytes()).expect("write stdin");
}
let output = child.wait_with_output().expect("wait marqdo");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
(code, stdout, stderr)
}
fn run_with_env(args: &[&str], env: &[(&str, &str)]) -> (i32, String, String) {
let mut cmd = Command::new(env!("CARGO_BIN_EXE_marqdo"));
cmd.args(args);
for (k, v) in env {
cmd.env(k, v);
}
let output = cmd.output().expect("failed to run marqdo");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
(code, stdout, stderr)
}
fn assert_out(path: &str, expect: &str) {
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run(&["run", path, "--backend", backend]);
assert_eq!(code, 0, "{path} {backend} stderr={stderr}");
assert_eq!(stdout.trim_end(), expect.trim_end(), "{path} {backend}");
}
}
fn assert_run_ok(path: &str) {
for backend in ["tree", "bytecode"] {
let (code, _stdout, stderr) = run(&["run", path, "--backend", backend]);
assert_eq!(code, 0, "{path} {backend} stderr={stderr}");
}
}
/// Skip live LLM/agent tests when no real API key is configured.
fn live_llm_key() -> Option<String> {
for k in ["OPENAI_API_KEY", "MARQDO_LLM_API_KEY"] {
if let Ok(v) = std::env::var(k) {
let t = v.trim();
if !t.is_empty() && t != "sk-test" {
return Some(t.to_string());
}
}
}
None
}
/// Build Go `plugins/web/build/libweb.so` once per test process (W-G13).
/// Also sets `MARQDO_WEB_PLUGIN` so child `marqdo` processes do not pick up a
/// stale Rust `libweb.so` from `~/.marqdo/ext`.
fn ensure_web_plugin_built() {
use std::sync::Once;
static ONCE: Once = Once::new();
ONCE.call_once(|| {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let script = root.join("scripts").join("build-web-plugin.sh");
let status = Command::new("bash")
.arg(&script)
.current_dir(&root)
.status()
.expect("run scripts/build-web-plugin.sh");
assert!(
status.success(),
"failed to build Go libweb via scripts/build-web-plugin.sh"
);
let lib = if cfg!(windows) {
root.join("plugins").join("web").join("build").join("web.dll")
} else if cfg!(target_os = "macos") {
root.join("plugins")
.join("web")
.join("build")
.join("libweb.dylib")
} else {
root.join("plugins")
.join("web")
.join("build")
.join("libweb.so")
};
assert!(lib.is_file(), "missing Go web plugin at {}", lib.display());
// SAFETY: single-threaded Once; children inherit for the rest of the test process.
std::env::set_var("MARQDO_WEB_PLUGIN", &lib);
// Prefer repo `ext/` over a stale `~/.marqdo/ext` so new page methods (e.g. compose_list)
// are visible without requiring `marqdo ext add web` before gold.
if std::env::var_os("MARQDO_EXT").is_none() {
let ext = root.join("ext");
if ext.join("web").join("web.mq.md").is_file() {
std::env::set_var("MARQDO_EXT", &ext);
}
}
});
}
/// Build `libagent` once per test process and prefer it over a stale `~/.marqdo/ext`.
fn ensure_agent_plugin_built() {
use std::sync::Once;
static ONCE: Once = Once::new();
ONCE.call_once(|| {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(&root)
.status()
.expect("build marqdo_plugin_agent");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let lib = if cfg!(windows) {
root.join("target").join("debug").join("agent.dll")
} else if cfg!(target_os = "macos") {
root.join("target").join("debug").join("libagent.dylib")
} else {
root.join("target").join("debug").join("libagent.so")
};
// Prefer release if newer / present (local `cargo build --release -p …`).
let release = if cfg!(windows) {
root.join("target").join("release").join("agent.dll")
} else if cfg!(target_os = "macos") {
root.join("target").join("release").join("libagent.dylib")
} else {
root.join("target").join("release").join("libagent.so")
};
// Prefer the debug artifact we just built; only fall back to release if
// debug is missing (or release is strictly newer — local release workflows).
let chosen = if lib.is_file() {
if release.is_file() {
let lib_m = std::fs::metadata(&lib).and_then(|m| m.modified()).ok();
let rel_m = std::fs::metadata(&release).and_then(|m| m.modified()).ok();
match (lib_m, rel_m) {
(Some(l), Some(r)) if r > l => release,
_ => lib,
}
} else {
lib
}
} else {
release
};
assert!(chosen.is_file(), "missing agent plugin at {}", chosen.display());
// SAFETY: single-threaded Once; children inherit for the rest of the test process.
std::env::set_var("MARQDO_AGENT_PLUGIN", &chosen);
if std::env::var_os("MARQDO_EXT").is_none() {
let ext = root.join("ext");
if ext.join("ai").join("agent.mq.md").is_file() {
std::env::set_var("MARQDO_EXT", &ext);
}
}
});
}
/// Assert failure with `path:line:col:` prefix and message substring (both backends).
fn assert_err(path: &str, line_col: &str, substr: &str) {
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run(&["run", path, "--backend", backend]);
assert_ne!(
code, 0,
"{path} backend={backend} unexpectedly succeeded stdout={stdout}"
);
let loc = format!("{path}:{line_col}:");
assert!(
stderr.contains(&loc),
"{path} backend={backend} stderr missing location {loc:?}: {stderr}"
);
assert!(
stderr.contains(substr),
"{path} backend={backend} stderr missing {substr:?}: {stderr}"
);
}
}
/// Imported faults have an actual library origin and a separate authored call site.
fn assert_import_err(path: &str, library: &str, origin: &str, caller: &str, substr: &str) {
for backend in ["tree", "bytecode"] {
let (code, stdout, stderr) = run(&["run", path, "--backend", backend]);
assert_ne!(code, 0, "{path} backend={backend} unexpectedly succeeded stdout={stdout}");
let source = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(library);
let module = marqdo::load::load_module(&source).expect("load actual library origin");
let mut lines = Vec::new();
for function in &module.functions {
marqdo::ast::walk_stmts(function, &mut |statement| {
if let marqdo::ast::Stmt::Return { value, span } = statement {
let mut payload = value;
while let marqdo::ast::Expr::Occluded { payload: Some(inner), .. } = payload {
payload = inner;
}
if let marqdo::ast::Expr::Call(call) = payload {
if call.callee == origin { lines.push(span.line); }
}
}
});
}
assert_eq!(lines.len(), 1, "expected one instruction {origin} in {library}");
let origin = format!("{library}:{}:1:", lines[0]);
assert!(stderr.lines().next().unwrap_or("").contains(&origin),
"{path} backend={backend} missing actual library origin {origin:?}: {stderr}");
let caller = format!(" from {path}:{caller}");
assert!(stderr.lines().skip(1).any(|line| line.starts_with(" called ") && line.ends_with(&caller)),
"{path} backend={backend} missing authored call site {caller:?}: {stderr}");
assert!(stderr.contains(substr), "{path} backend={backend} stderr missing {substr:?}: {stderr}");
}
}
/// Like [`assert_out`], but sets a dummy OpenAI key so offline LLM/agent paths
/// that only check for the env var (no live HTTP) can proceed.
/// Also points `MARQDO_EXT` at the repo `ext/` so tests do not pick up a stale
/// `~/.marqdo/ext` pack ahead of in-tree sources.
fn assert_out_llm_offline(path: &str, expect: &str) {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let ext = root.join("ext");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", path])
.env("OPENAI_API_KEY", "sk-test")
.env("MARQDO_EXT", &ext)
.current_dir(&root)
.output()
.expect("failed to run marqdo");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "{path} stderr={stderr}");
assert_eq!(
stdout.trim_end(),
expect.trim_end(),
"{path} stdout={stdout}"
);
}
#[test]
fn structure_hello() {
assert_out("tests/structure/hello.mq.md", "Hello World!");
}
#[test]
fn structure_unbound_table() {
assert_out("tests/structure/unbound-table.mq.md", "ok");
}
#[test]
fn structure_object_handle() {
assert_out("tests/structure/object-handle.mq.md", "counter\n3\n4");
}
#[test]
fn structure_inherit_parent_method() {
assert_out(
"tests/structure/inherit-parent-method.mq.md",
"Loud
Hello, world!",
);
}
#[test]
fn structure_inherit_override() {
assert_out(
"tests/structure/inherit-override.mq.md",
"Hello, world!
HELLO, world!",
);
}
#[test]
fn structure_inherit_explicit_super() {
assert_out(
"tests/structure/inherit-explicit-super.mq.md",
"Child
child
Ada",
);
}
#[test]
fn bytecode_inherit_explicit_super() {
assert_out_backend(
"tests/structure/inherit-explicit-super.mq.md",
"bytecode",
"Child
child
Ada",
);
}
#[test]
fn structure_nested_call() {
assert_out("tests/structure/nested-call.mq.md", "Hello World!");
}
#[test]
fn structure_positional_call() {
assert_out(
"tests/structure/positional-call.mq.md",
"Hello Marqdo!\nHello World!",
);
}
#[test]
fn structure_branch() {
assert_out("tests/structure/branch.mq.md", "零");
}
#[test]
fn structure_branch_consecutive() {
assert_out(
"tests/structure/branch-consecutive.mq.md",
"A\nB\nelse-ok",
);
}
#[test]
fn structure_loop() {
assert_out(
"tests/structure/loop.mq.md",
"3
2
1
今天吃苹果
今天吃梨",
);
}
#[test]
fn structure_collection() {
assert_out("tests/structure/collection.mq.md", "苹果
梨
桃");
}
#[test]
fn structure_collection_map() {
assert_out(
"tests/structure/collection-map.mq.md",
"水果
蔬菜
数码用品
苹果
黄瓜
鼠标",
);
}
#[test]
fn structure_collection_map_list() {
assert_out(
"tests/structure/collection-map-list.mq.md",
"红富士
[红富士, 嘎啦]
黄瓜条",
);
}
#[test]
fn structure_collection_cell_expr() {
assert_out(
"tests/structure/collection-cell-expr.mq.md",
"sk-live
gpt-4o-mini
https://api.openai.com/v1
/chat/completions
sk-live
1/5
16/9",
);
}
#[test]
fn structure_gap_star_json_body() {
assert_out(
"tests/structure/gap-star-json-body.mq.md",
"1
1
7",
);
}
#[test]
fn structure_footnote_index() {
assert_out(
"tests/structure/footnote-index.mq.md",
"苹果
梨
桃",
);
}
#[test]
fn structure_link_index() {
assert_out("tests/structure/link-index.mq.md", "28\n18\n桃");
}
#[test]
fn structure_bracket_call() {
assert_out(
"tests/structure/bracket-call.mq.md",
"True, Marqdo!
False, Ada!
False, Hi Bo!!
28",
);
}
#[test]
fn bytecode_bracket_call() {
assert_out_backend(
"tests/structure/bracket-call.mq.md",
"bytecode",
"True, Marqdo!
False, Ada!
False, Hi Bo!!
28",
);
}
#[test]
fn structure_footnote_map_digits() {
assert_out(
"tests/structure/footnote-map-digits.mq.md",
"half
other",
);
}
#[test]
fn structure_interp_footnote_index() {
assert_out(
"tests/structure/interp-footnote-index.mq.md",
"苹果单价:5
第一种:红富士 结尾
引号内:\"价 3 元\"
梨 × 3",
);
}
#[test]
fn bytecode_interp_footnote_index() {
assert_out_backend(
"tests/structure/interp-footnote-index.mq.md",
"bytecode",
"苹果单价:5
第一种:红富士 结尾
引号内:\"价 3 元\"
梨 × 3",
);
}
#[test]
fn structure_collection_records() {
assert_out(
"tests/structure/collection-records.mq.md",
"{品名: 苹果, 数量: 2}
苹果
3
{品名: 苹果, 数量: 2}
{品名: 梨, 数量: 3}",
);
}
#[test]
fn structure_collection_records_at() {
assert_out(
"tests/structure/collection-records-at.mq.md",
"apple
3",
);
}
#[test]
fn structure_import() {
assert_out(
"tests/structure/import/main.mq.md",
"42
你好,Marqdo!",
);
}
#[test]
fn structure_ns_path3() {
assert_out(
"tests/structure/ns/path3.mq.md",
"ok
constructed",
);
}
#[test]
fn structure_ns_use() {
assert_out("tests/structure/ns/use.mq.md", "hi");
}
#[test]
fn bytecode_ns_path3() {
assert_out_backend(
"tests/structure/ns/path3.mq.md",
"bytecode",
"ok
constructed",
);
}
#[test]
fn bytecode_ns_use() {
assert_out_backend("tests/structure/ns/use.mq.md", "bytecode", "hi");
}
#[test]
fn structure_ns_associated_function() {
assert_out("tests/structure/ns/associated.mq.md", "associated\n701");
}
#[test]
fn bytecode_ns_associated_function() {
assert_out_backend(
"tests/structure/ns/associated.mq.md",
"bytecode",
"associated\n701",
);
}
#[test]
fn structure_new_path_stdlib() {
assert_out(
"tests/structure/new-path-stdlib.mq.md",
"3.1415926536",
);
}
#[test]
fn bytecode_new_path_stdlib() {
assert_out_backend(
"tests/structure/new-path-stdlib.mq.md",
"bytecode",
"3.1415926536",
);
}
#[test]
fn knowledge_resolve_new_path() {
let (code, stdout, stderr) = run(&[
"knowledge",
"tests/structure/ns",
"--json",
"resolve",
"helpers.Box.birth_year",
"--from",
"tests/structure/ns/associated.mq.md",
]);
assert_eq!(code, 0, "{stderr}");
let value: serde_json::Value = serde_json::from_str(&stdout).unwrap();
assert_eq!(value["resolution"], "symbol");
assert_eq!(value["symbol"]["callable"], "associated_function");
}
#[test]
fn knowledge_resolve_rejects_instance_path() {
let (code, stdout, stderr) = run(&[
"knowledge",
"tests/structure/ns",
"--json",
"resolve",
"helpers.Box.type_name",
"--from",
"tests/structure/ns/associated.mq.md",
]);
assert_eq!(code, 1, "{stderr}");
let value: serde_json::Value = serde_json::from_str(&stdout).unwrap();
assert_eq!(value["resolution"], "instance_only");
}
#[test]
fn error_ns_instance_method() {
assert_err(
"tests/errors/ns-instance-method.mq.md",
"10:1",
"instance method",
);
}
#[test]
fn error_legacy_gt_import() {
assert_err(
"tests/errors/legacy-gt-import.mq.md",
"3:1",
"legacy frontmatter import",
);
}
#[test]
fn error_legacy_oneliner_import() {
assert_err(
"tests/errors/legacy-oneliner-import.mq.md",
"3:1",
"legacy frontmatter import",
);
}
#[test]
fn structure_fn_end_hr() {
assert_out("tests/structure/fn-end-hr.mq.md", "Hello World!");
}
#[test]
fn structure_fn_end_empty_return() {
assert_out("tests/structure/fn-end-empty-return.mq.md", "Hi Marqdo!");
}
#[test]
fn structure_paragraph_comment() {
assert_out("tests/structure/paragraph-comment.mq.md", "ok");
}
#[test]
fn structure_narrative_bold() {
assert_out("tests/structure/narrative-bold.mq.md", "ok");
}
#[test]
fn structure_optional_param() {
assert_out(
"tests/structure/optional-param.mq.md",
"Hi, Ada!\nHello, Bob!",
);
}
#[test]
fn structure_meta_binding() {
let (code, stdout, stderr) = run(&[
"run",
"tests/structure/meta-binding.mq.md",
"--bind",
"extra=from-cli",
]);
assert_eq!(code, 0, "meta-binding stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"default-model\nHello World\n16\nsk-test\nfrom-cli"
);
}
#[test]
fn structure_meta_binding_env_and_secret() {
let (code, stdout, stderr) = run_with_env(
&[
"run",
"tests/structure/meta-binding.mq.md",
"--bind",
"model=from-bind",
],
&[
("MARQDO_META_MODEL", "from-env"),
("MARQDO_META_USER", "Ada"),
("MARQDO_META_TOKENS", "32"),
("MARQDO_META_SECRET", "s3cr3t"),
],
);
assert_eq!(code, 0, "meta-binding-env stderr={stderr}");
// --bind overlays model; secret displays as <secret>
assert_eq!(
stdout.trim_end(),
"from-bind\nHello Ada\n32\n<secret>\nno-extra"
);
}
#[test]
fn structure_meta_lift() {
let (code, stdout, stderr) = run(&["run", "tests/structure/meta-lift.mq.md"]);
assert_eq!(code, 0, "meta-lift stderr={stderr}");
assert_eq!(stdout.trim_end(), "lifted-model\nhi\nsk-lift");
}
#[test]
fn structure_meta_lift_secret_and_bytecode() {
let (code, stdout, stderr) = run_with_env(
&[
"run",
"--backend",
"bytecode",
"tests/structure/meta-lift.mq.md",
],
&[("MARQDO_LIFT_SECRET", "top-secret")],
);
assert_eq!(code, 0, "meta-lift-bc stderr={stderr}");
assert_eq!(stdout.trim_end(), "lifted-model\nhi\n<secret>");
}
#[test]
fn keywords_print() {
assert_out(
"tests/keywords/print.mq.md",
"named form\npositional",
);
}
#[test]
fn keywords_bool_logic() {
assert_out(
"tests/keywords/bool-logic.mq.md",
"ok\nnone-falsy",
);
}
#[test]
fn keywords_stdlib() {
assert_out(
"tests/keywords/stdlib.mq.md",
"5
3
42
42
1",
);
}
#[test]
fn bytecode_stdlib() {
assert_out_backend(
"tests/keywords/stdlib.mq.md",
"bytecode",
"5
3
42
42
1",
);
}
#[test]
fn keywords_stdlib_more() {
assert_out(
"tests/keywords/stdlib-more.mq.md",
"hi
3
b
a-b-c
list",
);
}
#[test]
fn bytecode_stdlib_more() {
assert_out_backend(
"tests/keywords/stdlib-more.mq.md",
"bytecode",
"hi
3
b
a-b-c
list",
);
}
#[test]
fn keywords_zh_builtins() {
assert_out(
"tests/keywords/zh-builtins.mq.md",
"5
7",
);
}
#[test]
fn bytecode_zh_builtins() {
assert_out_backend(
"tests/keywords/zh-builtins.mq.md",
"bytecode",
"5
7",
);
}
#[test]
fn keywords_zh_bool() {
assert_out(
"tests/keywords/zh-bool.mq.md",
"ok
none-falsy",
);
}
#[test]
fn bytecode_zh_bool() {
assert_out_backend(
"tests/keywords/zh-bool.mq.md",
"bytecode",
"ok
none-falsy",
);
}
#[test]
fn structure_import_lib() {
assert_out(
"tests/structure/import-lib.mq.md",
"x
2
a",
);
}
#[test]
fn bytecode_import_lib() {
assert_out_backend(
"tests/structure/import-lib.mq.md",
"bytecode",
"x
2
a",
);
}
#[test]
fn error_undefined_var() {
assert_err(
"tests/errors/undefined-var.mq.md",
"8:1",
"undefined variable `missing`",
);
}
#[test]
fn error_unknown_fn() {
assert_err(
"tests/errors/unknown-fn.mq.md",
"8:1",
"unknown function `no_such_fn`",
);
}
#[test]
fn error_bad_arity() {
assert_err(
"tests/errors/bad-arity.mq.md",
"8:1",
"missing argument for parameter `x`",
);
}
#[test]
fn error_table_arity() {
assert_err(
"tests/errors/table-arity.mq.md",
"13:1",
"table row arity mismatch",
);
}
#[test]
fn error_syntax_bad_line() {
assert_err(
"tests/errors/syntax-bad-line.mq.md",
"7:1",
"unrecognized statement",
);
}
/// 回归(qdagent labels 全仓扫描期间实测):孤立的 `*` 行曾令解析器 panic
/// (`begin <= end (1 <= 0)`,exit 101,整条 labels 扫描被一个文件打死)。
/// 修复后必须是干净的 `unrecognized statement` 诊断,而不是进程崩溃。
#[test]
fn error_lone_asterisk_line() {
assert_err(
"tests/errors/lone-asterisk.mq.md",
"9:1",
"unrecognized statement",
);
}
#[test]
fn error_div_zero() {
assert_err("tests/errors/div-zero.mq.md", "8:1", "division by zero");
}
#[test]
fn error_footnote_zero() {
assert_err(
"tests/errors/footnote-zero.mq.md",
"14:1",
"`[^0]` is invalid",
);
}
#[test]
fn error_footnote_oob() {
assert_err(
"tests/errors/footnote-oob.mq.md",
"14:1",
"out of range",
);
}
#[test]
fn error_footnote_missing_key() {
assert_err(
"tests/errors/footnote-missing-key.mq.md",
"14:1",
"missing map key",
);
}
#[test]
fn error_table_dup_header() {
assert_err(
"tests/errors/table-dup-header.mq.md",
"9:1",
"duplicate table header",
);
}
#[test]
fn error_table_row_marker_only() {
assert_err(
"tests/errors/table-row-marker-only.mq.md",
"9:1",
"row-oriented table needs field columns",
);
}
#[test]
fn error_inherit_cycle() {
assert_err(
"tests/errors/inherit-cycle.mq.md",
"6:1",
"cyclic inheritance",
);
}
#[test]
fn error_inherit_unknown_base() {
assert_err(
"tests/errors/inherit-unknown-base.mq.md",
"6:1",
"unknown base type",
);
}
#[test]
fn error_inherit_bad_rhs() {
assert_err(
"tests/errors/inherit-bad-rhs.mq.md",
"5:1",
"object inheritance requires",
);
}
#[test]
fn error_bad_int() {
assert_err(
"tests/errors/bad-int.mq.md",
"8:1",
"cannot convert to int",
);
}
#[test]
fn error_bad_split_sep() {
assert_err(
"tests/errors/bad-split-sep.mq.md",
"8:1",
"split sep must not be empty",
);
}
fn assert_out_backend(path: &str, backend: &str, expect: &str) {
let (code, stdout, stderr) = run(&["run", path, "--backend", backend]);
assert_eq!(code, 0, "{path} backend={backend} stderr={stderr}");
assert_eq!(
stdout.trim_end(),
expect.trim_end(),
"{path} backend={backend}"
);
}
fn assert_out_stdin(path: &str, backend: &str, stdin: &str, expect: &str) {
let (code, stdout, stderr) =
run_with_stdin(&["run", path, "--backend", backend], stdin);
assert_eq!(code, 0, "{path} backend={backend} stderr={stderr}");
assert_eq!(
stdout.trim_end(),
expect.trim_end(),
"{path} backend={backend} stdout={stdout:?}"
);
}
#[test]
fn keywords_input() {
assert_out_stdin(
"tests/keywords/input.mq.md",
"tree",
"Alice\n",
"Name:Hello Alice!",
);
}
#[test]
fn keywords_input_escape() {
for backend in ["tree", "bytecode"] {
assert_out_stdin(
"tests/keywords/input-escape.mq.md",
backend,
"Ada\n",
"Name:\nHello Ada!",
);
}
}
#[test]
fn keywords_quoted_string() {
assert_out(
"tests/keywords/quoted-string.mq.md",
"a\nb\nhex \" quote' single\n中文\nkeep \\q verbatim\nABC",
);
}
#[test]
fn keywords_input_stdin_file() {
let (code, stdout, stderr) = run(&[
"run",
"tests/keywords/input.mq.md",
"--stdin-file",
"tests/keywords/input-stdin.txt",
]);
assert_eq!(code, 0, "{stderr}");
assert_eq!(stdout.trim_end(), "Name:Hello Alice!");
}
#[test]
fn bytecode_input() {
assert_out_stdin(
"tests/keywords/input.mq.md",
"bytecode",
"Alice\n",
"Name:Hello Alice!",
);
}
#[test]
fn bytecode_hello() {
assert_out_backend(
"tests/structure/hello.mq.md",
"bytecode",
"Hello World!",
);
}
#[test]
fn bytecode_inherit_parent_method() {
assert_out_backend(
"tests/structure/inherit-parent-method.mq.md",
"bytecode",
"Loud
Hello, world!",
);
}
#[test]
fn bytecode_inherit_override() {
assert_out_backend(
"tests/structure/inherit-override.mq.md",
"bytecode",
"Hello, world!
HELLO, world!",
);
}
#[test]
fn bytecode_branch() {
assert_out_backend("tests/structure/branch.mq.md", "bytecode", "零");
}
#[test]
fn bytecode_branch_consecutive() {
assert_out_backend(
"tests/structure/branch-consecutive.mq.md",
"bytecode",
"A\nB\nelse-ok",
);
}
#[test]
fn bytecode_loop() {
assert_out_backend(
"tests/structure/loop.mq.md",
"bytecode",
"3
2
1
今天吃苹果
今天吃梨",
);
}
#[test]
fn bytecode_collection() {
assert_out_backend(
"tests/structure/collection.mq.md",
"bytecode",
"苹果
梨
桃",
);
}
#[test]
fn bytecode_collection_map() {
assert_out_backend(
"tests/structure/collection-map.mq.md",
"bytecode",
"水果
蔬菜
数码用品
苹果
黄瓜
鼠标",
);
}
#[test]
fn bytecode_collection_map_list() {
assert_out_backend(
"tests/structure/collection-map-list.mq.md",
"bytecode",
"红富士
[红富士, 嘎啦]
黄瓜条",
);
}
#[test]
fn bytecode_footnote_index() {
assert_out_backend(
"tests/structure/footnote-index.mq.md",
"bytecode",
"苹果
梨
桃",
);
}
#[test]
fn bytecode_collection_records() {
assert_out_backend(
"tests/structure/collection-records.mq.md",
"bytecode",
"{品名: 苹果, 数量: 2}
苹果
3
{品名: 苹果, 数量: 2}
{品名: 梨, 数量: 3}",
);
}
#[test]
fn bytecode_collection_records_at() {
assert_out_backend(
"tests/structure/collection-records-at.mq.md",
"bytecode",
"apple
3",
);
}
#[test]
fn bytecode_print_keyword() {
assert_out_backend(
"tests/keywords/print.mq.md",
"bytecode",
"named form\npositional",
);
}
#[test]
fn bytecode_bool_logic() {
assert_out_backend(
"tests/keywords/bool-logic.mq.md",
"bytecode",
"ok\nnone-falsy",
);
}
#[test]
fn bytecode_nested_call() {
assert_out_backend(
"tests/structure/nested-call.mq.md",
"bytecode",
"Hello World!",
);
}
#[test]
fn bytecode_positional_call() {
assert_out_backend(
"tests/structure/positional-call.mq.md",
"bytecode",
"Hello Marqdo!\nHello World!",
);
}
#[test]
fn bytecode_import() {
assert_out_backend(
"tests/structure/import/main.mq.md",
"bytecode",
"42
你好,Marqdo!",
);
}
#[test]
fn bytecode_fn_end_hr() {
assert_out_backend(
"tests/structure/fn-end-hr.mq.md",
"bytecode",
"Hello World!",
);
}
#[test]
fn bytecode_fn_end_empty_return() {
assert_out_backend(
"tests/structure/fn-end-empty-return.mq.md",
"bytecode",
"Hi Marqdo!",
);
}
#[test]
fn bytecode_paragraph_comment() {
assert_out_backend(
"tests/structure/paragraph-comment.mq.md",
"bytecode",
"ok",
);
}
#[test]
fn trace_eval_json_tree() {
let (code, stdout, stderr) = run(&["run", "tests/structure/hello.mq.md", "--backend", "tree", "--trace-eval"]);
assert_eq!(code, 0, "{stderr}");
assert_eq!(stdout.trim_end(), "Hello World!");
assert!(stderr.contains("\"event\":\"enter_fn\""), "{stderr}");
assert!(stderr.contains("\"event\":\"stmt\""), "{stderr}");
assert!(stderr.contains("\"span\":\"5:1\""), "{stderr}");
assert!(stderr.contains("\"event\":\"leave_fn\""), "{stderr}");
}
#[test]
fn structure_self_method_paths_are_instance_methods() {
assert_out("tests/structure/self-method-paths.mq.md", "41\n41\n7");
}
#[test]
fn structure_lexical_siblings_recursion_and_shadowing() {
assert_out("tests/structure/lexical-sibling-calls.mq.md", "120\n41\n99");
}
#[test]
fn error_lexical_private_descendant_is_not_visible() {
assert_err("tests/errors/lexical-private-descendant.mq.md", "6:1", "unknown function `concealed`");
}
#[test]
fn trace_eval_json_bytecode() {
let (code, stdout, stderr) = run(&[
"run",
"tests/structure/hello.mq.md",
"--backend",
"bytecode",
"--trace-eval",
]);
assert_eq!(code, 0, "{stderr}");
assert_eq!(stdout.trim_end(), "Hello World!");
assert!(stderr.contains("\"event\":\"op\""), "{stderr}");
assert!(stderr.contains("\"kind\":\"print\""), "{stderr}");
assert!(stderr.contains("\"span\":\"5:1\""), "{stderr}");
}
#[test]
fn catalog_writes_yaml() {
let dir = tempfile_dir("mq-cat");
let (code, _, stderr) = run(&[
"catalog",
"tests",
"-o",
dir.to_str().unwrap(),
"--no-knowledge",
]);
assert_eq!(code, 0, "{stderr}");
let yaml = std::fs::read_to_string(dir.join("catalog.yaml")).unwrap();
assert!(yaml.contains("type: Marqdo Catalog"));
assert!(yaml.contains("structure/hello"));
assert!(yaml.contains("utils.mq.md"), "{yaml}");
assert!(yaml.contains("concepts:"), "{yaml}");
let index = std::fs::read_to_string(dir.join("index.md")).unwrap();
assert!(index.contains("## Modules"), "{index}");
assert!(index.contains("## Agent knowledge"), "{index}");
// Import graph: structure/import/main depends on utils — clickable on module page.
let import_page = std::fs::read_to_string(
dir.join("modules")
.join("structure__import__main.md"),
)
.unwrap();
assert!(
import_page.contains("](") && import_page.contains("utils"),
"depends should link to utils module: {import_page}"
);
}
#[test]
fn knowledge_compile_engineering_fixture() {
let dir = tempfile_dir("mq-ekc");
let (code, _, stderr) = run(&[
"knowledge",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
]);
assert_eq!(code, 0, "{stderr}");
assert!(dir.join("catalog/repository.mq.md").exists());
// G01: SemanticProject owns graph/; EKC retrieval lives under ekc/.
assert!(dir.join("graph/edges.json").exists(), "semantic edges");
assert!(dir.join("ekc/graph/graph.json").exists(), "EKC retrieval graph");
assert!(dir.join("ekc/graph/edges.json").exists(), "EKC retrieval edges");
assert!(
!dir.join("graph/graph.json").exists(),
"EKC graph.json must not overwrite semantic graph/"
);
let edges: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(dir.join("graph/edges.json")).unwrap())
.unwrap();
assert_eq!(edges["authority"], "SemanticProject", "{edges}");
assert!(dir.join("steps.json").exists(), "semantic steps projection");
assert!(dir.join("engineering.yaml").exists());
assert!(dir.join("index.mq.md").exists());
let eng = std::fs::read_to_string(dir.join("engineering.yaml")).unwrap();
assert!(eng.contains("type: Marqdo Engineering Knowledge"), "{eng}");
assert!(eng.contains("capabilities:"), "{eng}");
assert!(
dir.join("knowledge/decisions").exists()
|| dir.join("knowledge/constraints").exists(),
"L4 knowledge dirs"
);
let caps: Vec<_> = std::fs::read_dir(dir.join("catalog/capabilities"))
.unwrap()
.flatten()
.collect();
assert!(!caps.is_empty(), "expected capability pages");
}
#[test]
fn knowledge_reuse_prefers_existing_capability() {
let dir = tempfile_dir("mq-reuse");
let (code, stdout, stderr) = run(&[
"reuse",
"resolve configuration",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
"--json",
]);
assert_eq!(code, 0, "{stderr}");
assert!(
stdout.contains("\"decision\":\"REUSE\"") || stdout.contains("\"decision\": \"REUSE\""),
"expected REUSE: {stdout}"
);
assert!(stdout.contains("create_allowed"), "{stdout}");
assert!(
stdout.contains("false") || stdout.contains("\"create_allowed\":false"),
"create should not be required: {stdout}"
);
}
#[test]
fn knowledge_find_surfaces_negative_knowledge() {
let dir = tempfile_dir("mq-find");
let (code, stdout, stderr) = run(&[
"find",
"JWT",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
"--json",
]);
assert_eq!(code, 0, "{stderr}");
assert!(
stdout.contains("AntiPattern") || stdout.contains("JWT") || stdout.contains("parse"),
"expected JWT anti-pattern hit: {stdout}"
);
}
#[test]
fn knowledge_duplicate_detects_merge_pair() {
let dir = tempfile_dir("mq-dup");
let (code, stdout, stderr) = run(&[
"duplicate",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
"--threshold",
"0.75",
"--json",
]);
assert_eq!(code, 0, "{stderr}");
assert!(
stdout.contains("merge_config") && stdout.contains("merge_settings"),
"expected merge_* duplicate pair: {stdout}"
);
}
#[test]
fn knowledge_verify_and_conflicts_and_stale() {
let dir = tempfile_dir("mq-verify");
for cmd in ["verify", "conflicts", "stale"] {
let (code, stdout, stderr) = run(&[
cmd,
"tests/engineering",
"-o",
dir.to_str().unwrap(),
"--json",
]);
assert_eq!(code, 0, "{cmd}: {stderr}");
assert!(!stdout.is_empty(), "{cmd} empty stdout");
}
}
#[test]
fn knowledge_impact_lists_capabilities() {
let dir = tempfile_dir("mq-impact");
let (code, stdout, stderr) = run(&[
"impact",
"config_resolve.mq.md",
"--root",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
"--json",
]);
assert_eq!(code, 0, "{stderr}");
assert!(
stdout.contains("config.resolve") || stdout.contains("capabilities"),
"{stdout}"
);
}
#[test]
fn knowledge_preflight_writes_context_pack() {
let dir = tempfile_dir("mq-pf");
let (code, stdout, stderr) = run(&[
"knowledge",
"tests/engineering",
"preflight",
"resolve configuration",
"-o",
dir.to_str().unwrap(),
"--json",
]);
assert_eq!(code, 0, "{stderr}\n{stdout}");
assert!(stdout.contains("create_allowed"), "{stdout}");
let ctx = dir.join("agent/contexts");
assert!(ctx.exists(), "contexts dir missing");
let packs: Vec<_> = std::fs::read_dir(&ctx).unwrap().flatten().collect();
assert!(!packs.is_empty(), "expected context pack");
}
#[test]
fn knowledge_preflight_warm_loads_ir_without_recompile() {
let dir = tempfile_dir("mq-pf-warm");
let out = dir.to_str().unwrap();
let (code, _, stderr) = run(&["knowledge", "tests/engineering", "-o", out]);
assert_eq!(code, 0, "{stderr}");
assert!(
dir.join("ekc/graph/ir.json").exists(),
"expected ir.json snapshot after compile"
);
let gens = dir.join("generations");
let before: Vec<_> = if gens.exists() {
std::fs::read_dir(&gens).unwrap().flatten().collect()
} else {
Vec::new()
};
let (code2, stdout, stderr2) = run(&[
"knowledge",
"tests/engineering",
"preflight",
"resolve configuration",
"-o",
out,
"--json",
]);
assert_eq!(code2, 0, "{stderr2}\n{stdout}");
assert!(stdout.contains("create_allowed"), "{stdout}");
assert!(
!stderr2.contains("marqdo knowledge timing_ms:"),
"warm preflight must not full-compile: {stderr2}"
);
let after: Vec<_> = if gens.exists() {
std::fs::read_dir(&gens).unwrap().flatten().collect()
} else {
Vec::new()
};
assert_eq!(
before.len(),
after.len(),
"warm preflight must not create a new generations/ tree"
);
}
#[test]
fn catalog_hooks_knowledge_by_default() {
let dir = tempfile_dir("mq-cat-ekc");
let (code, _, stderr) = run(&[
"catalog",
"tests/engineering",
"-o",
dir.to_str().unwrap(),
]);
assert_eq!(code, 0, "{stderr}");
assert!(dir.join("catalog.yaml").exists());
assert!(dir.join("engineering.yaml").exists());
assert!(dir.join("ekc/graph/graph.json").exists());
assert!(dir.join("graph/edges.json").exists());
}
#[test]
fn ext_mq_md_never_calls_host() {
// Hard rule: ext/**/*.mq.md must not invoke host_* (use lib/* or plugin names).
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ext");
let mut offenders = Vec::new();
fn walk(dir: &std::path::Path, out: &mut Vec<String>) {
let Ok(rd) = std::fs::read_dir(dir) else {
return;
};
for ent in rd.flatten() {
let p = ent.path();
if p.is_dir() {
walk(&p, out);
continue;
}
let name = p.file_name().and_then(|n| n.to_str()).unwrap_or("");
if !name.ends_with(".mq.md") {
continue;
}
let Ok(src) = std::fs::read_to_string(&p) else {
continue;
};
for (i, line) in src.lines().enumerate() {
let t = line.trim_start();
// Executable call lines / bindings that invoke host_*.
if (t.starts_with('>') || t.starts_with('*')) && t.contains("host_") {
out.push(format!("{}:{}: {line}", p.display(), i + 1));
}
}
}
}
walk(&root, &mut offenders);
assert!(
offenders.is_empty(),
"ext must not call host_* (use lib/* or agent_* plugin names):\n{}",
offenders.join("\n")
);
}
#[test]
fn catalog_includes_agent_kb_concepts() {
let dir = tempfile_dir("mq-cat-kb");
// Own the seed and scan root: other agent tests may create/delete their
// private .marqdo files concurrently under tests/ext.
ensure_agent_plugin_built();
let scan = tempfile_dir("mq-cat-kb-source");
let seed = scan.join("seed.mq.md");
std::fs::copy(
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/ext/agent-kb-reuse.mq.md"),
&seed,
).unwrap();
let (code, _, stderr) = run(&["run", seed.to_str().unwrap()]);
assert_eq!(code, 0, "seed kb via reuse test: {stderr}");
let (code, _, stderr) = run(&[
"catalog",
scan.to_str().unwrap(),
"-o",
dir.to_str().unwrap(),
"--no-knowledge",
]);
assert_eq!(code, 0, "{stderr}");
let yaml = std::fs::read_to_string(dir.join("catalog.yaml")).unwrap();
assert!(
yaml.contains("Marqdo Task") || yaml.contains("Marqdo Agent Skill"),
"expected agent-kb concepts in catalog: {yaml}"
);
assert!(
dir.join("concepts").join("tasks").exists()
|| dir.join("concepts").join("skills").exists(),
"concepts should be copied into catalog out dir"
);
let index = std::fs::read_to_string(dir.join("index.md")).unwrap();
assert!(
!index.contains("No `.marqdo/agent-kb` concepts"),
"{index}"
);
}
#[test]
fn view_output_writes_html() {
let dir = tempfile_dir("mq-site");
let (code, _, stderr) = run(&[
"view",
"output",
"tests/structure/hello.mq.md",
"-o",
dir.to_str().unwrap(),
"--no-exec",
]);
assert_eq!(code, 0, "{stderr}");
let index = std::fs::read_to_string(dir.join("index.html")).unwrap();
assert!(index.contains("marqdo"));
assert!(!index.contains("fonts.googleapis.com"));
assert!(index.contains("#ffffff") || index.contains("--surface: #ffffff"));
assert!(index.contains("nav-toggle"));
assert!(!index.contains("Run with input"), "static export should omit live stdin form");
let page = std::fs::read_to_string(dir.join("pages").join("hello.mq.md.html")).unwrap();
assert!(page.contains("katex.min.css"), "view layout should load KaTeX");
assert!(
!page.contains("name=\"stdin\""),
"hello has no input; no preset form"
);
assert!(dir.join("pages").join("hello.mq.md.html").exists());
}
#[test]
fn view_input_static_awaits_stdin() {
let dir = tempfile_dir("mq-input-view");
let (code, _, stderr) = run(&[
"view",
"output",
"tests/keywords/input.mq.md",
"-o",
dir.to_str().unwrap(),
]);
assert_eq!(code, 0, "{stderr}");
let page = std::fs::read_to_string(dir.join("pages").join("input.mq.md.html")).unwrap();
assert!(
page.contains("Fill preset input") || page.contains("status-pill pending"),
"should defer execution, not fail"
);
assert!(
!page.contains("input needs a line"),
"static export should not surface input error before stdin"
);
}
#[test]
fn lib_fs_read() {
assert_out("tests/lib/fs-read.mq.md", "exists\nhello-lib");
}
#[test]
fn lib_path_smoke() {
assert_out(
"tests/lib/path-smoke.mq.md",
"dir/sub/f.txt\nf.txt\ntxt\ndir/sub\na/c\nTrue\na|b|c",
);
}
#[test]
fn lib_path_smoke_zh() {
assert_out(
"tests/lib/路径-烟测.mq.md",
"dir/sub/f.txt\nf.txt\ntxt\na/c",
);
}
#[test]
fn lib_fs_copy_move() {
assert_out(
"tests/lib/fs-copy-move.mq.md",
"m2-body\nmoved\ntemp-ok",
);
}
#[test]
fn lib_fs_copy_zh() {
assert_out("tests/lib/文件-复制.mq.md", "zh-body");
}
#[test]
fn lib_hash_smoke() {
assert_out(
"tests/lib/hash-smoke.mq.md",
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\nba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad\n5d41402abc4b2a76b9719d911017c592\nf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8",
);
}
#[test]
fn lib_hash_smoke_zh() {
assert_out(
"tests/lib/哈希-烟测.mq.md",
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\n5d41402abc4b2a76b9719d911017c592",
);
}
#[test]
fn lib_secrets_smoke() {
assert_out("tests/lib/secrets-smoke.mq.md", "16\n12");
}
#[test]
fn lib_secrets_smoke_zh() {
assert_out("tests/lib/机密-烟测.mq.md", "16");
}
#[test]
fn lib_text_mid_smoke() {
assert_out(
"tests/lib/text-mid-smoke.mq.md",
"True\nAB\na_a_a\n...x\nababab",
);
}
#[test]
fn lib_text_mid_smoke_zh() {
assert_out("tests/lib/文本-加厚-烟测.mq.md", "True\nAB\na_a-a");
}
#[test]
fn lib_csv_smoke() {
assert_out(
"tests/lib/csv-smoke.mq.md",
"2\nalice\nhi, there\n2",
);
}
#[test]
fn lib_csv_smoke_zh() {
assert_out("tests/lib/逗号表-烟测.mq.md", "1\n1");
}
#[test]
fn lib_table_list_mid() {
assert_out(
"tests/lib/table-list-mid.mq.md",
"1,1,2,3\n1,2,3\n2\n2\na,b,1,2,3",
);
}
#[test]
fn lib_cli_sort_smoke() {
assert_out(
"tests/lib/cli-sort-smoke.mq.md",
"alice\ndata.csv\nTrue\nrest",
);
}
#[test]
fn lib_cli_zh_smoke() {
assert_out("tests/lib/表-命令行-烟测.mq.md", "a,b,c\n1\nTrue");
}
#[test]
fn lib_log_uuid_smoke() {
assert_out(
"tests/lib/log-uuid-smoke.mq.md",
"INFO hello-info\nDEBUG shown-debug\n36\nTrue",
);
}
#[test]
fn lib_log_uuid_zh_smoke() {
assert_out("tests/lib/日志-标识-烟测.mq.md", "INFO 中文信息\n36");
}
#[test]
fn lib_datetime_smoke() {
assert_out(
"tests/lib/datetime-smoke.mq.md",
"1970-01-01T00:00:00Z\n1970-01-01T08:00:00+08:00\n1577905445\n86400\n1970-01-01",
);
}
#[test]
fn lib_datetime_smoke_zh() {
assert_out(
"tests/lib/日期时间-烟测.mq.md",
"1970-01-01T00:00:00Z\n1970-01-01T08:00:00+08:00\n1577905445",
);
}
#[test]
fn lib_url_smoke() {
assert_out(
"tests/lib/url-smoke.mq.md",
"https\nexample.com\n8443\n/a/b\nx=1&y=2\nfrag\nhi x\n1\n2\na=1&a=2&b=hi%20x",
);
}
#[test]
fn lib_url_smoke_zh() {
assert_out(
"tests/lib/地址-烟测.mq.md",
"https\nexample.com\n/a\nx=1",
);
}
#[test]
fn lib_toml_html_encoding_smoke() {
assert_out(
"tests/lib/toml-html-encoding-smoke.mq.md",
"marqdo\n2\n1\na&lt;b&gt;&amp;&quot;c&#x27;\na<b>&\"c'\nNBSWY3DP\nhello",
);
}
#[test]
fn lib_toml_html_encoding_smoke_zh() {
assert_out(
"tests/lib/配置表-超文本-编码-烟测.mq.md",
"中文\nTrue\na&lt;b&gt;\nNBUQ====",
);
}
#[test]
fn lib_fs_mid2_smoke() {
assert_out(
"tests/lib/fs-mid2-smoke.mq.md",
"1\nTrue\nFalse\n3\na.txt\nnested\nnested/b.txt\nFalse",
);
}
#[test]
fn lib_fs_mid2_smoke_zh() {
assert_out("tests/lib/文件-mid2-烟测.mq.md", "True\n2\nFalse");
}
#[test]
fn lib_stats_log_smoke() {
assert_out(
"tests/lib/stats-log-smoke.mq.md",
"2.5\n2.5\n1.2909944487\nINFO hi user=alice n=3",
);
}
#[test]
fn lib_stats_log_smoke_zh() {
assert_out(
"tests/lib/统计-日志-烟测.mq.md",
"3\nINFO 你好 谁=甲 n=1",
);
}
#[test]
fn lib_re_smoke() {
assert_out(
"tests/lib/re-smoke.mq.md",
"True\n12\n1,22,333\naXbXc3\na|b|c",
);
}
#[test]
fn lib_re_smoke_zh() {
assert_out("tests/lib/正则-烟测.mq.md", "True\n12\n1,22,333");
}
#[test]
fn lib_encoding_smoke() {
assert_out(
"tests/lib/encoding-smoke.mq.md",
"aGVsbG8=\nhello\n6869\nhi",
);
}
#[test]
fn lib_encoding_smoke_zh() {
assert_out(
"tests/lib/编码-烟测.mq.md",
"aGVsbG8=\nhello\n6869\nhi",
);
}
#[test]
fn lib_fs_read_zh() {
assert_out("tests/lib/文件-读.mq.md", "存在\nhello-lib");
}
#[test]
fn lib_time_format() {
assert_out("tests/lib/time-format.mq.md", "1970-01-01\n0");
}
#[test]
fn lib_json_roundtrip() {
assert_out(
"tests/lib/json-roundtrip.mq.md",
"map\n1\n{\"a\":1,\"b\":\"x\"}",
);
}
#[test]
fn lib_json_vsafe_max_safe_ok() {
assert_out(
"tests/lib/json-vsafe-max-safe-ok.mq.md",
"9007199254740991\n{\"n\":9007199254740991}",
);
}
#[test]
fn lib_json_vsafe_string_ok() {
assert_out(
"tests/lib/json-vsafe-string-ok.mq.md",
"1152921504606846977",
);
}
#[test]
fn lib_json_vsafe_refuse() {
// Check both the actual library body and the user call, without mixing them.
assert_import_err(
"tests/lib/json-vsafe-refuse.mq.md",
"lib/json.mq.md",
"host_json_parse",
"10:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_json_vsafe_stringify_refuse() {
assert_import_err(
"tests/lib/json-vsafe-stringify-refuse.mq.md",
"lib/json.mq.md",
"host_json_stringify",
"11:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_table_collections() {
assert_out(
"tests/lib/table-collections.mq.md",
"Bearer-x\nA\nb\nhi\nTrue\n3\n[Authorization, role, content]\n0",
);
}
#[test]
fn lib_table_collections_zh() {
assert_out("tests/lib/表-集合.mq.md", "Bearer-x\nA\n3");
}
#[test]
fn lib_sys_cwd() {
assert_out("tests/lib/sys-cwd.mq.md", "cwd-ok");
}
#[test]
fn lib_sys_exec_capture() {
assert_out(
"tests/lib/sys-exec-capture.mq.md",
"exec-code-ok
capture-code-ok
capture-stdout-ok",
);
}
#[test]
fn lib_sys_dotenv() {
assert_out("tests/lib/sys-dotenv.mq.md", "loaded");
}
#[test]
fn lib_writeback_get() {
assert_out("tests/lib/writeback-get.mq.md", "hello-writeback");
}
#[test]
fn lib_subtask_spawn() {
assert_out("tests/lib/subtask-spawn.mq.md", "child_ok\ndone\nquiet-ok");
}
#[test]
fn lib_subtask_quiet_io() {
assert_out("tests/lib/subtask-quiet-io.mq.md", "quiet-io-ok");
}
#[test]
fn lib_subtask_fn() {
assert_out("tests/lib/subtask-fn.mq.md", "42");
}
#[test]
fn lib_subtask_foreign() {
if !python_available() {
eprintln!("skip lib_subtask_foreign: no python on PATH");
return;
}
assert_out("tests/lib/subtask-foreign.mq.md", "15");
}
#[test]
fn lib_json_quote() {
assert_out("tests/lib/json-quote.mq.md", "\"hi\"");
}
#[test]
fn lib_plugin_demo() {
let status = Command::new(env!("CARGO"))
.args(["build", "-p", "marqdo_plugin_demo"])
.status()
.expect("cargo build plugin demo");
assert!(status.success(), "failed to build marqdo_plugin_demo");
let lib_name = if cfg!(windows) {
"demo.dll"
} else if cfg!(target_os = "macos") {
"libdemo.dylib"
} else {
"libdemo.so"
};
let target_dir = std::env::var_os("CARGO_TARGET_DIR")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("target")
});
let built = target_dir.join("debug").join(lib_name);
assert!(
built.is_file(),
"missing plugin artifact {}",
built.display()
);
// Must live under the program's fs_root (`tests/lib/`) for path sandbox.
let plugin = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests")
.join("lib")
.join(lib_name);
std::fs::copy(&built, &plugin).expect("copy demo plugin into tests/lib");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/lib/plugin-demo.mq.md"])
.env("MARQDO_TEST_PLUGIN", lib_name)
.output()
.expect("failed to run marqdo");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "plugin-demo stderr={stderr}");
assert_eq!(stdout.trim_end(), "3\nok", "plugin-demo");
}
#[test]
fn ext_cli_add_list_remove_llm() {
let tmp = tempfile_dir("marqdo-ext-cli");
let src = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ext");
assert!(src.join("ai").join("llm.mq.md").is_file());
let bin = env!("CARGO_BIN_EXE_marqdo");
let status = Command::new(bin)
.args(["ext", "add", "llm"])
.env("MARQDO_EXT", &tmp)
.env("MARQDO_EXT_SOURCE", &src)
.env_remove("USERPROFILE")
.env_remove("HOME")
.status()
.expect("ext add");
assert!(status.success(), "ext add llm failed");
assert!(tmp.join("ai").join("llm.mq.md").is_file());
assert!(tmp.join("ai").join("大模型.mq.md").is_file());
let out = Command::new(bin)
.args(["ext", "list"])
.env("MARQDO_EXT", &tmp)
.output()
.expect("ext list");
assert_eq!(out.status.code().unwrap_or(1), 0);
let list = String::from_utf8_lossy(&out.stdout);
assert!(list.contains("llm") && list.contains("yes"), "list={list}");
let mq = tmp.join("smoke.mq.md");
std::fs::write(
&mq,
"---\nimport:\n llm: ext/ai/llm.mq.md\n---\n\n# main\n\n> print text=ext-cli-ok\n",
)
.unwrap();
let run = Command::new(bin)
.args(["run", mq.to_str().unwrap()])
.env("MARQDO_EXT", &tmp)
.output()
.expect("run smoke");
assert_eq!(
run.status.code().unwrap_or(1),
0,
"stderr={}",
String::from_utf8_lossy(&run.stderr)
);
assert_eq!(
String::from_utf8_lossy(&run.stdout).trim_end(),
"ext-cli-ok"
);
let status = Command::new(bin)
.args(["ext", "remove", "llm"])
.env("MARQDO_EXT", &tmp)
.status()
.expect("ext remove");
assert!(status.success());
assert!(!tmp.join("ai").join("llm.mq.md").is_file());
}
#[test]
fn ext_cli_add_agent() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let tmp = tempfile_dir("marqdo-ext-agent");
let src = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ext");
let bin = env!("CARGO_BIN_EXE_marqdo");
let status = Command::new(bin)
.args(["ext", "add", "agent"])
.env("MARQDO_EXT", &tmp)
.env("MARQDO_EXT_SOURCE", &src)
.env("MARQDO_EXT_NO_DOWNLOAD", "1")
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("ext add agent");
assert!(status.success(), "ext add agent failed");
assert!(tmp.join("ai").join("agent.mq.md").is_file());
assert!(tmp.join("ai").join("智能体.mq.md").is_file());
assert!(
tmp.join("native").join(if cfg!(windows) {
"agent.dll"
} else if cfg!(target_os = "macos") {
"libagent.dylib"
} else {
"libagent.so"
})
.is_file()
|| tmp.join("agent.plugin").is_file(),
"agent native plugin should be installed"
);
}
#[test]
fn ext_cli_add_web() {
ensure_web_plugin_built();
let tmp = tempfile_dir("marqdo-ext-web");
let src = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("ext");
let bin = env!("CARGO_BIN_EXE_marqdo");
let status = Command::new(bin)
.args(["ext", "add", "web"])
.env("MARQDO_EXT", &tmp)
.env("MARQDO_EXT_SOURCE", &src)
.env("MARQDO_EXT_NO_DOWNLOAD", "1")
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("ext add web");
assert!(status.success(), "ext add web failed");
assert!(tmp.join("web").join("web.mq.md").is_file());
assert!(tmp.join("web").join("网页.mq.md").is_file());
assert!(
tmp.join("native").join(if cfg!(windows) {
"web.dll"
} else if cfg!(target_os = "macos") {
"libweb.dylib"
} else {
"libweb.so"
})
.is_file()
|| tmp.join("web.plugin").is_file(),
"web native plugin should be installed"
);
}
#[test]
fn ext_web_artifact_document() {
assert_run_ok("tests/ext/web-artifact-doc.mq.md");
}
#[test]
fn ext_web_artifact_endpoint() {
assert_run_ok("tests/ext/web-artifact-endpoint.mq.md");
}
#[test]
fn ext_web_artifact_zh() {
assert_run_ok("tests/ext/web-artifact-zh.mq.md");
}
#[test]
fn ext_web_artifact_render_smoke() {
ensure_web_plugin_built();
assert_out(
"tests/ext/web-artifact-render-smoke.mq.md",
"render-nodes-ok
render-doc-ok
inspect-ok",
);
}
#[test]
fn ext_web_data_db_smoke() {
ensure_web_plugin_built();
assert_out("tests/ext/web-data-db-smoke.mq.md", "db-ok");
}
#[test]
fn ext_web_use_smoke() {
ensure_web_plugin_built();
assert_out("tests/ext/web-use-smoke.mq.md", "use-ok");
}
#[test]
fn ext_web_static_artifact_smoke() {
ensure_web_plugin_built();
assert_out(
"tests/ext/web-static-artifact-smoke.mq.md",
"dir-ok
mount-ok",
);
}
#[test]
fn ext_web_rbac_artifact_smoke() {
ensure_web_plugin_built();
assert_out("tests/ext/web-rbac-artifact-smoke.mq.md", "rbac-ok");
}
#[test]
fn ext_web_cache_artifact_smoke() {
ensure_web_plugin_built();
assert_out("tests/ext/web-cache-artifact-smoke.mq.md", "cache-ok");
}
#[test]
fn ext_web_artifact_endpoint_live() {
// Restricted CI/sandbox runners may disallow every listening socket. The
// static/artifact tests still exercise the feature there; this one only
// verifies the live HTTP boundary when the OS grants that capability.
if std::net::TcpListener::bind("127.0.0.1:0").is_err() {
eprintln!("skip ext_web_artifact_endpoint_live: local sockets are unavailable");
return;
}
ensure_web_plugin_built();
let bin = env!("CARGO_BIN_EXE_marqdo");
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let site = root.join("tests/ext/web-artifact-site");
let mut child = Command::new(bin)
.args(["run", "serve.mq.md"])
.current_dir(&site)
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("spawn artifact site");
let base = "http://127.0.0.1:18110";
let ready = std::time::Instant::now();
loop {
if ready.elapsed().as_secs() > 15 {
let _ = child.kill();
panic!("artifact site did not start");
}
let out = Command::new("curl")
.args(["-s", "-o", "/dev/null", "-w", "%{http_code}", &format!("{base}/")])
.output()
.expect("curl");
if String::from_utf8_lossy(&out.stdout) == "200" {
break;
}
std::thread::sleep(std::time::Duration::from_millis(200));
}
let about = Command::new("curl").args(["-s", &format!("{base}/about")]).output().unwrap();
let about_s = String::from_utf8_lossy(&about.stdout);
assert!(about_s.contains("About"), "about={about_s}");
let ping = Command::new("curl").args(["-s", &format!("{base}/api/ping")]).output().unwrap();
let ping_s = String::from_utf8_lossy(&ping.stdout);
assert!(
ping_s.contains("pong") || ping_s.contains("\"ok\""),
"ping={ping_s}"
);
let _ = child.kill();
}
#[test]
fn ext_agent_mcp_server_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-mcp-server-smoke.mq.md",
"mcp-tool-ok
mcp-fn-ok",
);
}
#[test]
fn ext_agent_mcp_client() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-mcp-client.mq.md",
"mcp-client-list-ok
mcp-client-call-ok",
);
}
#[test]
fn ext_agent_resume() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-resume.mq.md",
"resume-save-ok
resume-load-ok
resume-list-ok
resume-clear-ok
resume-gone-ok",
);
}
#[test]
fn ext_agent_small_llm_route() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-small-llm-route.mq.md",
"small-llm-ok
jev-alias-ok",
);
}
#[test]
fn ext_linalg_doc_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-doc-smoke.mq.md",
"B^T*A^T\nidentity-ok\ndeclare-ok\nraw-ok",
);
}
#[test]
fn ext_linalg_infix_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-infix-smoke.mq.md",
"A + B\nB^T*A^T\ntype-ok\nformula-add-ok",
);
}
#[test]
fn ext_linalg_metrics_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-metrics-smoke.mq.md",
"lstsq-ok\nnorm-ok\ncond-ok\nrank-ok\ncomplex-dtype-ok\ncomplex-norm-ok\ntheme-ok\ntheme-mark-ok",
);
let svg = std::fs::read_to_string("tests/ext/linalg-metrics-heat.svg").unwrap_or_default();
assert!(
svg.contains(r#"data-theme="dark""#) && svg.contains(r#"data-linalg="heatmap""#),
"expected themed heatmap svg"
);
}
#[test]
fn ext_linalg_factor_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-factor-smoke.mq.md",
"eig-kind-ok\neig-val-ok\ndraw-kind-ok\ndraw-mark-ok\nlu-solve-ok\nsvd-ok",
);
let svg = std::fs::read_to_string("tests/ext/linalg-factor-eig.svg").unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains(r#"data-linalg="eig""#),
"expected eig structure svg"
);
}
#[test]
fn ext_linalg_block_kron() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-block-kron.mq.md",
"A⊗B\nBlock[[A*A, A*B + B*A]; [0(2×2), A*A]]\nping-ok",
);
}
#[test]
fn ext_linalg_basic_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-basic-smoke.mq.md",
"det-ok\ntrace-ok\nsolve-ok\nexplicit-ok",
);
}
#[test]
fn ext_linalg_formula_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out(
"tests/ext/linalg-formula-smoke.mq.md",
"B^T*A^T\nping-ok",
);
}
#[test]
fn ext_linalg_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_linalg"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build linalg plugin");
assert!(status.success(), "failed to build marqdo_plugin_linalg");
assert_out("tests/ext/linalg-zh-smoke.mq.md", "B^T*A^T\n探测-ok");
}
#[test]
fn ext_quantum_bell_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-bell-smoke.mq.md",
"p00-ok
p11-ok
ping-ok",
);
}
#[test]
fn ext_quantum_gates_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-gates-smoke.mq.md",
"z-sandwich-ok
ry-ok
run-ok
shots-ok",
);
}
#[test]
fn ext_quantum_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-zh-smoke.mq.md", "zh-ok");
}
#[test]
fn ext_quantum_steps_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
let path = "tests/ext/quantum-steps-smoke.mq.md";
let (code, stdout, stderr) = run(&["run", path]);
assert_eq!(code, 0, "{path} stderr={stderr}");
assert!(
stdout.contains("steps-ok"),
"{path} missing steps-ok in {stdout}"
);
assert!(
stdout.contains("draw-ok"),
"{path} missing draw-ok in {stdout}"
);
let svg_path = "tests/ext/quantum-steps-draw.svg";
let svg = std::fs::read_to_string(svg_path).unwrap_or_default();
assert!(
svg.contains("<svg")
&& svg.contains("q0")
&& svg.contains(r#"data-theme="dark""#)
&& svg.contains("#0a0e14")
&& svg.contains("data-gate-family")
&& svg.contains("url(#mq-bg)"),
"{path} bad themed svg at {svg_path}: {svg}"
);
let _ = std::fs::remove_file(svg_path);
}
#[test]
fn ext_quantum_draw_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-draw-smoke.mq.md", "probs-ok\nbloch-ok");
for p in [
"tests/ext/quantum-draw-probs.svg",
"tests/ext/quantum-draw-bloch.svg",
] {
let svg = std::fs::read_to_string(p).unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains(r#"data-theme="dark""#),
"expected themed svg at {p}"
);
let _ = std::fs::remove_file(p);
}
}
#[test]
fn ext_quantum_gate_matrix_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-gate-matrix-smoke.mq.md",
"match-ok\nreject-ok",
);
}
#[test]
fn ext_quantum_author_api_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-author-api-smoke.mq.md",
"state-ok\ndraw-ok\nappend-ok",
);
let svg_path = "tests/ext/quantum-author-draw.svg";
let svg = std::fs::read_to_string(svg_path).unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains("stroke-dasharray"),
"expected barrier dashes in {svg_path}"
);
let _ = std::fs::remove_file(svg_path);
}
#[test]
fn ext_quantum_noise_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-noise-smoke.mq.md", "noise-ok");
}
#[test]
fn ext_quantum_gate_heatmap_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-gate-heatmap-smoke.mq.md", "heatmap-ok");
let svg_path = "tests/ext/quantum-gate-heatmap.svg";
let svg = std::fs::read_to_string(svg_path).unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains("H matrix"),
"expected matrix heatmap in {svg_path}"
);
let _ = std::fs::remove_file(svg_path);
}
#[test]
fn ext_quantum_author_api_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-author-api-zh-smoke.mq.md",
"state-ok\ndraw-ok\nappend-ok",
);
let svg_path = "tests/ext/quantum-author-zh-draw.svg";
let svg = std::fs::read_to_string(svg_path).unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains("stroke-dasharray"),
"expected barrier dashes in {svg_path}"
);
let _ = std::fs::remove_file(svg_path);
}
#[test]
fn ext_quantum_noise_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-noise-zh-smoke.mq.md", "noise-ok");
}
#[test]
fn ext_quantum_amp_damp_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-amp-damp-smoke.mq.md", "amp-ok");
}
#[test]
fn ext_quantum_amp_damp_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-amp-damp-zh-smoke.mq.md", "amp-ok");
}
#[test]
fn ext_quantum_custom_gate_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-custom-gate-smoke.mq.md", "custom-ok");
}
#[test]
fn ext_quantum_custom_gate_zh_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-custom-gate-zh-smoke.mq.md", "custom-ok");
}
#[test]
fn ext_quantum_linalg_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out(
"tests/ext/quantum-linalg-smoke.mq.md",
"purity-ok\nreduce-ok\nexpect-ok\nschmidt-ok",
);
}
#[test]
fn ext_quantum_viz_advanced_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_quantum"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build quantum plugin");
assert!(status.success(), "failed to build marqdo_plugin_quantum");
assert_out("tests/ext/quantum-viz-advanced-smoke.mq.md", "viz-ok");
for (p, marker) in [
("tests/ext/quantum-viz-hinton.svg", "data-hinton"),
("tests/ext/quantum-viz-qsphere.svg", "data-qsphere"),
("tests/ext/quantum-viz-multibloch.svg", "data-multibloch"),
("tests/ext/quantum-viz-city.svg", "data-city"),
] {
let svg = std::fs::read_to_string(p).unwrap_or_default();
assert!(
svg.contains("<svg") && svg.contains(marker),
"expected {marker} in {p}, got {} bytes",
svg.len()
);
let _ = std::fs::remove_file(p);
}
}
#[test]
fn ext_agent_framework_smoke() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/agent-smoke.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.current_dir(env!("CARGO_MANIFEST_DIR"))
.output()
.expect("run agent-smoke");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "agent-smoke stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"skill-ok\ntools-ok\nsource-ok\nprotocol-ok\n获取时间\n获取时间\nok-time\n2\n0\nmain",
"agent-smoke"
);
}
#[test]
fn ext_fs_text_patch() {
assert_out(
"tests/ext/fs-text-patch.mq.md",
"alpha BETA gamma\n2\nALPHA BETA GAMMA",
);
}
#[test]
fn ext_agent_inspect_workbook() {
assert_out(
"tests/ext/agent-inspect-fixture.mq.md",
"0\nok-slot\npending",
);
}
#[test]
fn ext_agent_plan_confirm() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/agent-plan-confirm.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.current_dir(env!("CARGO_MANIFEST_DIR"))
.output()
.expect("run agent-plan-confirm");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "agent-plan-confirm stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"pending\nworkbook-ok\nskeleton-ok",
"agent-plan-confirm"
);
}
#[test]
fn ext_agent_plan_decision() {
assert_out(
"tests/ext/agent-plan-decision.mq.md",
"DONE\nall good\nCONTINUE\nDONE\nRUN\nRUN\nDONE\ncall\nlib_catalog\nread\nstderr\ndecision\ncatalog-ok\ndual-ok\nsolidify-ok\nimport-ok\n1\nkeep new keep\n1\nALPHA beta",
);
}
#[test]
fn ext_agent_workbook_patch_a0() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-workbook-patch-a0.mq.md",
"1\n1\ncontinue-ok\nsolidify-ok\nstep-gone\nanswer-ok",
);
}
#[test]
fn ext_agent_kb_plan_hit() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-kb-plan-hit.mq.md",
"promoted\nlist-ok\nlist-free\nstable\nlist-desc\nhit\nexact\npong\nsum-exact\nevents-ok\ndecision\nREUSE\nsoft-hit\nnear\npong",
);
}
#[test]
fn ext_agent_context_budget_a3() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-context-budget-a3.mq.md",
"source-trunc\ndeep-still-trunc\nskill-ok\nread-skill-parse\nread-skill-ok\nctx-trunc\nctx-protocol",
);
}
#[test]
fn ext_agent_tools_rag_a4() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-tools-rag-a4.mq.md",
"auth-ok\ncorpus-hit\ntop-refunds\nmcp-list-ok\nmcp-call-ok\nmcp-auth-ok\nparent-corpus-ok",
);
}
#[test]
fn ext_agent_plan_observe() {
assert_out(
"tests/ext/agent-plan-observe.mq.md",
"excerpt-stripped\nhas-value-ok\nread-source-ok",
);
}
#[test]
fn ext_llm_complete_live() {
let Some(_key) = live_llm_key() else {
eprintln!("skip ext_llm_complete_live: no OPENAI_API_KEY / MARQDO_LLM_API_KEY");
return;
};
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-complete.mq.md"])
.output()
.expect("run llm-complete");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-complete stderr={stderr}");
let reply = stdout.trim_end().to_lowercase();
assert!(
reply.contains("pong"),
"expected pong in reply, got {stdout:?}"
);
}
#[test]
fn ext_llm_stream_live() {
let Some(_key) = live_llm_key() else {
eprintln!("skip ext_llm_stream_live: no OPENAI_API_KEY / MARQDO_LLM_API_KEY");
return;
};
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-stream-live.mq.md"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.output()
.expect("run llm-stream-live");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-stream-live stderr={stderr}");
let lines: Vec<&str> = stdout.trim_end().lines().collect();
assert!(
lines.len() >= 2,
"llm-stream-live expected echo line + count + answer, got {stdout:?}"
);
let answer = lines.last().unwrap().to_lowercase();
assert!(
answer.contains("pong"),
"expected pong in streamed answer, got {stdout:?}"
);
let n: usize = lines[lines.len() - 2]
.parse()
.unwrap_or(0);
assert!(n >= 2, "expected at least delta+done events, n={n} stdout={stdout:?}");
}
#[test]
fn ext_agent_run_live() {
let Some(_key) = live_llm_key() else {
eprintln!("skip ext_agent_run_live: no OPENAI_API_KEY / MARQDO_LLM_API_KEY");
return;
};
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/agent-run-live.mq.md"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.output()
.expect("run agent-run-live");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "agent-run-live stderr={stderr}");
let lines: Vec<&str> = stdout.trim_end().lines().collect();
assert!(lines.len() >= 4, "agent-run-live stdout={stdout}");
assert!(
lines[0].chars().any(|c| c.is_ascii_digit()),
"expected date in reply, got {:?}",
lines[0]
);
assert_eq!(lines[1], "writeback-ok", "named ok slot after step");
assert_eq!(lines[2], "2", "history after step");
assert_eq!(lines[3], "0", "history after clear");
// Default step writeback persists the result map under the ok/error slots.
let src = std::fs::read_to_string(
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/ext/agent-run-live.mq.md"),
)
.expect("read agent-run-live after run");
assert!(
src.contains("\"status\"") || src.contains("marqdo-out"),
"expected writeback of step result map"
);
assert!(
!stdout.contains("marqdo-out"),
"writeback must not be printed to stdout"
);
}
#[test]
fn ext_agent_plan_live() {
let Some(_key) = live_llm_key() else {
eprintln!("skip ext_agent_plan_live: no OPENAI_API_KEY / MARQDO_LLM_API_KEY");
return;
};
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/agent-plan-live.mq.md"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.output()
.expect("run agent-plan-live");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "agent-plan-live stderr={stderr}");
let lines: Vec<&str> = stdout.trim_end().lines().collect();
assert!(
lines.iter().any(|l| *l == "ok"),
"agent-plan-live missing ok: stdout={stdout}"
);
assert!(
lines.iter().any(|l| *l == "workbook-ok"),
"agent-plan-live missing workbook-ok: stdout={stdout}"
);
assert!(
lines.iter().filter(|l| **l == "hit").count() >= 1,
"agent-plan-live expected OKF hit: stdout={stdout}"
);
}
#[test]
fn ext_agent_kb_reuse() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
let goal = "Reply with exactly the word pong and nothing else.";
let mut h: u64 = 5381;
for b in goal.as_bytes() {
h = h.wrapping_mul(33).wrapping_add(u64::from(*b));
}
let sig = format!("{h:016x}")[..12].to_string();
let slug = "reply-with-exactly-the-word-pong-and-nothing-els";
// Default file-subtask quiet: no child print on parent stdout; answer via wait.value.
let expect = format!("{sig}\n{slug}\npromoted\nstable\n{slug}\nlookup-ok\n0\npong\nstable-path");
assert_out("tests/ext/agent-kb-reuse.mq.md", &expect);
}
#[test]
fn ext_agent_kb_alias() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-kb-alias.mq.md",
"promoted
alias-written
alias-ok
alias
same-slug
exact
trip-promoted
帮我规划明天的行程
canonical-ok
canonical
list-ok",
);
}
#[test]
fn ext_agent_kb_near() {
let status = Command::new("cargo")
.args(["build", "-p", "marqdo_plugin_agent"])
.current_dir(env!("CARGO_MANIFEST_DIR"))
.status()
.expect("build agent plugin");
assert!(status.success(), "failed to build marqdo_plugin_agent");
assert_out(
"tests/ext/agent-kb-near.mq.md",
"promoted
near-ok
near
same-slug
off-miss
neg-miss
rank-ok
prompt-score-ok",
);
}
#[test]
fn ext_agent_soft_match() {
assert_out(
"tests/ext/agent-soft-match.mq.md",
"REUSE
trip-plan
NEW
REUSE
行程-a
prompt-ok",
);
}
#[test]
fn ext_agent_lib_call() {
assert_out(
"tests/ext/agent-lib-call.mq.md",
"call
lib.fs.exists
exists-ok
deny-ok
callable-ok",
);
}
#[test]
fn ext_agent_v2_learn() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-v2-learn.mq.md",
"ep-ok
3
learned
llm-free
3",
);
}
#[test]
fn ext_agent_p4_route() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-p4-route.mq.md",
"skill-learned
policy-ok
route-hit
auto/marqdo",
);
}
#[test]
fn ext_agent_plan_preserve() {
ensure_agent_plugin_built();
assert_out_llm_offline(
"tests/ext/agent-plan-preserve.mq.md",
"pending
True
False",
);
}
#[test]
fn ext_agent_zero_llm() {
ensure_agent_plugin_built();
assert_out_llm_offline(
"tests/ext/agent-zero-llm.mq.md",
"compiled
0",
);
}
#[test]
fn ext_ai_sandbox_cow() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/sandbox-cow.mq.md",
"2
seed-lower
False
brand-new
False
brand-new",
);
}
#[test]
fn ext_ai_sandbox_run_lib() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/sandbox-run-lib.mq.md",
"True
1",
);
}
#[test]
fn ext_ai_sandbox_deny() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/sandbox-deny.mq.md",
"False
deny-ok
inspect-ok",
);
}
#[test]
fn ext_ai_agent_sandbox_optin() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-sandbox-optin.mq.md",
"True
False
False
True
True
optin-ok
default",
);
}
#[test]
fn ext_ai_agent_sandbox_promote() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-sandbox-promote.mq.md",
"True
False
sandbox_proof_failed",
);
}
#[test]
fn ext_ai_agent_step_route() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-step-route.mq.md",
"marqdo
llm
auto",
);
}
#[test]
fn ext_ai_agent_sandbox_quarantine() {
ensure_agent_plugin_built();
assert_out(
"tests/ext/agent-sandbox-quarantine.mq.md",
"True
True
quarantine",
);
}
#[test]
fn ext_llm_named_offline() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-named-offline.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.env("MARQDO_EXT", root.join("ext"))
.env_remove("OPENAI_MODEL")
.env_remove("MARQDO_LLM_MODEL")
.env_remove("MARQDO_LLM_FAST_MODEL")
.env_remove("MARQDO_LLM_REASONING_MODEL")
.current_dir(&root)
.output()
.expect("run llm-named-offline");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-named-offline stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"fast
qwen-fast-test
reasoning
gpt-reason-test
ollama
llama3.2
True
False",
"stdout={stdout}"
);
}
#[test]
fn lib_net_encode() {
assert_out("tests/lib/net-encode.mq.md", "a%20b");
}
#[test]
fn lib_net_cookie_parse() {
assert_out(
"tests/lib/net-cookie.mq.md",
"session\nabc123\nTrue\nTrue\nLax\n3600",
);
}
#[test]
fn lib_net_multipart_parse() {
assert_out(
"tests/lib/net-multipart.mq.md",
"title\nHello\nfile\na.txt\ntext/plain\nfile body",
);
}
#[test]
fn lib_net_markdown_parse() {
assert_out(
"tests/lib/net-markdown.mq.md",
"markdown-ok",
);
}
#[test]
fn lib_net_openai_sse() {
assert_out(
"tests/lib/net-openai-sse.mq.md",
"Hel
lo
Hello",
);
}
#[test]
fn lib_net_openai_sse_reasoning() {
assert_out(
"tests/lib/net-openai-sse-reasoning.mq.md",
"3
reasoning
think
delta
Hi
done
Hi",
);
}
#[test]
fn ext_llm_stream_offline() {
assert_out("tests/ext/llm-stream-offline.mq.md", "Hi!");
}
#[test]
fn ext_llm_ask_offline() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-ask-offline.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.env("MARQDO_EXT", root.join("ext"))
.env_remove("OPENAI_MODEL")
.env_remove("MARQDO_LLM_MODEL")
.current_dir(&root)
.output()
.expect("run llm-ask-offline");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-ask-offline stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"gpt-4o-mini\nopenai-compatible\nHi!\nHi!",
"stdout={stdout}"
);
}
#[test]
fn ext_llm_meta_offline() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-meta-offline.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.env("MARQDO_EXT", root.join("ext"))
.env_remove("OPENAI_MODEL")
.env_remove("MARQDO_LLM_MODEL")
.env_remove("MARQDO_LLM_META_MODEL")
.current_dir(&root)
.output()
.expect("run llm-meta-offline");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-meta-offline stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"meta-model\n<secret>",
"stdout={stdout}"
);
}
#[test]
fn ext_llm_tool_calls_offline() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-tool-calls-offline.mq.md"])
.env("MARQDO_EXT", root.join("ext"))
.current_dir(&root)
.output()
.expect("run llm-tool-calls-offline");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-tool-calls-offline stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"1\ncall_1\nfunction\nlookup\n0",
"stdout={stdout}"
);
}
#[test]
fn ext_llm_ctor_offline() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/ext/llm-ctor-offline.mq.md"])
.env("OPENAI_API_KEY", "sk-test")
.env("MARQDO_EXT", root.join("ext"))
.env_remove("OPENAI_MODEL")
.env_remove("MARQDO_LLM_MODEL")
.current_dir(&root)
.output()
.expect("run llm-ctor-offline");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "llm-ctor-offline stderr={stderr}");
assert_eq!(
stdout.trim_end(),
"gpt-4o-mini\n/chat/completions",
"stdout={stdout}"
);
}
#[test]
fn ext_agent_plan_stream_offline() {
assert_out_llm_offline(
"tests/ext/agent-plan-stream-offline.mq.md",
"4
round
delta
Hi
decision
done
child
pending
1
done
await
2
decompose",
);
}
#[test]
fn lib_math_formula() {
assert_out(
"tests/lib/math-formula.mq.md",
"formula\n2*x\n[-1.4142135624, 1.4142135624]\n7",
);
}
#[test]
fn lib_math_formula_chain() {
assert_out(
"tests/lib/math-formula-chain.mq.md",
"formula\n3*2*x\n12",
);
}
#[test]
fn lib_math_random() {
assert_out("tests/lib/math-random.mq.md", "4\n7\n4");
}
#[test]
fn lib_math_zh_num() {
assert_out("tests/lib/数学-数值.mq.md", "num\n0");
}
#[test]
fn lib_math_plot() {
let path = "tests/lib/math-plot.mq.md";
let (code, stdout, stderr) = run(&["run", path]);
assert_eq!(code, 0, "{path} stderr={stderr}");
assert!(
stdout.lines().next() == Some("text"),
"{path} stdout={stdout}"
);
assert!(
stdout.contains("plot:"),
"{path} missing plot: line in {stdout}"
);
let _ = std::fs::remove_file("tests/lib/math-plot-plot-1.svg");
}
fn python_available() -> bool {
for cmd in ["python", "python3"] {
if let Ok(out) = Command::new(cmd)
.args(["-c", "print(1)"])
.output()
{
if out.status.success() {
return true;
}
}
}
false
}
#[test]
fn lib_foreign_python() {
if !python_available() {
eprintln!("skip lib_foreign_python: no python on PATH");
return;
}
assert_out("tests/lib/foreign-python.mq.md", "hello-from-python");
}
#[test]
fn lib_foreign_run_lang() {
if !python_available() {
eprintln!("skip lib_foreign_run_lang: no python on PATH");
return;
}
assert_out("tests/lib/foreign-run-lang.mq.md", "4");
}
#[test]
fn lib_foreign_zh() {
if !python_available() {
eprintln!("skip lib_foreign_zh: no python on PATH");
return;
}
assert_out("tests/lib/外联-python.mq.md", "中文外联");
}
fn node_available() -> bool {
Command::new("node")
.args(["-e", "process.exit(0)"])
.output()
.map(|o| o.status.success())
.unwrap_or(false)
}
#[test]
fn lib_foreign_invoke() {
if !node_available() {
eprintln!("skip lib_foreign_invoke: no node on PATH");
return;
}
assert_out("tests/lib/foreign-invoke.mq.md", "False\n3\nboom\nFalse");
}
#[test]
fn lib_foreign_json() {
if !node_available() {
eprintln!("skip lib_foreign_json: no node on PATH");
return;
}
assert_out("tests/lib/foreign-json.mq.md", "True\n4\n10");
}
#[test]
fn lib_foreign_call() {
if !node_available() {
eprintln!("skip lib_foreign_call: no node on PATH");
return;
}
assert_out(
"tests/lib/foreign-call.mq.md",
"2\n[2, 4, 6, 8]",
);
}
#[test]
fn lib_foreign_env_timeout() {
if !node_available() {
eprintln!("skip lib_foreign_env_timeout: no node on PATH");
return;
}
assert_out(
"tests/lib/foreign-env-timeout.mq.md",
"fast|node\nFalse\nTrue",
);
}
#[test]
fn lib_foreign_probe_register() {
if !node_available() {
eprintln!("skip lib_foreign_probe_register: no node on PATH");
return;
}
assert_out(
"tests/lib/foreign-probe-register.mq.md",
"True\nnode\ntiny",
);
}
#[test]
fn lib_foreign_config() {
if !node_available() {
eprintln!("skip lib_foreign_config: no node on PATH");
return;
}
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
.args(["run", "tests/lib/foreign-config.mq.md"])
.env(
"MARQDO_FOREIGN_CONFIG",
root.join("tests/lib/fixtures/foreign.toml"),
)
.current_dir(&root)
.output()
.expect("run foreign-config");
let code = output.status.code().unwrap_or(1);
let stdout = String::from_utf8_lossy(&output.stdout);
let stderr = String::from_utf8_lossy(&output.stderr);
assert_eq!(code, 0, "foreign-config stderr={stderr}");
assert_eq!(stdout.trim_end(), "1\ncfg", "stdout={stdout}");
}
#[test]
fn lib_foreign_session() {
if !node_available() {
eprintln!("skip lib_foreign_session: no node on PATH");
return;
}
assert_out("tests/lib/foreign-session.mq.md", "42\n41\n5\n1\nTrue");
}
#[test]
fn lib_foreign_session_timeout() {
if !node_available() {
eprintln!("skip lib_foreign_session_timeout: no node on PATH");
return;
}
assert_out(
"tests/lib/foreign-session-timeout.mq.md",
"False\nTrue\nFalse",
);
}
#[test]
fn lib_foreign_session_python() {
if !python_available() {
eprintln!("skip lib_foreign_session_python: no python on PATH");
return;
}
assert_out("tests/lib/foreign-session-python.mq.md", "42\n5");
}
#[test]
fn lib_foreign_session_vsafe_refuse() {
if !node_available() {
eprintln!("skip lib_foreign_session_vsafe_refuse: no node on PATH");
return;
}
// Span points at lib/foreign.mq.md session_set body.
assert_import_err(
"tests/lib/foreign-session-vsafe-refuse.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_set",
"12:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_foreign_session_use_after_close() {
if !node_available() {
eprintln!("skip lib_foreign_session_use_after_close: no node on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-session-use-after-close.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_eval",
"12:1",
"foreign session",
);
}
#[test]
fn lib_foreign_session_double_close() {
if !node_available() {
eprintln!("skip lib_foreign_session_double_close: no node on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-session-double-close.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_close",
"12:1",
"foreign session",
);
}
#[test]
fn lib_foreign_session_use_before_open() {
// Text fabrication is refused before registry lookup (opaque handle discipline).
assert_import_err(
"tests/lib/foreign-session-use-before-open.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_eval",
"10:1",
"session id must be a handle",
);
}
#[test]
fn lib_foreign_session_handle_no_serialize() {
if !node_available() {
eprintln!("skip lib_foreign_session_handle_no_serialize: no node on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-session-handle-no-serialize.mq.md",
"lib/json.mq.md",
"host_json_stringify",
"12:1",
"session handle cannot be serialized",
);
}
#[test]
fn lib_foreign_session_result_vsafe_refuse() {
if !python_available() {
eprintln!("skip lib_foreign_session_result_vsafe_refuse: no python on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-session-result-vsafe-refuse.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_eval",
"11:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_foreign_session_isolation() {
if !node_available() {
eprintln!("skip lib_foreign_session_isolation: no node on PATH");
return;
}
assert_out("tests/lib/foreign-session-isolation.mq.md", "41\nFalse");
}
#[test]
fn lib_foreign_session_cold_replay_empty() {
if !node_available() {
eprintln!("skip lib_foreign_session_cold_replay_empty: no node on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-session-cold-replay-empty.mq.md",
"lib/foreign.mq.md",
"host_foreign_session_eval",
"13:1",
"foreign session",
);
}
#[test]
fn lib_foreign_vsafe_refuse() {
if !python_available() {
eprintln!("skip lib_foreign_vsafe_refuse: no python on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-vsafe-refuse.mq.md",
"lib/json.mq.md",
"host_json_parse",
"21:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_foreign_vsafe_postarith_refuse() {
if !python_available() {
eprintln!("skip lib_foreign_vsafe_postarith_refuse: no python on PATH");
return;
}
assert_import_err(
"tests/lib/foreign-vsafe-postarith-refuse.mq.md",
"lib/json.mq.md",
"host_json_parse",
"22:1",
"json: integer outside V_safe",
);
}
#[test]
fn lib_foreign_vsafe_string_ok() {
if !node_available() {
eprintln!("skip lib_foreign_vsafe_string_ok: no node on PATH");
return;
}
assert_out(
"tests/lib/foreign-vsafe-string-ok.mq.md",
"{\"out\":\"1152921504606846978\"}",
);
}
#[test]
fn bytecode_lib_math_formula() {
assert_out_backend(
"tests/lib/math-formula.mq.md",
"bytecode",
"formula\n2*x\n[-1.4142135624, 1.4142135624]\n7",
);
}
#[test]
fn bytecode_lib_json() {
assert_out_backend(
"tests/lib/json-roundtrip.mq.md",
"bytecode",
"map\n1\n{\"a\":1,\"b\":\"x\"}",
);
}
fn tempfile_dir(prefix: &str) -> std::path::PathBuf {
let dir = std::env::temp_dir().join(format!(
"{prefix}-{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis()
));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
dir
}
// ---------------------------------------------------------------------------
// Markup mapping v0.3 — fixtures under tests/markup-v03/
// ---------------------------------------------------------------------------
fn assert_out_v03(path: &str, expect: &str) {
assert_out(path, expect);
}
#[test]
fn markup_v03_inc_prose() {
assert_out_v03("tests/markup-v03/inc-prose.mq.md", "38");
}
#[test]
fn markup_v03_bold_call() {
assert_out_v03("tests/markup-v03/bold-call.mq.md", "38");
}
#[test]
fn markup_v03_dual_call() {
assert_out_v03("tests/markup-v03/dual-call.mq.md", "38\n38");
}
#[test]
fn markup_v03_greet_default() {
assert_out_v03(
"tests/markup-v03/greet-default.mq.md",
"您好,\nMarqdo\n嗨,\nWorld",
);
}
#[test]
fn markup_v03_dead_bind() {
assert_out_v03("tests/markup-v03/dead-bind.mq.md", "你好");
}
#[test]
fn markup_v03_empty_return_hr() {
assert_out_v03("tests/markup-v03/empty-return-hr.mq.md", "hi\ndone");
}
#[test]
fn markup_v03_empty_return_none() {
assert_out_v03("tests/markup-v03/empty-return-none.mq.md", "hi\ndone");
}
#[test]
fn markup_v03_empty_return_stars() {
assert_out_v03("tests/markup-v03/empty-return-stars.mq.md", "hi\ndone");
}
#[test]
fn markup_v03_empty_return_compat() {
assert_out_v03("tests/markup-v03/empty-return-compat.mq.md", "hi\ndone");
}
#[test]
fn markup_v03_multi_bold() {
assert_out_v03("tests/markup-v03/multi-bold.mq.md", "a\nb");
}
#[test]
fn markup_v03_print_bold() {
assert_out_v03("tests/markup-v03/print-bold.mq.md", "Hello");
}
#[test]
fn markup_v03_module_hr() {
assert_out_v03("tests/markup-v03/module-hr.mq.md", "ok");
}
#[test]
fn markup_v03_soft_emphasis() {
assert_out_v03("tests/markup-v03/soft-emphasis.mq.md", "2");
}
#[test]
fn markup_v03_float_discount() {
assert_out_v03("tests/markup-v03/float-discount.mq.md", "23.8");
}
#[test]
fn markup_v03_dynamic_footnote() {
assert_out_v03("tests/markup-v03/dynamic-footnote.mq.md", "28");
}
#[test]
fn markup_v03_leading_backtick_decl() {
assert_out_v03("tests/markup-v03/leading-backtick-decl.mq.md", "ok");
}
#[test]
fn markup_v03_decl_ident_only() {
assert_out_v03("tests/markup-v03/decl-ident-only.mq.md", "42");
}
#[test]
fn markup_v03_bold_expr() {
assert_out_v03("tests/markup-v03/bold-expr.mq.md", "42");
}
#[test]
fn markup_v03_formula_meta_var() {
assert_out_v03("tests/markup-v03/formula-meta-var.mq.md", "x^2 - 2");
}
#[test]
fn markup_v03_inline_dollar_formula() {
assert_out_v03("tests/markup-v03/inline-dollar-formula.mq.md", "x + 1");
}
#[test]
fn markup_v03_branch_arm_prose() {
assert_out_v03("tests/markup-v03/branch-arm-prose.mq.md", "正");
}
#[test]
fn markup_v03_branch_cond_narrative() {
assert_out_v03("tests/markup-v03/branch-cond-narrative.mq.md", "正");
}
#[test]
fn markup_v03_foreach_narrative() {
assert_out_v03("tests/markup-v03/foreach-narrative.mq.md", "a\nb\n1\n2");
}
#[test]
fn markup_v03_foreach_nested_link() {
assert_out_v03("tests/markup-v03/foreach-nested-link.mq.md", "x\ny");
}