- Delete HostOp::Print and StdHost::op_print; the print builtin only routes to bundled io.写值 when Program.print_override is set, otherwise returns a structured kernel.unavailable error (ADR-0031). - Keep the 打印/print builtin name for arity/static validation; Value::display remains only for CLI result rendering, not print execution. - Teach the direct-runtime semantic harness to mirror loader stdlib injection and import edges; replace runtime tests that used print with non-print effects. - Update spec/security/status/changelog/README, add ADR-0031 and evidence. Gate: fmt, clippy -D warnings, 419 tests passed.
242 lines
7.3 KiB
Rust
242 lines
7.3 KiB
Rust
//! End-to-end interpreter tests: Markdown source → frontend IR → execution.
|
|
|
|
use marqdo_host::{Capabilities, Host, StdHost};
|
|
use marqdo_ir::{ModuleId, Program};
|
|
use marqdo_runtime::{run, run_with_limits, EvaluatedArg, MemoryLimits, RuntimeError, Value};
|
|
use marqdo_sandbox::SandboxMode;
|
|
use marqdo_span::Span;
|
|
|
|
fn build(source: &str) -> Program {
|
|
let result = marqdo_frontend::analyze_source("index.mq.md", source);
|
|
assert!(
|
|
!result.has_errors(),
|
|
"unexpected compile diagnostics: {:#?}",
|
|
result.diagnostics
|
|
);
|
|
let module_id = ModuleId::from("index.mq.md");
|
|
let mut program = Program {
|
|
main_module: Some(module_id.clone()),
|
|
..Program::default()
|
|
};
|
|
program.insert(result.module);
|
|
program
|
|
}
|
|
|
|
fn host() -> StdHost {
|
|
StdHost::new(
|
|
SandboxMode::Project,
|
|
Capabilities::pure(),
|
|
std::env::temp_dir(),
|
|
)
|
|
}
|
|
|
|
fn run_named(source: &str, function: &str, args: &[(&str, Value)]) -> Result<Value, RuntimeError> {
|
|
let program = build(source);
|
|
let mut host = host();
|
|
let args = args
|
|
.iter()
|
|
.map(|(name, value)| EvaluatedArg::named(*name, value.clone(), Span::default()))
|
|
.collect();
|
|
run(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
function,
|
|
args,
|
|
)
|
|
.map(|outcome| outcome.value)
|
|
}
|
|
|
|
fn run_and_output(source: &str, function: &str) -> (Result<Value, RuntimeError>, String) {
|
|
let program = build(source);
|
|
let mut host = host();
|
|
let result = run(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
function,
|
|
Vec::new(),
|
|
)
|
|
.map(|outcome| outcome.value);
|
|
let output = String::from_utf8(host.take_output()).unwrap();
|
|
(result, output)
|
|
}
|
|
|
|
#[test]
|
|
fn recursion_branch_and_return() {
|
|
let source = "## 阶乘\n\n1. `n <= 1`\n\n *1*\n\n2. `n > 1`\n\n **结果 = n * 阶乘(n=n-1)**\n\n *结果*\n";
|
|
let value = run_named(source, "阶乘", &[("n", Value::int(5))]).unwrap();
|
|
assert_eq!(value, Value::int(120));
|
|
}
|
|
|
|
#[test]
|
|
fn loop_mutates_and_returns_unit_for_fallthrough() {
|
|
let source = "## 倒计时\n\n**n = 3**\n\n- `n > 0`\n\n **n = n - 1**\n";
|
|
let (result, _) = run_and_output(source, "倒计时");
|
|
assert_eq!(result.unwrap(), Value::Unit);
|
|
}
|
|
|
|
#[test]
|
|
fn return_inside_loop_propagates() {
|
|
let source = "## 找\n\n**i = 0**\n\n- `true`\n\n **i = i + 1**\n\n - `i >= 3`\n\n *i*\n";
|
|
let (result, _) = run_and_output(source, "找");
|
|
assert_eq!(result.unwrap(), Value::int(3));
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_signature_supports_positional_arguments() {
|
|
let source = "## 加\n\n`(a: Int, b: Int = 10)`\n\n*a + b*\n";
|
|
let program = build(source);
|
|
let mut host = host();
|
|
let result = run(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
"加",
|
|
vec![EvaluatedArg::positional(Value::int(2), Span::default())],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(result.value, Value::int(12));
|
|
}
|
|
|
|
#[test]
|
|
fn builtins_for_conversions_and_length() {
|
|
let source = "## f\n\n*长度(\"你好\") + 整数(\"40\") + 整数(2.0)*\n";
|
|
let value = run_named(source, "f", &[]).unwrap();
|
|
assert_eq!(value, Value::int(44));
|
|
}
|
|
|
|
#[test]
|
|
fn function_reference_can_be_called() {
|
|
let source =
|
|
"## 平方\n\n`(n: Int)`\n\n*n * n*\n\n## 主\n\n**f = ref(\"#平方\")**\n\n*f(n=4)*\n";
|
|
let value = run_named(source, "主", &[]).unwrap();
|
|
assert_eq!(value, Value::int(16));
|
|
}
|
|
|
|
#[test]
|
|
fn non_bool_condition_is_a_runtime_error() {
|
|
let source = "## f\n\n**x = 1**\n\n- `x`\n\n **x = x + 1**\n\n*x*\n";
|
|
let error = run_named(source, "f", &[]).unwrap_err();
|
|
assert_eq!(error.code(), "runtime.type");
|
|
}
|
|
|
|
#[test]
|
|
fn fuel_budget_is_enforced() {
|
|
let program = build("## f\n\n- `true`\n\n **x = 1**\n\n*0*\n");
|
|
let mut host = StdHost::new(
|
|
SandboxMode::Project,
|
|
Capabilities::pure(),
|
|
std::env::temp_dir(),
|
|
);
|
|
host.budget.fuel = 200;
|
|
let error = run(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
"f",
|
|
Vec::new(),
|
|
)
|
|
.unwrap_err();
|
|
assert_eq!(error.code(), "resource.exhausted");
|
|
}
|
|
|
|
#[test]
|
|
fn recursion_depth_is_bounded() {
|
|
let source = "## f\n\n*f(n=n + 1)*\n";
|
|
let program = build(source);
|
|
let mut host = StdHost::new(
|
|
SandboxMode::Project,
|
|
Capabilities::pure(),
|
|
std::env::temp_dir(),
|
|
);
|
|
host.budget.stack_limit = 8;
|
|
let error = run(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
"f",
|
|
vec![EvaluatedArg::named("n", Value::int(0), Span::default())],
|
|
)
|
|
.unwrap_err();
|
|
assert_eq!(error.code(), "resource.exhausted");
|
|
assert!(error.frames.len() >= 2);
|
|
}
|
|
|
|
#[test]
|
|
fn ambiguous_ref_resource_is_an_error() {
|
|
let source = "## f\n\n### 公式\n\n$$a = 1$$\n\n$$b = 2$$\n\n**x = ref(\"#公式\")**\n\n*x*\n";
|
|
let error = run_named(source, "f", &[]).unwrap_err();
|
|
assert_eq!(error.code(), "ref.ambiguous");
|
|
}
|
|
|
|
#[test]
|
|
fn print_without_the_bundled_stdlib_is_a_structured_error() {
|
|
let source = "## f\n\n> 打印(1)\n\n*None*\n";
|
|
let error = run_named(source, "f", &[]).unwrap_err();
|
|
assert_eq!(error.code(), "kernel.unavailable");
|
|
assert!(
|
|
error.message.contains("bundled stdlib"),
|
|
"unexpected message: {}",
|
|
error.message
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn function_ref_and_resource_members_are_readable() {
|
|
let source = "## 目标\n\n*1*\n\n## main\n\n### 公式\n\n$$a = 1$$\n\n### 代码\n\n```text\nx\n```\n\n**f = ref(\"#目标\")**\n\n**g = ref(\"#公式\")**\n\n**c = ref(\"#代码\")**\n\n*[f.module, f.name, g.latex, g.display, c.language, c.source]*\n";
|
|
let value = run_named(source, "main", &[]).unwrap();
|
|
let Value::List(items) = value else {
|
|
panic!("expected list");
|
|
};
|
|
assert!(matches!(&items[0], Value::Text(module) if module.ends_with("index.mq.md")));
|
|
assert_eq!(items[1], Value::text("目标"));
|
|
assert_eq!(items[2], Value::text("a = 1"));
|
|
assert_eq!(items[3], Value::Bool(true));
|
|
assert_eq!(items[4], Value::text("text"));
|
|
assert_eq!(items[5], Value::text("x\n"));
|
|
}
|
|
|
|
#[test]
|
|
fn memory_region_is_shared_by_handle_identity() {
|
|
let source = "## f\n\n**m = memory.new(1, 2)**\n\n**n = m**\n\n**`m[3] = 7`**\n\n*[n[3], m == n, memory.size(n)]*\n";
|
|
let value = run_named(source, "f", &[]).unwrap();
|
|
assert_eq!(
|
|
value,
|
|
Value::List(vec![Value::int(7), Value::Bool(true), Value::int(1)])
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn memory_handle_cannot_reach_the_host_boundary() {
|
|
let source = "## f\n\n**m = memory.new(1, 1)**\n\n> fs.read(m)\n\n*0*\n";
|
|
let error = run_named(source, "f", &[]).unwrap_err();
|
|
assert_eq!(error.code(), "runtime.type");
|
|
assert!(
|
|
error
|
|
.message
|
|
.contains("Memory values cannot cross the host boundary"),
|
|
"unexpected message: {}",
|
|
error.message
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn memory_budget_is_enforced_without_changing_the_region() {
|
|
let program = build("## f\n\n**m = memory.new(1, 1)**\n\n*[m[0], memory.grow(m, 1)]*\n");
|
|
let mut host = host();
|
|
let error = run_with_limits(
|
|
&program,
|
|
&mut host,
|
|
&ModuleId::from("index.mq.md"),
|
|
"f",
|
|
Vec::new(),
|
|
MemoryLimits {
|
|
max_total_bytes: 64 * 1024,
|
|
max_region_bytes: 64 * 1024 * 2,
|
|
},
|
|
)
|
|
.unwrap_err();
|
|
assert_eq!(error.code(), "resource.exhausted");
|
|
}
|