mirror of
https://github.com/pjh456/OxideJS.git
synced 2026-10-23 18:21:13 +08:00
874 lines
30 KiB
Rust
874 lines
30 KiB
Rust
use std::sync::Arc;
|
||
|
||
use oxide_compiler::compiler::Compiler;
|
||
use oxide_compiler::DefaultCompilerService;
|
||
use oxide_runtime_api::VmHost;
|
||
use oxide_types::value::JsValue;
|
||
use oxide_vm::vm::Vm;
|
||
|
||
fn eval(source: &str) -> Result<(Vm, 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))?;
|
||
let mut vm = Vm::new();
|
||
vm.set_compiler_service(Arc::new(DefaultCompilerService));
|
||
let result = vm.run(&Arc::new(module))?;
|
||
Ok((vm, result))
|
||
}
|
||
|
||
fn stringify_val(val: &JsValue) -> String {
|
||
if val.is_string() {
|
||
unsafe { (*val.as_string_ptr()).to_owned_string() }
|
||
} else {
|
||
format!("{:?}", val)
|
||
}
|
||
}
|
||
|
||
// --- replacer array ---
|
||
|
||
#[test]
|
||
fn replacer_array_filters_properties() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({a:1,b:2,c:3}, ['a','c'])"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"a":1,"c":3}"#);
|
||
}
|
||
|
||
#[test]
|
||
fn replacer_array_numeric_keys() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({a:1,b:2}, ['b'])"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"b":2}"#);
|
||
}
|
||
|
||
// --- replacer function ---
|
||
|
||
#[test]
|
||
fn replacer_function_skip_property() {
|
||
let (_vm, result) =
|
||
eval(r#"JSON.stringify({a:1,b:2}, function(k,v){if(k==='a')return undefined;return v})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"b":2}"#);
|
||
}
|
||
|
||
#[test]
|
||
fn replacer_function_array_null() {
|
||
let (_vm, result) =
|
||
eval(r#"JSON.stringify([1,2,3], function(k,v){if(k==='1')return undefined;return v})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), "[1,null,3]");
|
||
}
|
||
|
||
#[test]
|
||
fn replacer_function_transform() {
|
||
let (_vm, result) =
|
||
eval(r#"JSON.stringify({a:1}, function(k,v){if(typeof v==='number')return v*2;return v})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"a":2}"#);
|
||
}
|
||
|
||
// --- 顶层 replacer 序（replacer 先于 undefined/函数/Symbol 早返）---
|
||
|
||
// 顶层 undefined：replacer 先被调用，返回值即序列化结果。
|
||
#[test]
|
||
fn stringify_top_level_undefined_replacer_first() {
|
||
let out = eval_str("JSON.stringify(undefined, (k,v) => 42)").unwrap();
|
||
assert_eq!(out, "42");
|
||
}
|
||
|
||
// 顶层函数/Symbol：replacer 可替换为可序列化值。
|
||
#[test]
|
||
fn stringify_top_level_fn_symbol_replacer() {
|
||
let out = eval_str("JSON.stringify(function(){}, (k,v) => 'x')").unwrap();
|
||
assert_eq!(out, r#""x""#);
|
||
let out = eval_str("JSON.stringify(Symbol(), (k,v) => 'y')").unwrap();
|
||
assert_eq!(out, r#""y""#);
|
||
}
|
||
|
||
// 顶层 undefined 无 replacer / replacer 透传：仍 undefined（守卫）。
|
||
#[test]
|
||
fn stringify_top_level_undefined_still_undefined() {
|
||
let (_vm, result) = eval("JSON.stringify(undefined, (k,v) => v)").unwrap();
|
||
assert!(result.is_undefined());
|
||
let (_vm, result) = eval("JSON.stringify(undefined)").unwrap();
|
||
assert!(result.is_undefined());
|
||
}
|
||
|
||
// --- space ---
|
||
|
||
#[test]
|
||
fn space_number_indent() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({a:1}, null, 2)"#).unwrap();
|
||
let s = stringify_val(&result);
|
||
assert!(s.len() > 5, "expected indented output, got: {}", s);
|
||
assert!(s.starts_with('{'), "should start with brace");
|
||
}
|
||
|
||
#[test]
|
||
fn space_negative_clamped() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({a:1}, null, -5)"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"a":1}"#);
|
||
}
|
||
|
||
// space = +∞ → 10 空格 gap（ToIntegerOrInfinity 后 min(10, x)）。
|
||
#[test]
|
||
fn stringify_space_infinity_ten_spaces() {
|
||
let out = eval_str("JSON.stringify({a:1}, null, Infinity)").unwrap();
|
||
assert_eq!(out, "{\n \"a\": 1\n}");
|
||
}
|
||
|
||
// space = −∞/NaN → 空 gap。
|
||
#[test]
|
||
fn stringify_space_neg_inf_nan_empty() {
|
||
let out = eval_str("JSON.stringify({a:1}, null, -Infinity)").unwrap();
|
||
assert_eq!(out, r#"{"a":1}"#);
|
||
let out = eval_str("JSON.stringify({a:1}, null, NaN)").unwrap();
|
||
assert_eq!(out, r#"{"a":1}"#);
|
||
}
|
||
|
||
// space 小数截断（2.5 → 2 空格）、12 钳 10。
|
||
#[test]
|
||
fn stringify_space_fractional_and_clamp() {
|
||
let out = eval_str("JSON.stringify({a:1}, null, 2.5)").unwrap();
|
||
assert_eq!(out, "{\n \"a\": 1\n}");
|
||
let out = eval_str("JSON.stringify({a:1}, null, 12)").unwrap();
|
||
assert_eq!(out, "{\n \"a\": 1\n}");
|
||
}
|
||
|
||
// 装箱 Number space：ToNumber 后与素形同语义（+∞ → 10、−∞ → 空）。
|
||
#[test]
|
||
fn stringify_space_boxed_number() {
|
||
let out = eval_str("JSON.stringify({a:1}, null, new Number(Infinity))").unwrap();
|
||
assert_eq!(out, "{\n \"a\": 1\n}");
|
||
let out = eval_str("JSON.stringify({a:1}, null, new Number(-Infinity))").unwrap();
|
||
assert_eq!(out, r#"{"a":1}"#);
|
||
}
|
||
|
||
// space 字符串 astral：按前 10 码元截断（12 码元 → 5 对，非标量值 6 口径）。
|
||
#[test]
|
||
fn stringify_space_astral_truncated_units() {
|
||
let out = eval_str("JSON.stringify([1], null, '😀😀😀😀😀😀')").unwrap();
|
||
assert_eq!(out, "[\n😀😀😀😀😀1\n]");
|
||
}
|
||
|
||
// 装箱 String space：同款码元口径。
|
||
#[test]
|
||
fn stringify_space_astral_boxed_string() {
|
||
let out = eval_str("JSON.stringify([1], null, new String('😀😀😀😀😀😀'))").unwrap();
|
||
assert_eq!(out, "[\n😀😀😀😀😀1\n]");
|
||
}
|
||
|
||
// 截断落在代理对边界：gap 保留原始孤立 surrogate（node 口径，非 \u 转义）。
|
||
#[test]
|
||
fn stringify_space_astral_lone_surrogate() {
|
||
let (vm, result) =
|
||
eval("JSON.stringify([1], null, '\\uD83D\\uD83D\\uD83D\\uD83D\\uD83D\\uD83D\\uD83D\\uD83D')").unwrap();
|
||
let units = vm.string_units(result);
|
||
let expected: Vec<u16> = vec![
|
||
0x5B, 0x0A, 0xD83D, 0xD83D, 0xD83D, 0xD83D, 0xD83D, 0xD83D, 0xD83D, 0xD83D, 0x31, 0x0A, 0x5D,
|
||
];
|
||
assert_eq!(units.as_ref(), expected.as_slice());
|
||
}
|
||
|
||
// --- toJSON ---
|
||
|
||
#[test]
|
||
fn tojson_called_before_serialize() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({toJSON:function(){return {x:1}}})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"x":1}"#);
|
||
}
|
||
|
||
#[test]
|
||
fn tojson_non_callable_ignored() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({toJSON:'not-a-function', a:1})"#).unwrap();
|
||
// toJSON 属性是字符串，应按普通属性序列化。
|
||
assert!(stringify_val(&result).contains("toJSON"));
|
||
assert!(stringify_val(&result).contains(r#""a":1"#));
|
||
}
|
||
|
||
// --- cycle detection ---
|
||
|
||
#[test]
|
||
fn cycle_throws_type_error() {
|
||
let result = eval("var a={};a.self=a;JSON.stringify(a)");
|
||
match result {
|
||
Err(e) => assert!(e.to_lowercase().contains("circular"), "error should mention 'circular', got: {}", e),
|
||
Ok(_) => panic!("expected cycle error, got ok"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn no_cycle_distinct_objects_ok() {
|
||
let (_vm, result) = eval(r#"JSON.stringify([{a:1},{a:1}])"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"[{"a":1},{"a":1}]"#);
|
||
}
|
||
|
||
// --- reviver ---
|
||
|
||
#[test]
|
||
fn reviver_transform_values() {
|
||
let (_vm, result) =
|
||
eval(r#"JSON.parse('{"a":1,"b":2}', function(k,v){if(typeof v==='number')return v*2;return v})"#).unwrap();
|
||
assert!(result.is_object());
|
||
}
|
||
|
||
#[test]
|
||
fn reviver_delete_property() {
|
||
let (_vm, result) =
|
||
eval(r#"JSON.parse('{"a":1,"b":2}', function(k,v){if(k==='a')return undefined;return v})"#).unwrap();
|
||
// 属性被软删除（置为 undefined）。
|
||
// 为 test262 兼容，stringify 应省略 undefined 属性。
|
||
assert!(result.is_object());
|
||
}
|
||
|
||
#[test]
|
||
fn reviver_root_key_empty_string() {
|
||
let (_vm, result) = eval(r#"JSON.parse('42', function(k,v){return v+1})"#).unwrap();
|
||
assert!(result.is_int() || result.is_double(), "expected number");
|
||
if result.is_int() {
|
||
assert_eq!(result.as_int(), 43);
|
||
} else {
|
||
assert_eq!(result.as_double() as i32, 43);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn reviver_no_reviver_works() {
|
||
let (_vm, result) = eval(r#"JSON.parse('{"a":1}')"#).unwrap();
|
||
assert!(result.is_object());
|
||
}
|
||
|
||
// --- accessor 自身属性值读（SerializeJSONProperty 步 2 Get）---
|
||
|
||
// reverse arraylike + length accessor：getter 被触发，length 键保留在输出。
|
||
#[test]
|
||
fn stringify_reverse_arraylike_length_accessor() {
|
||
let (_vm, result) = eval(
|
||
"(() => { const o = {0:'x',1:'y',length:2}; \
|
||
Object.defineProperty(o,'length',{get(){return 2;},set(v){},enumerable:true,configurable:true}); \
|
||
Array.prototype.reverse.call(o); return JSON.stringify(o); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"0":"y","1":"x","length":2}"#);
|
||
}
|
||
|
||
// 对象属性访问器：字面量 getter 与 defineProperty 重定义 accessor 两形态。
|
||
#[test]
|
||
fn stringify_object_accessor_getter() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({get x(){return 5;}, y:1})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"x":5,"y":1}"#);
|
||
let (_vm, result) = eval(
|
||
"(() => { const o = {x:1}; \
|
||
Object.defineProperty(o,'x',{get(){return 2;}}); return JSON.stringify(o); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"x":2}"#);
|
||
}
|
||
|
||
// getter 的 this 绑定为属性所在对象。
|
||
#[test]
|
||
fn stringify_accessor_this_binding() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({v:1, get p(){return this.v+10;}})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"v":1,"p":11}"#);
|
||
}
|
||
|
||
// 数组 replacer 白名单判定先于 Get：非白名单键的 getter 不触发。
|
||
#[test]
|
||
fn stringify_whitelist_before_accessor_get() {
|
||
let out = eval_str(
|
||
"(() => { let fired = false; const o = {a:1, get b(){fired=true;return 2;}}; \
|
||
return JSON.stringify(o,['a']) + '|' + fired; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"a":1}|false"#);
|
||
}
|
||
|
||
// 数组元素访问器：元素位触发 getter，值为 getter 返回值。
|
||
#[test]
|
||
fn stringify_array_element_accessor() {
|
||
let out = eval_str(
|
||
"(() => { const a = [1,2]; \
|
||
Object.defineProperty(a,0,{get(){return 9;},configurable:true}); \
|
||
Object.defineProperty(a,1,{get(){return 2;},configurable:true}); \
|
||
return JSON.stringify(a); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "[9,2]");
|
||
}
|
||
|
||
// getter 返回值形态：function/undefined 省略，带 toJSON 的对象走钩子，setter-only 省略。
|
||
#[test]
|
||
fn stringify_accessor_return_shapes() {
|
||
let out = eval_str(
|
||
"(() => { const o = {}; \
|
||
Object.defineProperty(o,'f',{get(){ return function g(){return 7;}; },enumerable:true,configurable:true}); \
|
||
Object.defineProperty(o,'u',{get(){ return undefined; },enumerable:true,configurable:true}); \
|
||
Object.defineProperty(o,'t',{get(){ return {toJSON(){return 7;}}; },enumerable:true,configurable:true}); \
|
||
Object.defineProperty(o,'s',{set(v){},enumerable:true,configurable:true}); \
|
||
return JSON.stringify(o); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"t":7}"#);
|
||
}
|
||
|
||
// space 缩进 + 访问器：getter 值正常入输出（判别 p 键存在；对象开括号换行
|
||
// 位置是 space 格式面 pre-existing 偏差，不属本钉面）。
|
||
#[test]
|
||
fn stringify_space_with_accessor() {
|
||
let (_vm, result) = eval(
|
||
"(() => { const o = {}; \
|
||
Object.defineProperty(o,'p',{get(){return [1];},enumerable:true,configurable:true}); \
|
||
return JSON.stringify({o},null,2); })()",
|
||
)
|
||
.unwrap();
|
||
let s = stringify_val(&result);
|
||
assert!(s.contains(r#""p": ["#), "getter value missing from indented output: {}", s);
|
||
assert!(s.contains("1"), "getter value absent: {}", s);
|
||
}
|
||
|
||
// getter 抛非 Error 原始值：原值传播（捕获侧见 number 42，非 TypeError 对象）。
|
||
#[test]
|
||
fn stringify_accessor_throws_original_value() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.stringify({get x(){throw 42;}, y:1}); } \
|
||
catch (e) { return typeof e + '|' + e; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "number|42");
|
||
}
|
||
|
||
// toJSON 抛非 Error 原始值：原值传播。
|
||
#[test]
|
||
fn stringify_tojson_throws_original_value() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.stringify({toJSON(){throw 42;}}); } \
|
||
catch (e) { return typeof e + '|' + e; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "number|42");
|
||
}
|
||
|
||
// replacer 抛非 Error 原始值：原值传播。
|
||
#[test]
|
||
fn stringify_replacer_throws_original_value() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.stringify({a:1}, function(k,v){ if(k==='a') throw 'boom'; return v; }); } \
|
||
catch (e) { return typeof e + '|' + e; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "string|boom");
|
||
}
|
||
|
||
// 嵌套序：toJSON 先于 replacer 应用，replacer 见到 toJSON 结果。
|
||
#[test]
|
||
fn stringify_nested_tojson_before_replacer() {
|
||
let out = eval_str(
|
||
"(() => { let seen; const inner = {toJSON(){return 'T';}}; \
|
||
const s = JSON.stringify({a:inner}, function(k,v){ if(k==='a') seen = String(v); return v; }); \
|
||
return seen + '|' + s; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"T|{"a":"T"}"#);
|
||
}
|
||
|
||
// 顶层 toJSON 结果自身带 toJSON：只应用一次。
|
||
#[test]
|
||
fn stringify_top_level_tojson_once() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({toJSON(){return {toJSON(){return 'inner';}};}})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{}"#);
|
||
}
|
||
|
||
// 访问器返回自身成环：getter 触发后环检抛 TypeError。
|
||
#[test]
|
||
fn stringify_accessor_self_cycle() {
|
||
let result = eval(
|
||
"(() => { const o = {n:1}; \
|
||
Object.defineProperty(o,'self',{get(){return o;},enumerable:true,configurable:true}); \
|
||
return JSON.stringify(o); })()",
|
||
);
|
||
match result {
|
||
Err(e) => assert!(e.to_lowercase().contains("circular"), "expected circular error, got: {}", e),
|
||
Ok(_) => panic!("expected cycle error"),
|
||
}
|
||
}
|
||
|
||
// 不可枚举访问器：省略（守卫，防修后翻红）。
|
||
#[test]
|
||
fn stringify_non_enumerable_accessor_skipped() {
|
||
let out = eval_str(
|
||
"(() => { const o = {v:2}; \
|
||
Object.defineProperty(o,'h',{get(){return 99;},enumerable:false,configurable:true}); \
|
||
return JSON.stringify(o); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"v":2}"#);
|
||
}
|
||
|
||
// 嵌套 toJSON 结果为对象：单应用下正常展开（守卫）。
|
||
#[test]
|
||
fn stringify_nested_tojson_result_object() {
|
||
let (_vm, result) = eval(r#"JSON.stringify({a:{toJSON(){return {};}}})"#).unwrap();
|
||
assert_eq!(stringify_val(&result), r#"{"a":{}}"#);
|
||
}
|
||
|
||
// 数组附加命名属性：序列化省略（守卫）。
|
||
#[test]
|
||
fn stringify_array_ignores_named_props() {
|
||
let out = eval_str("(() => { const a = [1,2]; a.x = 'hello'; return JSON.stringify(a); })()").unwrap();
|
||
assert_eq!(out, "[1,2]");
|
||
}
|
||
|
||
// --- BigInt 值位（SerializeJSONProperty 步 10 抛 TypeError；步 2 查 toJSON）---
|
||
|
||
fn assert_bigint_serialize_err(source: &str) {
|
||
let result = eval(source);
|
||
match result {
|
||
Err(e) => {
|
||
assert!(
|
||
e.to_lowercase().contains("do not know how to serialize a bigint"),
|
||
"expected BigInt serialize TypeError, got: {}",
|
||
e
|
||
)
|
||
}
|
||
Ok(_) => panic!("expected BigInt serialize TypeError, got ok: {}", source),
|
||
}
|
||
}
|
||
|
||
// 顶层原语四值位：1n / -1n / 0n / -0n 恒抛，无文本产出。
|
||
#[test]
|
||
fn stringify_bigint_top_level_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify(1n)");
|
||
assert_bigint_serialize_err("JSON.stringify(-1n)");
|
||
assert_bigint_serialize_err("JSON.stringify(0n)");
|
||
assert_bigint_serialize_err("JSON.stringify(-0n)");
|
||
}
|
||
|
||
// 大位宽 BigInt 同样抛错（不产十进制文本）。
|
||
#[test]
|
||
fn stringify_bigint_wide_bits_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify(2n ** 32n + 1n)");
|
||
}
|
||
|
||
// 嵌套对象属性与数组元素位（含深嵌套、稀疏）均经值位臂抛错。
|
||
#[test]
|
||
fn stringify_bigint_nested_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify({a:1n})");
|
||
assert_bigint_serialize_err("JSON.stringify([1n,2n,[3n]])");
|
||
assert_bigint_serialize_err("JSON.stringify({a:{b:1n}})");
|
||
assert_bigint_serialize_err("JSON.stringify([,1n])");
|
||
}
|
||
|
||
// 空格缩进不改变抛错路径。
|
||
#[test]
|
||
fn stringify_bigint_space_indent_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify({a:1n}, null, 2)");
|
||
}
|
||
|
||
// replacer 白名单命中键后仍走值位抛错。
|
||
#[test]
|
||
fn stringify_bigint_whitelist_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify({a:1n}, ['a'])");
|
||
}
|
||
|
||
// 装箱 BigInt（步 4d 无条件解包 [[BigIntData]]）与裸值同抛。
|
||
#[test]
|
||
fn stringify_bigint_boxed_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify(Object(0n))");
|
||
assert_bigint_serialize_err("JSON.stringify({a:Object(1n)})");
|
||
}
|
||
|
||
// BigInt64Array 元素位经对象臂读值后在值位臂抛错。
|
||
#[test]
|
||
fn stringify_bigint64array_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify(new BigInt64Array([1n,2n]))");
|
||
}
|
||
|
||
// replacer 透传不改变值位；replacer 结果再入值位臂同样抛错。
|
||
#[test]
|
||
fn stringify_bigint_replacer_throws() {
|
||
assert_bigint_serialize_err("JSON.stringify(1n, (k,v) => v)");
|
||
assert_bigint_serialize_err("JSON.stringify({a:1n}, (k,v) => v)");
|
||
assert_bigint_serialize_err("JSON.stringify({a:1}, (k,v) => 2n)");
|
||
}
|
||
|
||
// BigInt.prototype 挂数据属性 toJSON：钩子被触发，返回串值正常序列化。
|
||
#[test]
|
||
fn stringify_bigint_tojson_hook_top_level() {
|
||
let out = eval_str(
|
||
"(() => { BigInt.prototype.toJSON = function(){ return this.toString(); }; \
|
||
const s = JSON.stringify(0n); \
|
||
delete BigInt.prototype.toJSON; \
|
||
return s; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#""0""#);
|
||
}
|
||
|
||
// toJSON 钩子嵌套对象属性位：receiver 为 BigInt 原语，this.toString() 生效。
|
||
#[test]
|
||
fn stringify_bigint_tojson_hook_nested() {
|
||
let out = eval_str(
|
||
"(() => { BigInt.prototype.toJSON = function(){ return this.toString(); }; \
|
||
const s = JSON.stringify({a:1n}); \
|
||
delete BigInt.prototype.toJSON; \
|
||
return s; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"a":"1"}"#);
|
||
}
|
||
|
||
// 守卫：replacer 先于值位转换 BigInt → number，不抛错。
|
||
#[test]
|
||
fn stringify_bigint_replacer_transform_guard() {
|
||
let out = eval_str("JSON.stringify({b:1n}, function(k,v){ if(typeof v==='bigint') return Number(v); return v; })")
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"b":1}"#);
|
||
}
|
||
|
||
// --- reviver 抛错原值传播（InternalizeJSONProperty 步 3）---
|
||
|
||
// reviver 抛非 Error 原语：原值传播（捕获侧见 number 42，非 TypeError 对象）。
|
||
#[test]
|
||
fn parse_reviver_throws_original_value() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('0', function(){ throw 42; }); } \
|
||
catch (e) { return typeof e + '|' + e; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "number|42");
|
||
}
|
||
|
||
// reviver 抛字符串：原始串传播。
|
||
#[test]
|
||
fn parse_reviver_throws_string() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('0', function(){ throw 'boom'; }); } \
|
||
catch (e) { return typeof e + '|' + e; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "string|boom");
|
||
}
|
||
|
||
// reviver 抛 Error 对象：原错误对象传播（种类与消息保真）。
|
||
#[test]
|
||
fn parse_reviver_throws_range_error() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('0', function(){ throw new RangeError('re'); }); } \
|
||
catch (e) { return e.constructor.name + '|' + e.message; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "RangeError|re");
|
||
}
|
||
|
||
// --- reviver 读写臂（Get 读臂 / [[Delete]] + CreateDataProperty 写臂 / 根级无写回）---
|
||
|
||
// 读臂 Get：reviver 删自身 b 后读值走原型链，CreateDataProperty 重建自身 b（对象臂）。
|
||
#[test]
|
||
fn parse_reviver_object_get_prop_from_prototype() {
|
||
let out = eval_str(
|
||
"(() => { Object.prototype.b = 3; \
|
||
const obj = JSON.parse('{\"a\": 1, \"b\": 2}', function(key, value) { \
|
||
if (key === 'a') { delete this.b; } return value; }); \
|
||
delete Object.prototype.b; \
|
||
return [obj.a, obj.hasOwnProperty('b'), obj.b].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|true|3");
|
||
}
|
||
|
||
// 读臂 Get：数组臂同款（删自身 [1] 后原型读 3 重建）。
|
||
#[test]
|
||
fn parse_reviver_array_get_prop_from_prototype() {
|
||
let out = eval_str(
|
||
"(() => { Array.prototype[1] = 3; \
|
||
const arr = JSON.parse('[1, 2]', function(key, value) { \
|
||
if (key === '0') { delete this[1]; } return value; }); \
|
||
delete Array.prototype[1]; \
|
||
return [arr[0], arr.hasOwnProperty('1'), arr[1]].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|true|3");
|
||
}
|
||
|
||
// 读臂 Get：自身访问器 getter 抛错穿透，原值传播（非 TypeError 折叠）。
|
||
#[test]
|
||
fn parse_reviver_get_name_err_original_value() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('[0,0]', function() { \
|
||
Object.defineProperty(this, '1', { get() { throw 42; } }); }); } \
|
||
catch (e) { return typeof e + '|' + e; } return 'nothrow'; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "number|42");
|
||
}
|
||
|
||
// 写臂 CreateDataProperty：非可配置属性写败静默，保旧值（对象臂）。
|
||
#[test]
|
||
fn parse_reviver_object_non_configurable_prop_create() {
|
||
let out = eval_str(
|
||
"(() => { const obj = JSON.parse('{\"a\": 1, \"b\": 2}', function(key, value) { \
|
||
if (key === 'a') { Object.defineProperty(this, 'b', {configurable: false}); } \
|
||
if (key === 'b') return 22; return value; }); \
|
||
return [obj.a, obj.b].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|2");
|
||
}
|
||
|
||
// 写臂 [[Delete]]：非可配置属性删败静默，属性保留（对象臂）。
|
||
#[test]
|
||
fn parse_reviver_object_non_configurable_prop_delete() {
|
||
let out = eval_str(
|
||
"(() => { const obj = JSON.parse('{\"a\": 1, \"b\": 2}', function(key, value) { \
|
||
if (key === 'a') { Object.defineProperty(this, 'b', {configurable: false}); } \
|
||
if (key === 'b') return; return value; }); \
|
||
return [obj.a, obj.hasOwnProperty('b'), obj.b].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|true|2");
|
||
}
|
||
|
||
// 写臂同款两臂（数组臂）。
|
||
#[test]
|
||
fn parse_reviver_array_non_configurable_prop_create() {
|
||
let out = eval_str(
|
||
"(() => { const arr = JSON.parse('[1, 2]', function(key, value) { \
|
||
if (key === '0') { Object.defineProperty(this, '1', {configurable: false}); } \
|
||
if (key === '1') return 22; return value; }); \
|
||
return [arr[0], arr[1]].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|2");
|
||
}
|
||
|
||
#[test]
|
||
fn parse_reviver_array_non_configurable_prop_delete() {
|
||
let out = eval_str(
|
||
"(() => { const arr = JSON.parse('[1, 2]', function(key, value) { \
|
||
if (key === '0') { Object.defineProperty(this, '1', {configurable: false}); } \
|
||
if (key === '1') return; return value; }); \
|
||
return [arr[0], arr.hasOwnProperty('1'), arr[1]].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1|true|2");
|
||
}
|
||
|
||
// 根级无写回：wrapper `''` 槽值/描述符恒保留（reviver 返 undefined 不抹槽）。
|
||
#[test]
|
||
fn parse_reviver_wrapper_slot_preserved() {
|
||
let out = eval_str(
|
||
"(() => { let w; JSON.parse('2', function() { w = this; }); \
|
||
const d = Object.getOwnPropertyDescriptor(w, ''); \
|
||
return [w[''], Object.getOwnPropertyNames(w).length, d.writable, d.enumerable, d.configurable].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "2|1|true|true|true");
|
||
}
|
||
|
||
// 根返回值 = 根级 reviver 返回值原样。
|
||
#[test]
|
||
fn parse_reviver_root_return_value() {
|
||
let (_vm, result) = eval(r#"JSON.parse('5', function(k,v){return v*2})"#).unwrap();
|
||
assert!(result.is_int() || result.is_double(), "expected number");
|
||
if result.is_int() {
|
||
assert_eq!(result.as_int(), 10);
|
||
} else {
|
||
assert_eq!(result.as_double() as i32, 10);
|
||
}
|
||
}
|
||
|
||
// this 面守卫：根级 this = wrapper（`''` 槽即结果对象）、子级 this = 容器，
|
||
// 前向改写 `this[1] = 99` 在子读点生效。
|
||
#[test]
|
||
fn parse_reviver_this_binding_guard() {
|
||
let out = eval_str(
|
||
"(() => { let rootThis, childThis; \
|
||
const arr = JSON.parse('[1, 2]', function(key, value) { \
|
||
if (key === '') rootThis = this; \
|
||
if (key === '0') childThis = this; \
|
||
if (key === '0') this[1] = 99; return value; }); \
|
||
return [rootThis[''] === arr, childThis === arr, rootThis === childThis, arr[1]].join('|'); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true|true|false|99");
|
||
}
|
||
|
||
// --- PropertyList 列表序（SerializeJSONObject 步 5 K = P）---
|
||
|
||
// 顶层对象：输出序 = 白名单列表序（非自身枚举序）。
|
||
#[test]
|
||
fn replacer_array_list_order() {
|
||
let out = eval_str(r#"JSON.stringify({b:1,a:2,c:3}, ['c','b','a'])"#).unwrap();
|
||
assert_eq!(out, r#"{"c":3,"b":1,"a":2}"#);
|
||
}
|
||
|
||
// 嵌套层级每级同用列表序。
|
||
#[test]
|
||
fn replacer_array_nested_list_order() {
|
||
let out = eval_str(r#"JSON.stringify({a:{b:2,c:3}}, ['c','b','a'])"#).unwrap();
|
||
assert_eq!(out, r#"{"a":{"c":3,"b":2}}"#);
|
||
}
|
||
|
||
// TypedArray：列表序定输出序，整数索引名读元素。
|
||
#[test]
|
||
fn replacer_array_typed_array_list_order() {
|
||
let out = eval_str(r#"JSON.stringify(new Float64Array([1,2,3]), ['2','0','1'])"#).unwrap();
|
||
assert_eq!(out, r#"{"2":3,"0":1,"1":2}"#);
|
||
}
|
||
|
||
// --- 白名单元素强转（Stringify 步 4：装箱 String/Number 走 ToPrimitive）---
|
||
|
||
// 装箱 Number 自定义 toString：string hint 调用结果作键。
|
||
#[test]
|
||
fn replacer_boxed_number_tostring() {
|
||
let out = eval_str(
|
||
"(() => { const n = new Number(10); \
|
||
n.toString = function(){ return 'toString'; }; \
|
||
return JSON.stringify({10:1,toString:2}, [n]); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"toString":2}"#);
|
||
}
|
||
|
||
// 素形装箱 Number：盒值 → "10"。
|
||
#[test]
|
||
fn replacer_boxed_number_plain() {
|
||
let out = eval_str(r#"JSON.stringify({10:1}, [new Number(10)])"#).unwrap();
|
||
assert_eq!(out, r#"{"10":1}"#);
|
||
}
|
||
|
||
// 素形装箱 String：盒值 → "str"。
|
||
#[test]
|
||
fn replacer_boxed_string_plain() {
|
||
let out = eval_str(r#"JSON.stringify({str:4}, [new String('str')])"#).unwrap();
|
||
assert_eq!(out, r#"{"str":4}"#);
|
||
}
|
||
|
||
// --- 白名单键 Get 语义（原型链 + 不可枚举自身 + 访问器）---
|
||
|
||
// 原型链 getter 键在白名单给定时命中（getter 触发）。
|
||
#[test]
|
||
fn replacer_whitelist_proto_getter() {
|
||
let out = eval_str(
|
||
"(() => { const base = {get b(){ return 9; }}; \
|
||
const o = Object.create(base); o.a = 1; \
|
||
return JSON.stringify(o, ['a','b']); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"a":1,"b":9}"#);
|
||
}
|
||
|
||
// 不可枚举自身键在白名单给定时同样序列化。
|
||
#[test]
|
||
fn replacer_whitelist_non_enumerable_own() {
|
||
let out = eval_str(
|
||
"(() => { const o = {a:1}; \
|
||
Object.defineProperty(o,'b',{value:2,enumerable:false,configurable:true}); \
|
||
return JSON.stringify(o, ['a','b']); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"a":1,"b":2}"#);
|
||
}
|
||
|
||
// 嵌套层级原型链 getter 同样命中。
|
||
#[test]
|
||
fn replacer_whitelist_nested_proto_getter() {
|
||
let out = eval_str(
|
||
"(() => { const base = {get x(){ return 7; }}; \
|
||
const o = Object.create(base); o.y = 1; \
|
||
return JSON.stringify({o}, ['o','x','y']); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#"{"o":{"x":7,"y":1}}"#);
|
||
}
|
||
|
||
// --- toJSON 查表 Get 语义（accessor 形 toJSON 触发）---
|
||
|
||
// BigInt.prototype toJSON accessor 形：getter 触发，receiver = BigInt 原语。
|
||
#[test]
|
||
fn stringify_bigint_tojson_accessor() {
|
||
let out = eval_str(
|
||
"(() => { \"use strict\"; \
|
||
Object.defineProperty(BigInt.prototype, 'toJSON', \
|
||
{get(){ return () => typeof this; }, configurable:true}); \
|
||
const s = JSON.stringify(1n); \
|
||
delete BigInt.prototype.toJSON; \
|
||
return s; })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, r#""bigint""#);
|
||
}
|
||
|
||
// --- 守卫（修后零漂移）---
|
||
|
||
// 白名单缺失名：空对象输出。
|
||
#[test]
|
||
fn replacer_whitelist_missing_name() {
|
||
let out = eval_str(r#"JSON.stringify({b:1}, ['zzz'])"#).unwrap();
|
||
assert_eq!(out, "{}");
|
||
}
|
||
|
||
// TA 白名单非索引名（length）经 Get 读命名键。
|
||
#[test]
|
||
fn replacer_whitelist_typed_array_length() {
|
||
let out = eval_str(r#"JSON.stringify(new Float64Array(2), ['length'])"#).unwrap();
|
||
assert_eq!(out, r#"{"length":2}"#);
|
||
}
|
||
|
||
// 数组容器不查白名单。
|
||
#[test]
|
||
fn replacer_whitelist_array_container_ignores() {
|
||
let out = eval_str(r#"JSON.stringify([1,2], ['1'])"#).unwrap();
|
||
assert_eq!(out, "[1,2]");
|
||
}
|
||
|
||
// 装箱 Boolean / 普通对象元素跳过（不产键）。
|
||
#[test]
|
||
fn replacer_whitelist_skip_object_elements() {
|
||
let out = eval_str(r#"JSON.stringify({b:5}, [new Boolean(true), {custom:1}])"#).unwrap();
|
||
assert_eq!(out, "{}");
|
||
}
|
||
|
||
// 白名单命中键值为 undefined：跳键。
|
||
#[test]
|
||
fn replacer_whitelist_undefined_value_skipped() {
|
||
let out = eval_str(r#"JSON.stringify({a:1,b:undefined}, ['a','b'])"#).unwrap();
|
||
assert_eq!(out, r#"{"a":1}"#);
|
||
}
|
||
|
||
// --- 嵌套深度上限（递归限制）---
|
||
|
||
// 深度 128 层恰好过：128 层嵌套数组正常解析。
|
||
#[test]
|
||
fn parse_depth_128_ok() {
|
||
let out = eval_str(
|
||
"(() => { const v = JSON.parse('['.repeat(128) + ']'.repeat(128)); \
|
||
return String(Array.isArray(v) && v.length === 1); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "true");
|
||
}
|
||
|
||
// 深度 129 层超限：抛 SyntaxError（递归限制），而非进程 abort。
|
||
#[test]
|
||
fn parse_depth_129_throws() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('['.repeat(129) + ']'.repeat(129)); return 'no-throw'; } \
|
||
catch (e) { return e.constructor.name + '|' + e.message; } })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "SyntaxError|recursion limit exceeded");
|
||
}
|
||
|
||
// 深度计数复位：深嵌套解析超限失败后，随后普通嵌套解析不受残留计数影响。
|
||
#[test]
|
||
fn parse_depth_count_resets() {
|
||
let out = eval_str(
|
||
"(() => { try { JSON.parse('['.repeat(129) + ']'.repeat(129)); } catch (e) {} \
|
||
const v = JSON.parse('{\"a\":{\"b\":[1]}}'); \
|
||
return String(v.a.b[0]); })()",
|
||
)
|
||
.unwrap();
|
||
assert_eq!(out, "1");
|
||
}
|
||
|
||
fn eval_str(source: &str) -> Result<String, String> {
|
||
let (vm, result) = eval(source)?;
|
||
vm.lookup_str(result)
|
||
.ok_or_else(|| "completion value is not a string".to_string())
|
||
}
|