Files
endorphin-tessera-gui/vendor/nexus/tests/program.rs
T

194 lines
6.7 KiB
Rust

//! 完整程序装载与宿主返回值处理的无 UI 回归;需在获授权环境编译、执行。
//! 使用可观察原生回调/析构检查入口策略和拥有根,避免依赖 Tessera 的页面实现。
use anyhow::{Result, bail};
use endor_core::{
CallArity, ContextNativeFunction, NativeCallable, NativeContext, NativeResult, ObjectPayload,
ObjectRef, Value, VmError,
};
use endorphin_nexus_runtime::{
DEFAULT_LIMITS, VmSession,
program::{CodeRetention, PreparedProgram},
};
use frontend::EndorReader;
use std::{
any::Any,
sync::{
Arc,
atomic::{AtomicUsize, Ordering},
},
};
#[derive(Debug)]
/// main 显式调用才递增,装载定义或检查源码不应触发该宿主能力。
struct Mark(Arc<AtomicUsize>);
impl NativeCallable for Mark {
/// 宿主能力使用确定零参契约。
fn arity(&self) -> Option<CallArity> {
Some(CallArity::exact(0))
}
/// 返回纯数值给源 main,计数留在 VM 外观察。
fn invoke(
&self,
_cx: &mut NativeContext<'_>,
_args: &[Value],
) -> Result<NativeResult, VmError> {
self.0.fetch_add(1, Ordering::SeqCst);
Ok(NativeResult::Return(Value::Number(7_i64.into())))
}
}
/// 解码读取的借用对象身份,不建立或释放根。
fn object(value: Value) -> ObjectRef {
let Value::Object(value) = value else {
panic!("expected object")
};
value
}
#[test]
/// 两种代码根策略都只执行模块定义;main 何时调用由宿主决定,装载的函数在代码根释放后仍有效。
fn module_loading_preserves_function_identity_without_calling_main() {
let program = PreparedProgram::compile(
EndorReader::from_text(
"headless module",
"function main(): Number { return mark() }",
),
["mark".to_owned()].into_iter().collect(),
)
.unwrap();
assert!(program.ast_nodes() > 0);
for retention in [CodeRetention::Execution, CodeRetention::Session] {
let calls = Arc::new(AtomicUsize::new(0));
let mut runtime = VmSession::new().unwrap();
let globals = runtime.create_globals().unwrap();
let mark = runtime
.vm_mut()
.allocate(ContextNativeFunction::new(
"mark",
Mark(calls.clone()),
vec![],
))
.unwrap();
runtime.keep_root(mark);
runtime
.vm_mut()
.dict_set(globals, Value::Text("mark".into()), Value::Object(mark))
.unwrap();
runtime.execute_program(&program, retention).unwrap();
assert_eq!(calls.load(Ordering::SeqCst), 0);
let main = object(
runtime
.vm()
.dict_get(globals, &Value::Text("main".into()))
.unwrap()
.unwrap(),
);
let value = runtime
.with_call_result(main, &[], DEFAULT_LIMITS, |_vm, value| {
Ok(value.clone()) // 此处返回标量,不把借用的托管对象带出。
})
.unwrap();
assert_eq!(value, Value::Number(7_i64.into()));
assert_eq!(calls.load(Ordering::SeqCst), 1);
runtime.close().unwrap();
assert_eq!(runtime.vm().object_count(), 0);
}
}
#[test]
/// 脚本中途出错不回滚前段写入,两种代码根清理路径都必须能关闭至空堆。
fn script_failure_keeps_completed_writes_and_releases_both_code_policies() {
let program = PreparedProgram::compile(
EndorReader::from_text(
"headless program failure",
"total = 1\ntotal = total + 1\n1 / 0",
),
Default::default(),
)
.unwrap();
for retention in [CodeRetention::Execution, CodeRetention::Session] {
let mut runtime = VmSession::new().unwrap();
let globals = runtime.create_globals().unwrap();
let error = runtime
.execute_program(&program, retention)
.unwrap_err()
.to_string();
assert!(error.contains("headless program failure"));
assert_eq!(
runtime
.vm()
.dict_get(globals, &Value::Text("total".into()))
.unwrap(),
Some(Value::Number(2_i64.into()))
);
runtime.close().unwrap();
assert_eq!(runtime.vm().object_count(), 0);
}
}
#[derive(Debug)]
/// 每个真正返回的新对象拥有独立析构事件,验证宿主处理失败后的根也被归还。
struct Returned(Arc<AtomicUsize>);
impl ObjectPayload for Returned {
/// 支持 Aster 载荷识别,不引入额外托管出边。
fn as_any(&self) -> &dyn Any {
self
}
/// 测试诊断类别,与 UI 名义类型无关。
fn kind_name(&self) -> &'static str {
"returned-test-object"
}
}
impl Drop for Returned {
/// 真实拥有根归零时计数;仅 drop Rust Value 不会触发此回调。
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
#[derive(Debug)]
/// 模拟 main 返回新对象,返回前没有其他拥有边。
struct Allocate(Arc<AtomicUsize>);
impl NativeCallable for Allocate {
/// 与宿主调用的空实参数量一致。
fn arity(&self) -> Option<CallArity> {
Some(CallArity::exact(0))
}
/// NativeContext 把分配根提升为返回根,Nexus 的处理接口负责后续归还。
fn invoke(&self, cx: &mut NativeContext<'_>, _args: &[Value]) -> Result<NativeResult, VmError> {
let result = cx.allocate(Returned(self.0.clone()))?;
Ok(NativeResult::Return(Value::Object(result)))
}
}
#[test]
/// 成功/错误宿主处理都可在返回对象存活期间访问它,处理结束后立即释放唯一返回根。
fn host_result_errors_release_the_returned_object() {
let drops = Arc::new(AtomicUsize::new(0));
let mut runtime = VmSession::new().unwrap();
let callee = runtime
.vm_mut()
.allocate(ContextNativeFunction::new(
"allocate",
Allocate(drops.clone()),
vec![],
))
.unwrap();
runtime.keep_root(callee);
let baseline = runtime.vm().object_count();
for fail in [false, true] {
let result: Result<()> =
runtime.with_call_result(callee, &[], DEFAULT_LIMITS, |vm, value| {
assert!(vm.object(object(value.clone())).is_ok());
if fail {
bail!("host presentation failed");
}
Ok(())
});
assert_eq!(result.is_err(), fail);
assert_eq!(runtime.vm().object_count(), baseline);
}
assert_eq!(drops.load(Ordering::SeqCst), 2);
runtime.close().unwrap();
assert_eq!(runtime.vm().object_count(), 0);
}