455 lines
21 KiB
Rust
455 lines
21 KiB
Rust
//! 测试框架调用的内置值/载荷集成回归，通过公开 Vm API 验证 objects 与执行器协议一致。
|
|
//! 各场景区分 Rust 表示相等、语言数值/内容比较、外部拥有根和容器内部强边。
|
|
|
|
use endor_core::{
|
|
CodeLayout, CompareOp, EndorBaseExceptionObject, EndorCode, EndorDictObject,
|
|
EndorFunctionObject, EndorInteger, EndorNativeFunctionObject, EndorNumber, EndorNumberObject,
|
|
EndorReal, EndorStringObject, EndorTracebackEntry, Instruction, Opcode, Value, Vm, VmError,
|
|
};
|
|
|
|
/// 测试数据辅助：构造直接 Text，不分配堆字符串对象。
|
|
fn text(value: &str) -> Value {
|
|
Value::Text(value.into())
|
|
}
|
|
|
|
#[test]
|
|
/// 验证整数规范化、任意长字面量保存、小数表示差异、分母符号和非法词法。
|
|
fn numbers_preserve_large_digits_decimal_scale_exponents_and_fraction_parts() {
|
|
// 超过 i64 的数字串仍可精确保存，只有显式 as_i64 收窄失败。
|
|
let huge = "123456789012345678901234567890123456789012345678901234567890";
|
|
assert_eq!(EndorNumber::integer(huge).unwrap().to_string(), huge);
|
|
assert_eq!(EndorNumber::integer("-000").unwrap().to_string(), "0");
|
|
assert_eq!(EndorNumber::integer("+0012").unwrap().as_i64(), Some(12));
|
|
assert_eq!(EndorNumber::integer(huge).unwrap().as_i64(), None);
|
|
// 逐个验证合法小数原样保存，包括负零、尾零、边界小数点和超长指数。
|
|
for literal in [
|
|
"-0.0000",
|
|
"1.2300000000000000000001",
|
|
".5",
|
|
"1.",
|
|
"2e+999999999999999999999999999999",
|
|
] {
|
|
assert_eq!(EndorNumber::decimal(literal).unwrap().to_string(), literal);
|
|
}
|
|
assert_ne!(
|
|
EndorNumber::decimal("1.00").unwrap(),
|
|
EndorNumber::decimal("1.0").unwrap()
|
|
);
|
|
assert_eq!(
|
|
EndorNumber::rational("2", "-6").unwrap().to_string(),
|
|
"-2/6"
|
|
);
|
|
assert_eq!(EndorNumber::rational("0", "-6").unwrap().to_string(), "0/6");
|
|
assert!(EndorNumber::rational("1", "0").is_err());
|
|
// 逐个拒绝非法词法，不忽略空白或把 Unicode 数字当 ASCII 数字。
|
|
for invalid in ["", "+", " 1", "1 ", "1_000", "１２", "1.0"] {
|
|
assert!(EndorNumber::integer(invalid).is_err(), "{invalid}");
|
|
}
|
|
// 逐个拒绝非法词法，不忽略空白或把 Unicode 数字当 ASCII 数字。
|
|
for invalid in ["", ".", "1.2.3", "1e", "1e+", "1e2e3", "nan", " 0.1", "--1"] {
|
|
assert!(EndorNumber::decimal(invalid).is_err(), "{invalid}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// 验证 IEEE 位保真、零真值、复数显示及未实现数值 hash/比较的明确拒绝。
|
|
fn number_objects_preserve_ieee_bits_and_reject_undefined_numeric_operations() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 带特定 NaN payload 的 IEEE 位，验证存储不会规范化掉低位信息。
|
|
let bits = 0x7ff8_0000_0000_0042;
|
|
// 显式 float 构造保留位，而非按数学等价改写。
|
|
let nan = EndorNumber::binary_float(f64::from_bits(bits));
|
|
assert_eq!(nan.as_real(), Some(&EndorReal::BinaryFloat(bits)));
|
|
assert_ne!(
|
|
EndorNumber::binary_float(-0.0),
|
|
EndorNumber::binary_float(0.0)
|
|
);
|
|
assert!(!EndorNumber::binary_float(f64::INFINITY).is_zero());
|
|
// 超长指数的十进制负零仍为零，真值判断不需要进行指数运算。
|
|
let zero = vm
|
|
.new_number(EndorNumber::decimal("-0.000e99999999999").unwrap())
|
|
.unwrap();
|
|
assert!(!vm.is_true(zero).unwrap());
|
|
// 复数两分量可保留不同精确形式，但不代表复数算术/比较已经实现。
|
|
let complex = EndorNumber::complex(
|
|
EndorReal::Integer(EndorInteger::parse("3").unwrap()),
|
|
EndorNumber::rational("1", "3")
|
|
.unwrap()
|
|
.as_real()
|
|
.unwrap()
|
|
.clone(),
|
|
);
|
|
// 将复数放入堆载荷，验证通过 VM 协议访问的行为。
|
|
let object = vm.new_number(complex).unwrap();
|
|
assert_eq!(vm.str(object).unwrap(), "(3 + (1/3)i)");
|
|
assert_eq!(
|
|
vm.hash(object),
|
|
Err(VmError::UnsupportedOperation("numeric hash"))
|
|
);
|
|
assert_eq!(
|
|
vm.compare(object, zero, CompareOp::Eq),
|
|
Err(VmError::UnsupportedOperation("numeric comparison"))
|
|
);
|
|
assert!(
|
|
vm.payload::<EndorNumberObject>(object, "number")
|
|
.unwrap()
|
|
.value()
|
|
.as_real()
|
|
.is_none()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
/// 验证字符串按 Unicode 标量计数/索引，按内容相等及哈希，空串为假。
|
|
fn strings_use_unicode_characters_and_content_equality() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 两个分别分配的字符串身份不同，内容/哈希协议仍应相等。
|
|
let a = vm.new_string("Endor中文🦀").unwrap();
|
|
// 相同内容的另一对象用于排除仅身份比较的错误实现。
|
|
let b = vm.new_string("Endor中文🦀").unwrap();
|
|
// 空字符串真值应为假。
|
|
let empty = vm.new_string("").unwrap();
|
|
// 借用具体载荷检查 Unicode 标量索引，不把 UTF-8 字节数当字符数。
|
|
let string = vm.payload::<EndorStringObject>(a, "string").unwrap();
|
|
assert_eq!(string.char_count(), 8);
|
|
assert_eq!(string.char_at(7), Some('🦀'));
|
|
assert_eq!(string.char_at(8), None);
|
|
assert!(vm.compare(a, b, CompareOp::Eq).unwrap());
|
|
assert_eq!(vm.hash(a).unwrap(), vm.hash(b).unwrap());
|
|
assert_eq!(vm.str(a).unwrap(), "Endor中文🦀");
|
|
assert!(!vm.is_true(empty).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
/// 验证堆字符串键与直接文本等价时保留首键及顺序，覆盖/删除正确释放旧边。
|
|
fn dictionaries_keep_order_and_first_key_and_own_keys_and_values() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 字典返回一份外部根；插入对象键值时另持内部边。
|
|
let dict = vm.new_dict().unwrap();
|
|
// 堆字符串键之后与同内容直接 Text 比较，字典应保留此首键身份。
|
|
let key = vm.new_string("answer").unwrap();
|
|
// 覆盖前的对象值，归还外部根后只由字典持有，便于检查覆盖释放。
|
|
let old = vm.new_object().unwrap();
|
|
vm.dict_set(dict, Value::Object(key), Value::Object(old))
|
|
.unwrap();
|
|
// 归还测试根，后续键仍通过字典键边存活。
|
|
vm.release(key).unwrap();
|
|
// 归还旧值测试根，字典覆盖时应释放其最后强边。
|
|
vm.release(old).unwrap();
|
|
vm.dict_set(dict, text("second"), Value::Nil).unwrap();
|
|
vm.dict_set(dict, text("answer"), text("replacement"))
|
|
.unwrap();
|
|
assert_eq!(
|
|
vm.dict_get(dict, &text("answer")).unwrap(),
|
|
Some(text("replacement"))
|
|
);
|
|
assert_eq!(vm.dict_items(dict).unwrap()[0].0, Value::Object(key));
|
|
assert_eq!(vm.dict_items(dict).unwrap().len(), 2);
|
|
assert!(matches!(vm.object(old), Err(VmError::InvalidHandle)));
|
|
assert!(vm.dict_delete(dict, &text("answer")).unwrap());
|
|
assert!(matches!(vm.object(key), Err(VmError::InvalidHandle)));
|
|
assert!(!vm.dict_delete(dict, &text("missing")).unwrap());
|
|
vm.dict_clear(dict).unwrap();
|
|
assert!(!vm.is_true(dict).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
/// 验证异堆/过期句柄、不可哈希键和错误容器种类不破坏既有值与计数。
|
|
fn failed_container_writes_leave_values_and_counts_unchanged() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 第二个 VM 提供异堆句柄，拒绝时不能把它保留在本堆容器。
|
|
let mut other = Vm::new().unwrap();
|
|
// 异堆对象始终由其所属 VM 管理，不允许跨堆建立托管边。
|
|
let foreign = other.new_object().unwrap();
|
|
// 字典返回一份外部根；插入对象键值时另持内部边。
|
|
let dict = vm.new_dict().unwrap();
|
|
// 子对象根加上字典/Cell 内部边应按实际拥有次数计数。
|
|
let child = vm.new_object().unwrap();
|
|
vm.dict_set(dict, text("x"), Value::Object(child)).unwrap();
|
|
assert_eq!(
|
|
vm.dict_set(dict, text("x"), Value::Object(foreign)),
|
|
Err(VmError::ForeignHandle)
|
|
);
|
|
assert_eq!(
|
|
vm.dict_get(dict, &text("x")).unwrap(),
|
|
Some(Value::Object(child))
|
|
);
|
|
assert_eq!(vm.ref_count(child).unwrap(), 2);
|
|
assert_eq!(
|
|
vm.dict_set(dict, Value::Number(1_i64.into()), Value::Nil),
|
|
Err(VmError::UnsupportedOperation("numeric hash"))
|
|
);
|
|
assert_eq!(
|
|
vm.dict_set(dict, Value::Object(dict), Value::Nil),
|
|
Err(VmError::UnsupportedOperation("dict hash"))
|
|
);
|
|
// Cell 创建即有一份外部根，初值对象额外成为内部边；None 则保持未初始化。
|
|
let cell = vm.new_cell(Some(Value::Object(child))).unwrap();
|
|
assert_eq!(
|
|
vm.cell_set(cell, Value::Object(foreign)),
|
|
Err(VmError::ForeignHandle)
|
|
);
|
|
assert_eq!(vm.cell_get(cell).unwrap(), Value::Object(child));
|
|
// 分配后立即释放以制造真正的过期身份，不能误认为普通缺值。
|
|
let dead = vm.new_object().unwrap();
|
|
// 此后向 Cell 写入该身份必须报 InvalidHandle，不改变原值。
|
|
vm.release(dead).unwrap();
|
|
assert_eq!(
|
|
vm.cell_set(cell, Value::Object(dead)),
|
|
Err(VmError::InvalidHandle)
|
|
);
|
|
assert_eq!(vm.ref_count(child).unwrap(), 3);
|
|
assert_eq!(
|
|
vm.dict_clear(child),
|
|
Err(VmError::ObjectKindMismatch("dict"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
/// 验证 None 空槽与已存 Nil 不同，同对象重写不提前释放，clear 后旧值失效。
|
|
fn cells_share_rebinding_distinguish_empty_and_none_and_keep_stable_objects() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// Cell 创建即有一份外部根，初值对象额外成为内部边；None 则保持未初始化。
|
|
let cell = vm.new_cell(None).unwrap();
|
|
assert_eq!(vm.cell_get(cell), Err(VmError::EmptyCell));
|
|
vm.cell_set(cell, Value::Nil).unwrap();
|
|
assert_eq!(vm.cell_get(cell).unwrap(), Value::Nil);
|
|
// 子对象根加上字典/Cell 内部边应按实际拥有次数计数。
|
|
let child = vm.new_object().unwrap();
|
|
vm.cell_set(cell, Value::Object(child)).unwrap();
|
|
// 归还测试根后，容器/Cell 内部边仍须维持子对象存活。
|
|
vm.release(child).unwrap();
|
|
vm.cell_set(cell, Value::Object(child)).unwrap();
|
|
assert_eq!(vm.ref_count(child).unwrap(), 1);
|
|
vm.cell_clear(cell).unwrap();
|
|
assert!(matches!(vm.object(child), Err(VmError::InvalidHandle)));
|
|
assert_eq!(vm.cell_get(cell), Err(VmError::EmptyCell));
|
|
}
|
|
|
|
#[test]
|
|
/// 验证同一 Cell 被字典多键持有要计多条边，外部根移除后互引环整体回收。
|
|
fn container_cycles_and_duplicate_edges_are_collected() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 字典返回一份外部根；插入对象键值时另持内部边。
|
|
let dict = vm.new_dict().unwrap();
|
|
// Cell 创建即有一份外部根，初值对象额外成为内部边；None 则保持未初始化。
|
|
let cell = vm.new_cell(Some(Value::Object(dict))).unwrap();
|
|
vm.dict_set(dict, text("a"), Value::Object(cell)).unwrap();
|
|
vm.dict_set(dict, text("b"), Value::Object(cell)).unwrap();
|
|
assert_eq!(vm.ref_count(cell).unwrap(), 3);
|
|
vm.release(dict).unwrap();
|
|
// 归还 Cell 原根，闭包或字典边仍可持有它，最后无根环交给 GC。
|
|
vm.release(cell).unwrap();
|
|
assert_eq!(vm.collect_cycles(), 2);
|
|
assert_eq!(vm.object_count(), 0);
|
|
}
|
|
|
|
#[test]
|
|
/// 验证代码常量、默认值、全局和共享捕获槽均有强边，闭包更新可见且无根环可回收。
|
|
fn functions_retain_globals_constants_defaults_and_shared_closure_cells() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 准备函数环境；本场景可故意使用非字典以测试种类校验。
|
|
let globals = vm.new_dict().unwrap();
|
|
// 常量初始有测试根，代码常量表和默认值还会独立拥有强边。
|
|
let constant = vm.new_string("constant").unwrap();
|
|
// Cell 创建即有一份外部根，初值对象额外成为内部边；None 则保持未初始化。
|
|
let cell = vm.new_cell(Some(text("first"))).unwrap();
|
|
// 构造已验证代码元数据，只有分配代码载荷后才建立常量托管边。
|
|
let code = EndorCode::from_instructions(
|
|
&[
|
|
Instruction::new(Opcode::LoadDeref, 1),
|
|
Instruction::simple(Opcode::ReturnValue),
|
|
],
|
|
vec![Value::Object(constant)],
|
|
CodeLayout {
|
|
parameters: vec!["argument".into()],
|
|
locals: vec!["argument".into()],
|
|
free_variables: vec!["captured".into()],
|
|
..CodeLayout::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
// 托管代码对象有一份根，函数载荷还会额外持有代码边。
|
|
let code = vm.new_code(code).unwrap();
|
|
// 函数/原生函数分配结果由测试持有根，载荷内部引用另计。
|
|
let function = vm
|
|
.new_function(
|
|
"read",
|
|
code,
|
|
globals,
|
|
vec![Value::Object(constant)],
|
|
vec![cell],
|
|
)
|
|
.unwrap();
|
|
// 第二个函数共用代码/全局/Cell，但默认值布局不同，拥有边各自计数。
|
|
let second = vm
|
|
.new_function("read_again", code, globals, vec![], vec![cell])
|
|
.unwrap();
|
|
assert_eq!(vm.ref_count(constant).unwrap(), 3);
|
|
// 释放代码测试根后函数仍持有代码内部边，不能使执行数据常量失效。
|
|
vm.release(code).unwrap();
|
|
// 常量原测试根归还，其余代码/默认值边仍保持存活。
|
|
vm.release(constant).unwrap();
|
|
// 归还 Cell 原根，闭包或字典边仍可持有它，最后无根环交给 GC。
|
|
vm.release(cell).unwrap();
|
|
vm.cell_set(cell, text("updated")).unwrap();
|
|
// 逐个读取两个函数捕获的同一 Cell，必须观察相同更新。
|
|
for reference in [function, second] {
|
|
// 借用函数载荷的闭包引用，不为读取额外保留根。
|
|
let f = vm
|
|
.payload::<EndorFunctionObject>(reference, "function")
|
|
.unwrap();
|
|
assert_eq!(vm.cell_get(f.closure()[0]).unwrap(), text("updated"));
|
|
}
|
|
assert_eq!(vm.call(function, &[]).unwrap(), text("updated"));
|
|
vm.dict_set(globals, text("read"), Value::Object(function))
|
|
.unwrap();
|
|
vm.release(globals).unwrap();
|
|
vm.release(function).unwrap();
|
|
vm.release(second).unwrap();
|
|
assert_eq!(vm.collect_cycles(), 5);
|
|
}
|
|
|
|
#[test]
|
|
/// 验证函数全局种类/闭包数量及代码重复槽名错误不新增根或持有边。
|
|
fn malformed_function_environments_are_rejected_without_retaining_any_edges() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 准备函数环境；本场景可故意使用非字典以测试种类校验。
|
|
let globals = vm.new_object().unwrap();
|
|
// 最小装载常量并返回的逻辑指令，用于只改变环境或闭包布局的错误测试。
|
|
let instructions = [
|
|
Instruction::new(Opcode::LoadConst, 0),
|
|
Instruction::simple(Opcode::ReturnValue),
|
|
];
|
|
// 构造已验证代码元数据，只有分配代码载荷后才建立常量托管边。
|
|
let code = EndorCode::from_instructions(&instructions, vec![Value::Nil], CodeLayout::default())
|
|
.unwrap();
|
|
// 托管代码对象有一份根，函数载荷还会额外持有代码边。
|
|
let code = vm.new_code(code).unwrap();
|
|
assert_eq!(
|
|
vm.new_function("bad", code, globals, vec![], vec![]),
|
|
Err(VmError::ObjectKindMismatch("dict"))
|
|
);
|
|
assert_eq!(vm.ref_count(globals).unwrap(), 1);
|
|
assert_eq!(vm.ref_count(code).unwrap(), 1);
|
|
assert!(EndorCode::new(vec![], vec![], vec!["x".into(), "x".into()], vec![]).is_err());
|
|
// 构造已验证代码元数据，只有分配代码载荷后才建立常量托管边。
|
|
let code = EndorCode::from_instructions(
|
|
&instructions,
|
|
vec![Value::Nil],
|
|
CodeLayout {
|
|
free_variables: vec!["x".into()],
|
|
..CodeLayout::default()
|
|
},
|
|
)
|
|
.unwrap();
|
|
// 托管代码对象有一份根，函数载荷还会额外持有代码边。
|
|
let code = vm.new_code(code).unwrap();
|
|
// 准备函数环境；本场景可故意使用非字典以测试种类校验。
|
|
let globals = vm.new_dict().unwrap();
|
|
assert!(
|
|
vm.new_function("bad", code, globals, vec![], vec![])
|
|
.is_err()
|
|
);
|
|
assert_eq!(vm.ref_count(code).unwrap(), 1);
|
|
}
|
|
|
|
#[test]
|
|
/// 验证异常数据载荷的参数/链强边与注释/回溯元数据，错误 cause 种类被拒绝。
|
|
fn exceptions_preserve_arguments_chains_notes_and_traceback_without_type_classes() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 异常参数对象由 cause 的参数边持有，之后归还测试根仍须存活。
|
|
let argument = vm.new_string("detail").unwrap();
|
|
// cause 异常载荷持有参数；主异常的 cause/context 两项都指向它。
|
|
let cause = vm
|
|
.allocate(EndorBaseExceptionObject::new(
|
|
"ValueError",
|
|
vec![Value::Object(argument)],
|
|
))
|
|
.unwrap();
|
|
// 同一 cause 被两条字段边拥有，注释/回溯文本不构成托管对象边。
|
|
let exception = vm
|
|
.allocate(
|
|
EndorBaseExceptionObject::new("RuntimeError", vec![text("failed")])
|
|
.with_cause(cause)
|
|
.with_context(cause)
|
|
.with_note("while loading")
|
|
.with_traceback(EndorTracebackEntry {
|
|
function: "load".into(),
|
|
file: "demo.endor".into(),
|
|
line: 12,
|
|
}),
|
|
)
|
|
.unwrap();
|
|
assert_eq!(vm.ref_count(cause).unwrap(), 3);
|
|
// 归还参数外部根，链上异常仍通过参数边持有它。
|
|
vm.release(argument).unwrap();
|
|
// 归还 cause 外部根，主异常两条链边继续保活。
|
|
vm.release(cause).unwrap();
|
|
// 借用异常元数据观察；不在此处抛出异常或自动创建语言异常类。
|
|
let data = vm
|
|
.payload::<EndorBaseExceptionObject>(exception, "exception")
|
|
.unwrap();
|
|
assert!(data.context_suppressed());
|
|
assert_eq!(data.notes(), &["while loading"]);
|
|
assert_eq!(data.traceback()[0].line, 12);
|
|
assert_eq!(vm.str(exception).unwrap(), "failed");
|
|
// 归还主异常最后根会级联释放 cause 和参数，无需手动重复 release 内部边。
|
|
vm.release(exception).unwrap();
|
|
assert_eq!(vm.object_count(), 0);
|
|
// 字典不是异常，不能通过 with_cause 绕过内置校验。
|
|
let wrong = vm.new_dict().unwrap();
|
|
assert_eq!(
|
|
vm.allocate(EndorBaseExceptionObject::new("Error", vec![]).with_cause(wrong)),
|
|
Err(VmError::ObjectKindMismatch("exception"))
|
|
);
|
|
}
|
|
|
|
/// 旧式原生回调借用返回原参数；VM 必须为最终对象结果另取拥有根。
|
|
fn echo(arguments: &[Value]) -> Result<Value, VmError> {
|
|
// 回调只接受一个参数，clone 不增加计数，最终拥有根由 VM 原生调用路径取得。
|
|
match arguments {
|
|
[value] => Ok(value.clone()),
|
|
_ => Err(VmError::InvalidArgument("expected one value")),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
/// 验证原生传参不损失数值表示，即使原样返回对象参数也要独立结果根。
|
|
fn native_functions_pass_lossless_numbers_and_return_owned_objects() {
|
|
// 每个测试建立独立 VM；句柄所有权由 API 决定，不依赖复制值自动 retain。
|
|
let mut vm = Vm::new().unwrap();
|
|
// 函数/原生函数分配结果由测试持有根，载荷内部引用另计。
|
|
let function = vm
|
|
.allocate(EndorNativeFunctionObject::new("echo", echo))
|
|
.unwrap();
|
|
// 精确小数作为直接参数，经原生回调传回仍保留全部数字和尾零。
|
|
let number = Value::Number(EndorNumber::decimal("12345678901234567890.000100").unwrap());
|
|
assert_eq!(
|
|
vm.call(function, std::slice::from_ref(&number)).unwrap(),
|
|
number
|
|
);
|
|
// 字典返回一份外部根；插入对象键值时另持内部边。
|
|
let dict = vm.new_dict().unwrap();
|
|
// 调用结果与原参数身份相同，但对象结果必须额外有一份外部根。
|
|
let returned = vm.call(function, &[Value::Object(dict)]).unwrap();
|
|
assert_eq!(returned, Value::Object(dict));
|
|
assert_eq!(vm.ref_count(dict).unwrap(), 2);
|
|
// 只归还结果根，原 dict 根仍存在，计数应从二降为一。
|
|
vm.release_value(returned).unwrap();
|
|
assert_eq!(vm.ref_count(dict).unwrap(), 1);
|
|
assert_eq!(
|
|
vm.payload::<EndorDictObject>(dict, "dict").unwrap().len(),
|
|
0
|
|
);
|
|
}
|