Shorten crate directory names and update workspace paths
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 14m53s
Verify databases and deploy Aster VM / verify-and-deploy (push) Successful in 14m53s
This commit is contained in:
@@ -0,0 +1,343 @@
|
||||
use aster_core::{
|
||||
CompareOp, EndorBaseExceptionObject, EndorCode, EndorDictObject, EndorFunctionObject,
|
||||
EndorInteger, EndorNativeFunctionObject, EndorNumber, EndorNumberObject, EndorReal,
|
||||
EndorStringObject, EndorTracebackEntry, Value, Vm, VmError,
|
||||
};
|
||||
|
||||
fn text(value: &str) -> Value {
|
||||
Value::Text(value.into())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn numbers_preserve_large_digits_decimal_scale_exponents_and_fraction_parts() {
|
||||
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());
|
||||
for invalid in ["", "+", " 1", "1 ", "1_000", "12", "1.0"] {
|
||||
assert!(EndorNumber::integer(invalid).is_err(), "{invalid}");
|
||||
}
|
||||
for invalid in ["", ".", "1.2.3", "1e", "1e+", "1e2e3", "nan", " 0.1", "--1"] {
|
||||
assert!(EndorNumber::decimal(invalid).is_err(), "{invalid}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn number_objects_preserve_ieee_bits_and_reject_undefined_numeric_operations() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let bits = 0x7ff8_0000_0000_0042;
|
||||
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(),
|
||||
);
|
||||
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]
|
||||
fn strings_use_unicode_characters_and_content_equality() {
|
||||
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();
|
||||
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() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
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() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
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"))
|
||||
);
|
||||
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();
|
||||
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]
|
||||
fn cells_share_rebinding_distinguish_empty_and_none_and_keep_stable_objects() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
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);
|
||||
let child = vm.new_object().unwrap();
|
||||
vm.cell_set(cell, Value::Object(child)).unwrap();
|
||||
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]
|
||||
fn container_cycles_and_duplicate_edges_are_collected() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let dict = vm.new_dict().unwrap();
|
||||
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();
|
||||
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() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let globals = vm.new_dict().unwrap();
|
||||
let constant = vm.new_string("constant").unwrap();
|
||||
let cell = vm.new_cell(Some(text("first"))).unwrap();
|
||||
let code = EndorCode::new(
|
||||
vec![0],
|
||||
vec![Value::Object(constant)],
|
||||
vec!["argument".into()],
|
||||
vec!["captured".into()],
|
||||
)
|
||||
.unwrap();
|
||||
let function = vm
|
||||
.allocate(
|
||||
EndorFunctionObject::new(
|
||||
"read",
|
||||
code.clone(),
|
||||
globals,
|
||||
vec![Value::Object(constant)],
|
||||
vec![cell],
|
||||
)
|
||||
.unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
let second = vm
|
||||
.allocate(
|
||||
EndorFunctionObject::new("read_again", code, globals, vec![], vec![cell]).unwrap(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(vm.ref_count(constant).unwrap(), 4);
|
||||
vm.release(constant).unwrap();
|
||||
vm.release(cell).unwrap();
|
||||
vm.cell_set(cell, text("updated")).unwrap();
|
||||
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, &[]),
|
||||
Err(VmError::UnsupportedOperation("language function execution"))
|
||||
);
|
||||
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(), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_function_environments_are_rejected_without_retaining_any_edges() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let globals = vm.new_object().unwrap();
|
||||
let code = EndorCode::new(vec![], vec![], vec![], vec![]).unwrap();
|
||||
let function = EndorFunctionObject::new("bad", code, globals, vec![], vec![]).unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(function),
|
||||
Err(VmError::ObjectKindMismatch("dict"))
|
||||
);
|
||||
assert_eq!(vm.ref_count(globals).unwrap(), 1);
|
||||
assert!(EndorCode::new(vec![], vec![], vec!["x".into(), "x".into()], vec![]).is_err());
|
||||
let code = EndorCode::new(vec![], vec![], vec![], vec!["x".into()]).unwrap();
|
||||
assert!(EndorFunctionObject::new("bad", code, globals, vec![], vec![]).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exceptions_preserve_arguments_chains_notes_and_traceback_without_type_classes() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let argument = vm.new_string("detail").unwrap();
|
||||
let cause = vm
|
||||
.allocate(EndorBaseExceptionObject::new(
|
||||
"ValueError",
|
||||
vec![Value::Object(argument)],
|
||||
))
|
||||
.unwrap();
|
||||
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();
|
||||
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");
|
||||
vm.release(exception).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
let wrong = vm.new_dict().unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(EndorBaseExceptionObject::new("Error", vec![]).with_cause(wrong)),
|
||||
Err(VmError::ObjectKindMismatch("exception"))
|
||||
);
|
||||
}
|
||||
|
||||
fn echo(arguments: &[Value]) -> Result<Value, VmError> {
|
||||
match arguments {
|
||||
[value] => Ok(value.clone()),
|
||||
_ => Err(VmError::InvalidArgument("expected one value")),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_functions_pass_lossless_numbers_and_borrowed_objects() {
|
||||
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();
|
||||
assert_eq!(
|
||||
vm.call(function, &[Value::Object(dict)]).unwrap(),
|
||||
Value::Object(dict)
|
||||
);
|
||||
assert_eq!(vm.ref_count(dict).unwrap(), 1);
|
||||
assert_eq!(
|
||||
vm.payload::<EndorDictObject>(dict, "dict").unwrap().len(),
|
||||
0
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,480 @@
|
||||
use std::any::Any;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
use aster_core::{CompareOp, NativeFunction, ObjectPayload, ObjectRef, Record, Value, Vm, VmError};
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Resource {
|
||||
drops: Arc<AtomicUsize>,
|
||||
edges: Vec<ObjectRef>,
|
||||
}
|
||||
|
||||
impl Drop for Resource {
|
||||
fn drop(&mut self) {
|
||||
self.drops.fetch_add(1, Ordering::SeqCst);
|
||||
}
|
||||
}
|
||||
|
||||
impl ObjectPayload for Resource {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"resource"
|
||||
}
|
||||
|
||||
fn trace(&self, visit: &mut dyn FnMut(ObjectRef)) {
|
||||
for reference in &self.edges {
|
||||
visit(*reference);
|
||||
}
|
||||
}
|
||||
|
||||
fn allows_attributes(&self) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Number(i64);
|
||||
|
||||
impl ObjectPayload for Number {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"number"
|
||||
}
|
||||
|
||||
fn repr(&self, _identity: ObjectRef) -> Result<String, VmError> {
|
||||
Ok(self.0.to_string())
|
||||
}
|
||||
|
||||
fn is_true(&self) -> Result<bool, VmError> {
|
||||
Ok(self.0 != 0)
|
||||
}
|
||||
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Ok(self.0 as u64)
|
||||
}
|
||||
|
||||
fn compare(
|
||||
&self,
|
||||
other: &dyn ObjectPayload,
|
||||
operation: CompareOp,
|
||||
) -> Result<Option<bool>, VmError> {
|
||||
let Some(other) = other.as_any().downcast_ref::<Self>() else {
|
||||
return Ok(None);
|
||||
};
|
||||
Ok(Some(match operation {
|
||||
CompareOp::Eq => self.0 == other.0,
|
||||
CompareOp::Ne => self.0 != other.0,
|
||||
CompareOp::Lt => self.0 < other.0,
|
||||
CompareOp::Le => self.0 <= other.0,
|
||||
CompareOp::Gt => self.0 > other.0,
|
||||
CompareOp::Ge => self.0 >= other.0,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
fn resource(vm: &mut Vm, drops: &Arc<AtomicUsize>, edges: Vec<ObjectRef>) -> ObjectRef {
|
||||
vm.allocate(Resource {
|
||||
drops: drops.clone(),
|
||||
edges,
|
||||
})
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn starts_empty_without_language_classes_or_a_type_system() {
|
||||
let vm = Vm::new().unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_provide_identity_representation_hash_and_truth() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = vm.new_object().unwrap();
|
||||
let second = vm.new_object().unwrap();
|
||||
assert_eq!(vm.object(first).unwrap().header().identity(), first);
|
||||
assert!(vm.is_same(first, first).unwrap());
|
||||
assert!(!vm.is_same(first, second).unwrap());
|
||||
assert!(vm.repr(first).unwrap().contains(&first.to_string()));
|
||||
assert_eq!(vm.repr(first).unwrap(), vm.str(first).unwrap());
|
||||
assert_eq!(vm.hash(first).unwrap(), vm.hash(first).unwrap());
|
||||
assert!(vm.is_true(first).unwrap());
|
||||
assert!(vm.compare(first, first, CompareOp::Eq).unwrap());
|
||||
assert!(vm.compare(first, second, CompareOp::Ne).unwrap());
|
||||
assert_eq!(
|
||||
vm.compare(first, second, CompareOp::Lt),
|
||||
Err(VmError::UnsupportedOperation("ordering"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(first, &[]),
|
||||
Err(VmError::UnsupportedOperation("call"))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_references_control_lifetime_and_copies_are_borrowed() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owned = resource(&mut vm, &drops, vec![]);
|
||||
let borrowed = owned;
|
||||
assert_eq!(vm.ref_count(borrowed).unwrap(), 1);
|
||||
vm.retain(owned).unwrap();
|
||||
assert_eq!(vm.ref_count(owned).unwrap(), 2);
|
||||
vm.release(owned).unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 0);
|
||||
vm.release(owned).unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
assert!(matches!(vm.object(borrowed), Err(VmError::InvalidHandle)));
|
||||
assert_eq!(vm.release(borrowed), Err(VmError::InvalidHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn attributes_keep_objects_alive_and_delete_releases_them() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let child = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(owner, "child", Value::Object(child)).unwrap();
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 2);
|
||||
vm.release(child).unwrap();
|
||||
assert_eq!(vm.ref_count(child).unwrap(), 1);
|
||||
assert_eq!(vm.release(child), Err(VmError::NoOwnedReference));
|
||||
assert_eq!(vm.get_attr(owner, "child").unwrap(), Value::Object(child));
|
||||
vm.del_attr(owner, "child").unwrap();
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "child"),
|
||||
Err(VmError::AttributeNotFound("child".into()))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replacing_the_same_edge_does_not_destroy_the_target() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let target = vm.new_object().unwrap();
|
||||
vm.set_attr(owner, "child", Value::Object(target)).unwrap();
|
||||
vm.release(target).unwrap();
|
||||
vm.set_attr(owner, "child", Value::Object(target)).unwrap();
|
||||
assert_eq!(vm.ref_count(target).unwrap(), 1);
|
||||
vm.set_attr(owner, "child", Value::Number(7_i64.into()))
|
||||
.unwrap();
|
||||
assert!(matches!(vm.object(target), Err(VmError::InvalidHandle)));
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "child").unwrap(),
|
||||
Value::Number(7_i64.into())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn borrowed_attribute_results_can_be_retained_by_the_host() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let parent = vm.new_object().unwrap();
|
||||
let child = vm.new_object().unwrap();
|
||||
vm.set_attr(parent, "child", Value::Object(child)).unwrap();
|
||||
vm.release(child).unwrap();
|
||||
let Value::Object(borrowed) = vm.get_attr(parent, "child").unwrap() else {
|
||||
panic!("expected an object");
|
||||
};
|
||||
vm.retain(borrowed).unwrap();
|
||||
vm.release(parent).unwrap();
|
||||
assert_eq!(vm.ref_count(borrowed).unwrap(), 1);
|
||||
vm.release(borrowed).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_foreign_and_stale_writes_preserve_the_old_attribute() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let owner = vm.new_object().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let stale = vm.new_object().unwrap();
|
||||
vm.release(stale).unwrap();
|
||||
vm.set_attr(owner, "value", Value::Number(1_i64.into()))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.set_attr(owner, "value", Value::Object(foreign)),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(
|
||||
vm.set_attr(owner, "value", Value::Object(stale)),
|
||||
Err(VmError::InvalidHandle)
|
||||
);
|
||||
assert_eq!(
|
||||
vm.get_attr(owner, "value").unwrap(),
|
||||
Value::Number(1_i64.into())
|
||||
);
|
||||
assert_eq!(vm.retain(foreign), Err(VmError::ForeignHandle));
|
||||
assert_eq!(vm.release(foreign), Err(VmError::ForeignHandle));
|
||||
assert_eq!(vm.is_same(owner, foreign), Err(VmError::ForeignHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn released_handles_cannot_alias_new_objects_or_new_vms() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let old = vm.new_object().unwrap();
|
||||
vm.release(old).unwrap();
|
||||
let new = vm.new_object().unwrap();
|
||||
assert_ne!(old, new);
|
||||
assert_eq!(vm.repr(old), Err(VmError::InvalidHandle));
|
||||
let other = Vm::new().unwrap();
|
||||
assert!(matches!(other.object(new), Err(VmError::ForeignHandle)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn boxed_objects_keep_their_addresses_when_the_slot_vector_grows() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = vm.new_object().unwrap();
|
||||
let address = std::ptr::from_ref(vm.object(first).unwrap());
|
||||
for _ in 0..4096 {
|
||||
vm.new_object().unwrap();
|
||||
}
|
||||
assert_eq!(std::ptr::from_ref(vm.object(first).unwrap()), address);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zero_reference_chains_are_released_without_recursive_destructors() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let head = vm.new_object().unwrap();
|
||||
let mut tail = head;
|
||||
for _ in 0..4096 {
|
||||
let next = vm.new_object().unwrap();
|
||||
vm.set_attr(tail, "next", Value::Object(next)).unwrap();
|
||||
vm.release(next).unwrap();
|
||||
tail = next;
|
||||
}
|
||||
vm.release(head).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cycles_remain_while_rooted_and_are_collected_when_unreachable() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let first = resource(&mut vm, &drops, vec![]);
|
||||
let second = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(first, "next", Value::Object(second)).unwrap();
|
||||
vm.set_attr(second, "next", Value::Object(first)).unwrap();
|
||||
vm.release(second).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 0);
|
||||
vm.release(first).unwrap();
|
||||
assert_eq!(vm.object_count(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 0);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 2);
|
||||
assert!(matches!(vm.object(first), Err(VmError::InvalidHandle)));
|
||||
assert!(matches!(vm.object(second), Err(VmError::InvalidHandle)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cycle_collection_preserves_rooted_targets_and_updates_counts() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let live = vm.new_object().unwrap();
|
||||
let cycle = vm.new_object().unwrap();
|
||||
vm.set_attr(cycle, "self", Value::Object(cycle)).unwrap();
|
||||
vm.set_attr(cycle, "live", Value::Object(live)).unwrap();
|
||||
vm.release(cycle).unwrap();
|
||||
assert_eq!(vm.ref_count(live).unwrap(), 2);
|
||||
assert_eq!(vm.collect_cycles(), 1);
|
||||
assert_eq!(vm.ref_count(live).unwrap(), 1);
|
||||
vm.release(live).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn payload_edges_are_owned_and_duplicate_edges_are_counted() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let target = vm.new_object().unwrap();
|
||||
let holder = resource(&mut vm, &drops, vec![target, target]);
|
||||
assert_eq!(vm.ref_count(target).unwrap(), 3);
|
||||
vm.release(target).unwrap();
|
||||
vm.release(holder).unwrap();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn payload_edges_participate_in_cycle_tracing() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let record = vm.new_object().unwrap();
|
||||
let native = resource(&mut vm, &drops, vec![record]);
|
||||
vm.set_attr(record, "native", Value::Object(native))
|
||||
.unwrap();
|
||||
vm.release(record).unwrap();
|
||||
vm.release(native).unwrap();
|
||||
assert_eq!(vm.collect_cycles(), 2);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_payload_edges_abort_allocation_without_retaining_valid_edges() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let local = vm.new_object().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
assert_eq!(
|
||||
vm.allocate(Resource {
|
||||
drops: drops.clone(),
|
||||
edges: vec![local, foreign],
|
||||
}),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
assert_eq!(vm.ref_count(local).unwrap(), 1);
|
||||
assert_eq!(vm.object_count(), 1);
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rust_payload_operations_override_defaults_without_language_types() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let zero = vm.allocate(Number(0)).unwrap();
|
||||
let first = vm.allocate(Number(42)).unwrap();
|
||||
let equal = vm.allocate(Number(42)).unwrap();
|
||||
assert!(!vm.is_same(first, equal).unwrap());
|
||||
assert!(vm.compare(first, equal, CompareOp::Eq).unwrap());
|
||||
assert!(vm.compare(zero, first, CompareOp::Lt).unwrap());
|
||||
assert_eq!(vm.hash(first).unwrap(), vm.hash(equal).unwrap());
|
||||
assert_eq!(vm.str(first).unwrap(), "42");
|
||||
assert!(!vm.is_true(zero).unwrap());
|
||||
assert!(vm.is_true(first).unwrap());
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ReflectedOrdering;
|
||||
|
||||
impl ObjectPayload for ReflectedOrdering {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"reflected-ordering"
|
||||
}
|
||||
|
||||
fn compare(
|
||||
&self,
|
||||
_other: &dyn ObjectPayload,
|
||||
operation: CompareOp,
|
||||
) -> Result<Option<bool>, VmError> {
|
||||
Ok(Some(operation == CompareOp::Gt))
|
||||
}
|
||||
|
||||
fn hash(&self, _identity: ObjectRef) -> Result<u64, VmError> {
|
||||
Err(VmError::UnsupportedOperation("hash"))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reflected_operations_and_explicitly_unsupported_hashing_are_respected() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let left = vm.allocate(Record).unwrap();
|
||||
let right = vm.allocate(ReflectedOrdering).unwrap();
|
||||
assert!(vm.compare(left, right, CompareOp::Lt).unwrap());
|
||||
assert_eq!(vm.hash(right), Err(VmError::UnsupportedOperation("hash")));
|
||||
}
|
||||
|
||||
fn add(arguments: &[Value]) -> Result<Value, VmError> {
|
||||
match arguments {
|
||||
[Value::Number(left), Value::Number(right)] => {
|
||||
let (left, right) = left
|
||||
.as_i64()
|
||||
.zip(right.as_i64())
|
||||
.ok_or(VmError::InvalidArgument("expected two integers"))?;
|
||||
left.checked_add(right)
|
||||
.map(|value| Value::Number(value.into()))
|
||||
.ok_or(VmError::InvalidArgument("integer overflow"))
|
||||
}
|
||||
_ => Err(VmError::InvalidArgument("expected two integers")),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_calls_dispatch_validate_arguments_and_propagate_errors() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let function = vm.allocate(NativeFunction::new("add", add)).unwrap();
|
||||
assert_eq!(vm.repr(function).unwrap(), "<native-function add>");
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[Value::Number(2_i64.into()), Value::Number(3_i64.into())]
|
||||
)
|
||||
.unwrap(),
|
||||
Value::Number(5_i64.into())
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(function, &[]),
|
||||
Err(VmError::InvalidArgument("expected two integers"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.call(
|
||||
function,
|
||||
&[Value::Number(i64::MAX.into()), Value::Number(1_i64.into())]
|
||||
),
|
||||
Err(VmError::InvalidArgument("integer overflow"))
|
||||
);
|
||||
assert_eq!(
|
||||
vm.set_attr(function, "x", Value::Nil),
|
||||
Err(VmError::UnsupportedOperation("attributes"))
|
||||
);
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
assert_eq!(
|
||||
vm.call(function, &[Value::Object(foreign)]),
|
||||
Err(VmError::ForeignHandle)
|
||||
);
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct ReturnsObject(ObjectRef);
|
||||
|
||||
impl ObjectPayload for ReturnsObject {
|
||||
fn as_any(&self) -> &dyn Any {
|
||||
self
|
||||
}
|
||||
|
||||
fn kind_name(&self) -> &'static str {
|
||||
"invalid-return"
|
||||
}
|
||||
|
||||
fn call(&self, _arguments: &[Value]) -> Result<Value, VmError> {
|
||||
Ok(Value::Object(self.0))
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_results_cannot_smuggle_foreign_or_dead_handles_into_the_vm() {
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let mut other = Vm::new().unwrap();
|
||||
let foreign = other.new_object().unwrap();
|
||||
let invalid_return = vm.allocate(ReturnsObject(foreign)).unwrap();
|
||||
assert_eq!(vm.call(invalid_return, &[]), Err(VmError::ForeignHandle));
|
||||
let dead = vm.new_object().unwrap();
|
||||
vm.release(dead).unwrap();
|
||||
let invalid_return = vm.allocate(ReturnsObject(dead)).unwrap();
|
||||
assert_eq!(vm.call(invalid_return, &[]), Err(VmError::InvalidHandle));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dropping_the_vm_cleans_up_rooted_objects_and_uncollected_cycles() {
|
||||
let drops = Arc::new(AtomicUsize::new(0));
|
||||
{
|
||||
let mut vm = Vm::new().unwrap();
|
||||
let rooted = resource(&mut vm, &drops, vec![]);
|
||||
let cycle = resource(&mut vm, &drops, vec![]);
|
||||
vm.set_attr(cycle, "self", Value::Object(cycle)).unwrap();
|
||||
vm.release(cycle).unwrap();
|
||||
assert_eq!(vm.ref_count(rooted).unwrap(), 1);
|
||||
}
|
||||
assert_eq!(drops.load(Ordering::SeqCst), 2);
|
||||
}
|
||||
Reference in New Issue
Block a user