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 { 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 assert_eq!( stdout.trim_end(), "from-bind\nHello Ada\n32\n\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"); } #[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) { 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<b>&"c'\na&\"c'\nNBSWY3DP\nhello", ); } #[test] fn lib_toml_html_encoding_smoke_zh() { assert_out( "tests/lib/配置表-超文本-编码-烟测.mq.md", "中文\nTrue\na<b>\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(" = 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", "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"); }