328 lines
15 KiB
Rust
328 lines
15 KiB
Rust
//! Rust 测试框架调用的属性存储回归，不执行源码指令。
|
||
//! Proxy 让字段存储与名义身份分开；ReflectiveType 触发类型查询对自身属性的重入。
|
||
//! 断言覆盖托管边生命周期、失败不修改版本、能力方法不得被实例属性遮蔽。
|
||
|
||
use objects::{ObjectPayload, ObjectRef, ObjectStore, TypeConstructor, Value, VmError};
|
||
|
||
#[derive(Debug)]
|
||
/// 一个拥有后端存储引用的门面，type_target 保持默认 None。
|
||
struct Proxy(ObjectRef);
|
||
impl ObjectPayload for Proxy {
|
||
/// Store 下转型测试载荷，不进行语言类型判定。
|
||
fn as_any(&self) -> &dyn std::any::Any {
|
||
self
|
||
}
|
||
/// 测试错误/诊断使用的类别标签。
|
||
fn kind_name(&self) -> &'static str {
|
||
"proxy"
|
||
}
|
||
/// Heap 分配/替换时记录一条拥有边，确保被代理存储或自引用 Cell 存活。
|
||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||
visit(self.0);
|
||
}
|
||
/// Store::attribute_path 追踪实际字段存储，不改变代理对象头部类型。
|
||
fn attribute_target(&self, _: &ObjectStore) -> Result<Option<ObjectRef>, VmError> {
|
||
Ok(Some(self.0))
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
/// 验证代理改指新存储后，名义类型不变、旧值释放、读写删除转到新终点。
|
||
fn storage_retargeting_preserves_type_identity_and_releases_old_state() {
|
||
// 建立独立堆隔离场景，所有分配根在测试末尾明确归还。
|
||
let mut store = ObjectStore::new().unwrap();
|
||
// 自举 Object/Type，各有一份外部根；其图内自环需最终 collect_cycles。
|
||
let roots = store.bootstrap_types().unwrap();
|
||
// 给代理/反射实例附着真实名义类型，字段转发不应替换它。
|
||
let class = store
|
||
.new_type("Proxy", roots.object, TypeConstructor::Record)
|
||
.unwrap();
|
||
// 普通 Record 作为无类型后端存储，只有代理持有时也须存活。
|
||
let storage = store.new_object().unwrap();
|
||
// 旧属性值先由测试根持有，之后转由字段强边持有。
|
||
let old_value = store.new_object().unwrap();
|
||
// 弱句柄不持有旧值，替换存储后可观测其真正释放。
|
||
let weak_value = store.downgrade(old_value).unwrap();
|
||
store
|
||
.set_attr(storage, "value", Value::Object(old_value))
|
||
.unwrap();
|
||
// 归还外部根，留下 storage.value 一条强边。
|
||
store.release(old_value).unwrap();
|
||
// Proxy 的 trace 持有后端，字段实际写入后端但类型留在 Proxy 头部。
|
||
let proxy = store.allocate(Proxy(storage)).unwrap();
|
||
store.attach_type(proxy, class).unwrap();
|
||
// 归还后端外部根后仍由 Proxy 的载荷边维持存活。
|
||
store.release(storage).unwrap();
|
||
// 确认路径同时包含门面和终点，不只返回头部类型对象。
|
||
assert_eq!(store.attribute_path(proxy).unwrap(), vec![proxy, storage]);
|
||
// 保留 type 属性查询代理自身名义类型，不跟随后端身份变化。
|
||
assert_eq!(store.get_attr(proxy, "type").unwrap(), Value::Object(class));
|
||
assert_eq!(
|
||
store.get_attr(proxy, "value").unwrap(),
|
||
Value::Object(old_value)
|
||
);
|
||
// 新后端先由根持有，替换成功后 Proxy 自己持有一条边。
|
||
let next = store.new_object().unwrap();
|
||
// 受控替换重新登记边，旧后端及其唯一持有的属性值应被级联释放。
|
||
store.replace_payload(proxy, Proxy(next)).unwrap();
|
||
// 归还新后端根，后续访问证明其仍由 Proxy 强边保留。
|
||
store.release(next).unwrap();
|
||
// 旧值没有残余根，弱升级必须返回 None。
|
||
assert!(store.upgrade(weak_value).unwrap().is_none());
|
||
store
|
||
.set_attr(proxy, "value", Value::Number(9_i64.into()))
|
||
.unwrap();
|
||
assert_eq!(
|
||
store.get_attr(next, "value").unwrap(),
|
||
Value::Number(9_i64.into())
|
||
);
|
||
// 通过代理删除应作用于新后端，不只是门面自己的属性表。
|
||
store.del_attr(proxy, "value").unwrap();
|
||
assert!(store.get_attr(next, "value").is_err());
|
||
// 逐项释放测试拥有根，不手动 release 内部边，避免重复归还。
|
||
for object in [proxy, class, roots.object, roots.type_type] {
|
||
store.release(object).unwrap();
|
||
}
|
||
// 回收类型自举环及其他已无外部根的环，最终堆应为空。
|
||
store.collect_cycles();
|
||
assert_eq!(store.object_count(), 0);
|
||
}
|
||
|
||
#[test]
|
||
/// 验证属性转发环和异堆身份被拒绝，失败不产生新的变更版本。
|
||
fn cyclic_and_foreign_attribute_storage_fail_without_mutating_fields() {
|
||
// 建立独立堆隔离场景，所有分配根在测试末尾明确归还。
|
||
let mut store = ObjectStore::new().unwrap();
|
||
// 普通 Record 作为无类型后端存储，只有代理持有时也须存活。
|
||
let storage = store.new_object().unwrap();
|
||
// Proxy 的 trace 持有后端，字段实际写入后端但类型留在 Proxy 头部。
|
||
let proxy = store.allocate(Proxy(storage)).unwrap();
|
||
// 注入合法托管自环但非法属性转发环；属性路径必须检测，不无限循环。
|
||
store.replace_payload(proxy, Proxy(proxy)).unwrap();
|
||
// 记录失败读写前版本，路径检查失败不得修改对象。
|
||
let version = store.change_version(proxy).unwrap();
|
||
assert!(store.get_attr(proxy, "field").is_err());
|
||
assert!(store.set_attr(proxy, "field", Value::Nil).is_err());
|
||
assert_eq!(store.change_version(proxy).unwrap(), version);
|
||
// 异堆即使槽号相同也必须报 ForeignHandle，不当成普通缺字段。
|
||
let other = ObjectStore::new().unwrap();
|
||
assert_eq!(other.attribute_path(proxy), Err(VmError::ForeignHandle));
|
||
// 归还后端外部根后仍由 Proxy 的载荷边维持存活。
|
||
store.release(storage).unwrap();
|
||
store.release(proxy).unwrap();
|
||
// 外部根释放后只有 Proxy 自环残留，显式回收恰好一个对象。
|
||
assert_eq!(store.collect_cycles(), 1);
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
/// 拥有一个 Cell，type_target 读 Cell 指回自己，测试递归属性查询。
|
||
struct ReflectiveType(ObjectRef);
|
||
impl ObjectPayload for ReflectiveType {
|
||
/// Store 下转型测试载荷，不进行语言类型判定。
|
||
fn as_any(&self) -> &dyn std::any::Any {
|
||
self
|
||
}
|
||
/// 测试错误/诊断使用的类别标签。
|
||
fn kind_name(&self) -> &'static str {
|
||
"reflective-type"
|
||
}
|
||
/// 反射对象自行存字段，允许 selector 查询从公共属性表读取。
|
||
fn allows_attributes(&self) -> bool {
|
||
true
|
||
}
|
||
/// Heap 分配/替换时记录一条拥有边，确保被代理存储或自引用 Cell 存活。
|
||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||
visit(self.0);
|
||
}
|
||
/// Store::type_of 调用时通过 Cell 找自己并读 selector，专门制造属性检查重入。
|
||
fn type_target(&self, store: &ObjectStore) -> Result<Option<ObjectRef>, VmError> {
|
||
// Cell 初始 Nil 时不重入，安装自引用后读自身 selector 触发保护守卫路径。
|
||
if let Value::Object(receiver) = store.cell_get(self.0)? {
|
||
store.get_attr(receiver, "selector")?;
|
||
}
|
||
Ok(None)
|
||
}
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
/// 无捕获且不修改存储的能力方法测试实现；完整签名供声明/调用门禁读取。
|
||
struct TypedCheck;
|
||
impl objects::NativeCallable for TypedCheck {
|
||
/// 为 check 声明显式 self、Number 返回和 ReadOnly 效果，供能力契约核对。
|
||
fn signature(&self) -> Option<objects::CallSignature> {
|
||
Some(objects::CallSignature::exact(
|
||
vec![objects::AnnotationType::Any],
|
||
objects::AnnotationType::Number,
|
||
objects::CallEffect::ReadOnly,
|
||
))
|
||
}
|
||
/// 原生分派返回直接整数，无对象结果需要额外保留；本文件主要验证契约门禁。
|
||
fn invoke(
|
||
&self,
|
||
_: &mut objects::NativeContext<'_>,
|
||
_: &[Value],
|
||
) -> Result<objects::NativeResult, VmError> {
|
||
Ok(objects::NativeResult::Return(Value::Number(1.into())))
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
/// 验证能力声明/调用各入口均拒绝同名字段遮蔽，且递归守卫失败后正确清理。
|
||
fn typed_method_storage_cannot_diverge_from_class_dispatch() {
|
||
// 建立独立堆隔离场景，所有分配根在测试末尾明确归还。
|
||
let mut store = ObjectStore::new().unwrap();
|
||
// 自举 Object/Type，各有一份外部根；其图内自环需最终 collect_cycles。
|
||
let roots = store.bootstrap_types().unwrap();
|
||
// 给代理/反射实例附着真实名义类型，字段转发不应替换它。
|
||
let class = store
|
||
.new_type("Checked", roots.object, TypeConstructor::Record)
|
||
.unwrap();
|
||
// 上下文原生函数发布完整签名；类方法表还会单独拥有它的强边。
|
||
let function = store
|
||
.allocate(objects::ContextNativeFunction::new(
|
||
"check",
|
||
TypedCheck,
|
||
vec![],
|
||
))
|
||
.unwrap();
|
||
store.define_method(class, "check", function).unwrap();
|
||
// 能力要求与原生方法完整契约一致，包含显式 self 参数。
|
||
let capability = store
|
||
.new_typed_trait(
|
||
"Checked",
|
||
vec![objects::TypedMethodRequirement {
|
||
name: "check".into(),
|
||
signature: objects::CallSignature::exact(
|
||
vec![objects::AnnotationType::Any],
|
||
objects::AnnotationType::Number,
|
||
objects::CallEffect::ReadOnly,
|
||
),
|
||
}],
|
||
)
|
||
.unwrap();
|
||
// 普通 Record 作为无类型后端存储，只有代理持有时也须存活。
|
||
let storage = store.new_object().unwrap();
|
||
// Proxy 的 trace 持有后端，字段实际写入后端但类型留在 Proxy 头部。
|
||
let proxy = store.allocate(Proxy(storage)).unwrap();
|
||
store.attach_type(proxy, class).unwrap();
|
||
// 直接写无类型后端可以造出对代理而言不符合能力的实例，后续门禁应拒绝。
|
||
store.set_attr(storage, "check", Value::Nil).unwrap();
|
||
// 能力声明失败应保持定义版本和声明集合不变。
|
||
let version = store.change_version(class).unwrap();
|
||
assert!(matches!(
|
||
// 当前后端仍有遮蔽字段，能力声明必须在状态提交前失败。
|
||
store.implement_trait(class, capability),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
assert_eq!(store.change_version(class).unwrap(), version);
|
||
// 失败声明不能留下一半能力关系。
|
||
assert!(!store.implements_trait(class, capability).unwrap());
|
||
// 删除遮蔽字段恢复合法存储，后续能力声明/查询应重新成功。
|
||
store.del_attr(storage, "check").unwrap();
|
||
// 存储冲突消除后能力声明才允许提交。
|
||
store.implement_trait(class, capability).unwrap();
|
||
// 代理受控写入在真正触及后端前失败，后端版本不得增加。
|
||
let version = store.change_version(storage).unwrap();
|
||
assert!(matches!(
|
||
store.set_attr(proxy, "check", Value::Nil),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
assert_eq!(store.change_version(storage).unwrap(), version);
|
||
assert!(store.supports(proxy, capability).unwrap());
|
||
// 可信宿主能直接写无类型后端；supports/get_attr/bind_attr/调用检查/直接存储检查都必须发现失效实例。
|
||
// 直接写无类型后端可以造出对代理而言不符合能力的实例，后续门禁应拒绝。
|
||
store.set_attr(storage, "check", Value::Nil).unwrap();
|
||
assert!(matches!(
|
||
store.supports(proxy, capability),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 后端已出现遮蔽方法的冲突字段时，即使只读属性查询也必须拒绝不合法的能力存储。
|
||
assert!(matches!(
|
||
store.get_attr(proxy, "check"),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 绑定方法入口不能绕过同一存储校验，不能先创建可调用绑定再放过冲突。
|
||
assert!(matches!(
|
||
store.bind_attr(proxy, "check"),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 直接方法契约检查也拒绝代理后端冲突，防止跳过属性查找后绕过门禁。
|
||
assert!(matches!(
|
||
store.check_method_contract_call(function, proxy, false),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 显式实例存储检查应给出同类能力违规，保持各调用入口的检查一致。
|
||
assert!(matches!(
|
||
store.check_typed_instance_storage(proxy),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 另建已有冲突字段的记录，验证 attach_type 也守住能力存储约束。
|
||
let candidate = store.new_object().unwrap();
|
||
// 先放同名字段再附着类型，不能绕过“创建后写入”的校验。
|
||
store.set_attr(candidate, "check", Value::Nil).unwrap();
|
||
assert!(matches!(
|
||
store.attach_type(candidate, class),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 附着失败不能留下部分头部类型关系。
|
||
assert_eq!(store.type_of(candidate).unwrap(), None);
|
||
// 删除遮蔽字段恢复合法存储，后续能力声明/查询应重新成功。
|
||
store.del_attr(storage, "check").unwrap();
|
||
assert!(store.supports(proxy, capability).unwrap());
|
||
assert_eq!(
|
||
store.get_attr(proxy, "check").unwrap(),
|
||
Value::Object(function)
|
||
);
|
||
store
|
||
.check_method_contract_call(function, proxy, false)
|
||
.unwrap();
|
||
// 用托管 Cell 保存反射对象，初始 Nil 避免初始化时就递归查询未设字段。
|
||
let self_cell = store.new_cell(Some(Value::Nil)).unwrap();
|
||
// 载荷持有 Cell，Cell 稍后反向持有对象，形成可回收的托管环。
|
||
let reflective = store.allocate(ReflectiveType(self_cell)).unwrap();
|
||
store
|
||
.set_attr(reflective, "selector", Value::Bool(true))
|
||
.unwrap();
|
||
store
|
||
.cell_set(self_cell, Value::Object(reflective))
|
||
.unwrap();
|
||
// 附着能力类型期间查询 selector 会重入检查，守卫应避免无限递归。
|
||
store.attach_type(reflective, class).unwrap();
|
||
assert_eq!(
|
||
store.get_attr(reflective, "selector").unwrap(),
|
||
Value::Bool(true)
|
||
);
|
||
assert!(store.supports(reflective, capability).unwrap());
|
||
// 带反射检查的载荷第一次非法写入仍须拒绝，递归防护不能误跳过最外层约束。
|
||
assert!(matches!(
|
||
store.set_attr(reflective, "check", Value::Nil),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 首次失败必须通过 RAII 移除标记；第二次同样的非法写入仍应失败，不能被误当成递归跳过。
|
||
assert!(matches!(
|
||
store.set_attr(reflective, "check", Value::Nil),
|
||
Err(VmError::TraitViolation { .. })
|
||
));
|
||
// 归还自引用图外部根；环内边仍在，统一由最终回收处理。
|
||
store.release(reflective).unwrap();
|
||
// Cell 的外部根也归还，不能仅释放反射门面而留下测试根。
|
||
store.release(self_cell).unwrap();
|
||
|
||
// 逐项释放测试拥有根，不手动 release 内部边，避免重复归还。
|
||
for object in [
|
||
candidate,
|
||
proxy,
|
||
storage,
|
||
function,
|
||
capability,
|
||
class,
|
||
roots.object,
|
||
roots.type_type,
|
||
] {
|
||
store.release(object).unwrap();
|
||
}
|
||
// 回收类型自举环及其他已无外部根的环，最终堆应为空。
|
||
store.collect_cycles();
|
||
assert_eq!(store.object_count(), 0);
|
||
}
|