feat: 支持 Date/Map/Set 成员方法

crates/oxide_vm/tests/builtins_boolean_tests.rs

@@ -0,0 +1,82 @@
+use oxide_types::object::JsObject;
+use oxide_types::value::JsValue;
+use oxide_vm::builtins::boolean::{
+    boolean_constructor, boolean_prototype_to_string, boolean_prototype_value_of,
+};
+use oxide_vm::vm::Vm;
+
+use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
+
+fn bool_ctor_call(vm: &mut Vm, arg: JsValue) -> JsValue {
+    vm.set_reg(1, arg);
+    boolean_constructor(vm, &[0, 1]).unwrap()
+}
+
+fn tbool_wrap(vm: &mut Vm, arg: JsValue) -> JsValue {
+    let proto_ptr = vm.kernel().builtin_world().boolean_proto.as_ptr() as *mut JsObject;
+    let wrapper = JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(proto_ptr));
+    let ptr = vm.epoch().alloc(wrapper);
+    let val = JsValue::from_js_object(ptr);
+    vm.set_reg(0, val);
+    vm.set_reg(1, arg);
+    boolean_constructor(vm, &[0, 1]).unwrap()
+}
+
+#[test]
+fn tboolean_call_true() {
+    let mut vm = Vm::new();
+    assert!(bool_ctor_call(&mut vm, JsValue::float(1.0)).as_bool());
+}
+
+#[test]
+fn tboolean_call_false() {
+    let mut vm = Vm::new();
+    assert!(!bool_ctor_call(&mut vm, JsValue::float(0.0)).as_bool());
+}
+
+#[test]
+fn tboolean_call_empty_is_false() {
+    let mut vm = Vm::new();
+    let empty = vm.intern("");
+    assert!(!bool_ctor_call(&mut vm, empty).as_bool());
+}
+
+#[test]
+fn tboolean_new_value_of_true() {
+    let mut vm = Vm::new();
+    let wrapper = tbool_wrap(&mut vm, JsValue::float(1.0));
+    vm.set_reg(0, wrapper);
+    assert!(boolean_prototype_value_of(&mut vm, &[0]).unwrap().as_bool());
+}
+
+#[test]
+fn tboolean_new_value_of_false() {
+    let mut vm = Vm::new();
+    let wrapper = tbool_wrap(&mut vm, JsValue::float(0.0));
+    vm.set_reg(0, wrapper);
+    assert!(!boolean_prototype_value_of(&mut vm, &[0]).unwrap().as_bool());
+}
+
+#[test]
+fn tboolean_new_tostring() {
+    let mut vm = Vm::new();
+    let w = tbool_wrap(&mut vm, JsValue::float(1.0));
+    vm.set_reg(0, w);
+    let r = boolean_prototype_to_string(&mut vm, &[0]).unwrap();
+    let s = vm
+        .kernel()
+        .string_forge()
+        .lookup(r.as_string_index())
+        .unwrap();
+    assert_eq!(s, "true");
+
+    let w2 = tbool_wrap(&mut vm, JsValue::float(0.0));
+    vm.set_reg(0, w2);
+    let r2 = boolean_prototype_to_string(&mut vm, &[0]).unwrap();
+    let s2 = vm
+        .kernel()
+        .string_forge()
+        .lookup(r2.as_string_index())
+        .unwrap();
+    assert_eq!(s2, "false");
+}

crates/oxide_vm/tests/builtins_date_tests.rs

@@ -0,0 +1,45 @@
+use oxide_compiler::compiler::Compiler;
+use oxide_vm::vm::Vm;
+
+fn eval(vm: &mut Vm, source: &str) -> Result<oxide_types::value::JsValue, String> {
+    let allocator = oxide_parser::Allocator::default();
+    let program =
+        oxide_parser::parse(&allocator, source).map_err(|e| format!("Parse error: {:?}", e))?;
+    let module = Compiler::new()
+        .compile(&program)
+        .map_err(|e| format!("Compile error: {}", e))?;
+    vm.run(&module)
+}
+
+#[test]
+fn date_now_returns_number() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "Date.now()").unwrap();
+    assert!(result.is_double());
+    assert!(result.as_double() > 0.0);
+}
+
+#[test]
+fn date_now_increases() {
+    let mut vm = Vm::new();
+    let t1 = eval(&mut vm, "Date.now()").unwrap().as_double();
+    let t2 = eval(&mut vm, "Date.now()").unwrap().as_double();
+    assert!(t2 >= t1);
+}
+
+#[test]
+fn date_parse_returns_nan() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "Date.parse('invalid-date')").unwrap();
+    assert!(result.is_double());
+    assert!(result.as_double().is_nan());
+}
+
+#[test]
+fn date_parse_iso_format() {
+    let mut vm = Vm::new();
+    let result = eval(&mut vm, "Date.parse('2020-01-15')").unwrap();
+    assert!(result.is_double());
+    assert!(!result.as_double().is_nan());
+    assert!(result.as_double() > 0.0);
+}

crates/oxide_vm/tests/builtins_map_tests.rs

@@ -0,0 +1,73 @@
+use oxide_types::value::JsValue;
+use oxide_vm::builtins::map::{
+    map_clear, map_constructor as new_map, map_delete, map_get, map_has, map_set, map_size,
+};
+use oxide_vm::vm::Vm;
+
+#[test]
+fn tmap_constructor_returns_object() {
+    let mut vm = Vm::new();
+    let r = new_map(&mut vm, &[0]).unwrap();
+    assert!(r.is_object());
+}
+
+#[test]
+fn tmap_set_get() {
+    let mut vm = Vm::new();
+    let m = new_map(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, m);
+    vm.set_reg(1, JsValue::float(42.0));
+    vm.set_reg(2, JsValue::float(100.0));
+    map_set(&mut vm, &[0, 1, 2]).unwrap();
+    assert_eq!(map_get(&mut vm, &[0, 1]).unwrap().as_double(), 100.0);
+}
+
+#[test]
+fn tmap_get_missing() {
+    let mut vm = Vm::new();
+    let m = new_map(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, m);
+    vm.set_reg(1, JsValue::float(99.0));
+    assert!(map_get(&mut vm, &[0, 1]).unwrap().is_undefined());
+}
+
+#[test]
+fn tmap_has_check() {
+    let mut vm = Vm::new();
+    let m = new_map(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, m);
+    vm.set_reg(1, JsValue::float(1.0));
+    vm.set_reg(2, JsValue::float(2.0));
+    map_set(&mut vm, &[0, 1, 2]).unwrap();
+    assert!(map_has(&mut vm, &[0, 1]).unwrap().as_bool());
+    assert!(!map_has(&mut vm, &[0, 99]).unwrap().as_bool());
+}
+
+#[test]
+fn tmap_delete_works() {
+    let mut vm = Vm::new();
+    let m = new_map(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, m);
+    vm.set_reg(1, JsValue::float(7.0));
+    vm.set_reg(2, JsValue::float(8.0));
+    map_set(&mut vm, &[0, 1, 2]).unwrap();
+    assert!(map_delete(&mut vm, &[0, 1]).unwrap().as_bool());
+    assert!(!map_has(&mut vm, &[0, 1]).unwrap().as_bool());
+}
+
+#[test]
+fn tmap_size_and_clear() {
+    let mut vm = Vm::new();
+    let m = new_map(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, m);
+    assert_eq!(map_size(&mut vm, &[0]).unwrap().as_double(), 0.0);
+    vm.set_reg(1, JsValue::float(1.0));
+    vm.set_reg(2, JsValue::float(10.0));
+    map_set(&mut vm, &[0, 1, 2]).unwrap();
+    vm.set_reg(1, JsValue::float(2.0));
+    vm.set_reg(2, JsValue::float(20.0));
+    map_set(&mut vm, &[0, 1, 2]).unwrap();
+    assert_eq!(map_size(&mut vm, &[0]).unwrap().as_double(), 2.0);
+    map_clear(&mut vm, &[0]).unwrap();
+    assert_eq!(map_size(&mut vm, &[0]).unwrap().as_double(), 0.0);
+}

crates/oxide_vm/tests/builtins_set_tests.rs

@@ -0,0 +1,90 @@
+use oxide_types::value::JsValue;
+use oxide_vm::builtins::set::{
+    set_add, set_clear, set_constructor as new_set, set_delete, set_has, set_size,
+};
+use oxide_vm::vm::Vm;
+
+#[test]
+fn tset_constructor_returns_object() {
+    let mut vm = Vm::new();
+    let r = new_set(&mut vm, &[0]).unwrap();
+    assert!(r.is_object());
+}
+
+#[test]
+fn tset_add_has() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(42.0));
+    let _ = set_add(&mut vm, &[0, 1]).unwrap();
+    assert!(set_has(&mut vm, &[0, 1]).unwrap().as_bool());
+}
+
+#[test]
+fn tset_has_missing() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(99.0));
+    assert!(!set_has(&mut vm, &[0, 1]).unwrap().as_bool());
+}
+
+#[test]
+fn tset_delete_works() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(7.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    assert!(set_delete(&mut vm, &[0, 1]).unwrap().as_bool());
+    assert!(!set_has(&mut vm, &[0, 1]).unwrap().as_bool());
+}
+
+#[test]
+fn tset_size_increases() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 0.0);
+    vm.set_reg(1, JsValue::float(1.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    vm.set_reg(1, JsValue::float(2.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 2.0);
+}
+
+#[test]
+fn tset_clear_works() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(1.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    set_clear(&mut vm, &[0]).unwrap();
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 0.0);
+}
+
+#[test]
+fn tset_nan_equality() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(f64::NAN));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 1.0);
+    set_add(&mut vm, &[0, 1]).unwrap();
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 1.0);
+}
+
+#[test]
+fn tset_signed_zero() {
+    let mut vm = Vm::new();
+    let s = new_set(&mut vm, &[0]).unwrap();
+    vm.set_reg(0, s);
+    vm.set_reg(1, JsValue::float(0.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    vm.set_reg(1, JsValue::float(-0.0));
+    set_add(&mut vm, &[0, 1]).unwrap();
+    assert_eq!(set_size(&mut vm, &[0]).unwrap().as_double(), 1.0);
+}