288 lines
10 KiB
Rust
288 lines
10 KiB
Rust
//! async/await 运行时测试：异步函数调用返回 promise、await 恢复、reject 进 catch、
|
||
//! 多 await 顺序、嵌套 async、微任务执行序。
|
||
|
||
use oxide_compiler::compiler::Compiler;
|
||
use oxide_parser::Allocator;
|
||
use oxide_vm::promise::promise_settled_value;
|
||
use oxide_vm::vm::Vm;
|
||
|
||
/// 执行源码并格式化顶层结果；Promise 结果取其 drain 后的 settled 值。
|
||
fn eval(source: &str) -> String {
|
||
let allocator = Allocator::default();
|
||
let program = match oxide_parser::parse(&allocator, source) {
|
||
Ok(p) => p,
|
||
Err(e) => return format!("parse error: {}", e[0].message),
|
||
};
|
||
let module = match Compiler::new().compile(&program) {
|
||
Ok(m) => m,
|
||
Err(e) => return format!("compile error: {e}"),
|
||
};
|
||
let mut vm = Vm::new();
|
||
match vm.run(&module) {
|
||
Ok(result) => format_value(&vm, result),
|
||
Err(e) => format!("vm error: {e}"),
|
||
}
|
||
}
|
||
|
||
fn format_value(vm: &Vm, val: oxide_vm::JsValue) -> String {
|
||
if val.is_string() {
|
||
format!("\"{}\"", vm.lookup_str(val).unwrap_or_default())
|
||
} else if val.is_object() {
|
||
let obj = unsafe { &*val.as_js_object_ptr() };
|
||
if obj.is_promise_obj() {
|
||
match promise_settled_value(obj) {
|
||
Some((true, v)) => format_value(vm, v),
|
||
Some((false, v)) => format!("<rejected {}>", format_value(vm, v)),
|
||
None => "<pending>".to_string(),
|
||
}
|
||
} else if obj.is_array() {
|
||
"[array]".to_string()
|
||
} else {
|
||
"[object]".to_string()
|
||
}
|
||
} else {
|
||
format!("{val}")
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn async_returns_immediate_value() {
|
||
assert_eq!(eval("async function f(){ return 42 } f()"), "42");
|
||
}
|
||
|
||
#[test]
|
||
fn async_await_primitive() {
|
||
assert_eq!(eval("async function f(){ var v = await 10; return v*2 } f()"), "20");
|
||
}
|
||
|
||
#[test]
|
||
fn async_await_resolved_promise() {
|
||
assert_eq!(eval("async function f(){ var v = await Promise.resolve(5); return v+1 } f()"), "6");
|
||
}
|
||
|
||
#[test]
|
||
fn async_await_reject_into_catch() {
|
||
assert_eq!(
|
||
eval("async function f(){ try { await Promise.reject('e') } catch(e) { return 'caught:'+e } } f()"),
|
||
"\"caught:e\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn async_multiple_awaits_in_order() {
|
||
assert_eq!(eval("async function f(){ var x = await 1; x += await 2; return x } f()"), "3");
|
||
}
|
||
|
||
#[test]
|
||
fn async_await_return_promise() {
|
||
assert_eq!(eval("async function f(){ return await Promise.resolve(7) } f()"), "7");
|
||
}
|
||
|
||
#[test]
|
||
fn async_nested_calls() {
|
||
assert_eq!(eval("async function g(){ return 2 } async function f(){ return await g() + 3 } f()"), "5");
|
||
}
|
||
|
||
#[test]
|
||
fn async_arrow_in_then() {
|
||
assert_eq!(eval("Promise.resolve().then(async ()=>{ return 9 }).then(v=>v)"), "9");
|
||
}
|
||
|
||
#[test]
|
||
fn async_execution_order_suspends_immediately() {
|
||
// await 挂起 body；当前同步代码先跑完，body 恢复在微任务 drain 阶段。
|
||
assert_eq!(
|
||
eval("var order=[]; async function f(){ order.push(1); await 0; order.push(2) } f(); order.push(0); Promise.resolve().then(function(){ return order.join(',') })"),
|
||
"\"1,0,2\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn async_throw_rejects_promise() {
|
||
assert_eq!(eval("async function f(){ throw 'boom' } f()"), "<rejected \"boom\">");
|
||
}
|
||
|
||
#[test]
|
||
fn async_is_not_constructor() {
|
||
assert!(
|
||
eval("new (async function(){})").starts_with("vm error")
|
||
|| eval("new (async function(){})").contains("not a constructor")
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn async_constructor_name() {
|
||
assert_eq!(eval("async function f(){}; f.constructor.name"), "\"AsyncFunction\"");
|
||
}
|
||
|
||
#[test]
|
||
fn async_class_method() {
|
||
assert_eq!(eval("class A { async m(){ return await 7 } } new A().m()"), "7");
|
||
}
|
||
|
||
#[test]
|
||
fn async_gen_rejected_yield_queued_next_gets_done() {
|
||
// P6：yield 值被拒 → 生成器 completed，unwrap 前排队的 next 得 {done:true}，
|
||
// 不得错误继续执行后续 yield。
|
||
assert_eq!(
|
||
eval(
|
||
"async function* g() { yield Promise.reject('e1'); yield 'never'; } \
|
||
async function run() { const it = g(); const p1 = it.next(); const p2 = it.next(); \
|
||
let r1, r2; try { await p1; r1 = 'p1-ok'; } catch (e) { r1 = 'p1-rej:' + e; } \
|
||
try { const v = await p2; r2 = 'p2:' + v.value + ':' + v.done; } catch (e) { r2 = 'p2-rej:' + e; } \
|
||
return r1 + '|' + r2; } run()"
|
||
),
|
||
"\"p1-rej:e1|p2:undefined:true\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn async_gen_normal_yield_awaits_value() {
|
||
// yield 一个 resolved promise：unwrap 完成后让出展开值；next(arg) 作为 yield 表达式值。
|
||
assert_eq!(
|
||
eval(
|
||
"async function* g() { var v = yield Promise.resolve(9); yield v; } \
|
||
async function run() { const it = g(); const a = (await it.next()).value; \
|
||
const b = (await it.next(100)).value; return a + ',' + b; } run()"
|
||
),
|
||
"\"9,100\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn async_gen_yield_then_next_continues() {
|
||
// 正常 yield 值（非 promise）后 next 继续执行到完成。
|
||
assert_eq!(
|
||
eval(
|
||
"async function* g() { yield 1; yield 2; } \
|
||
async function run() { const it = g(); const a = (await it.next()).value; \
|
||
const b = (await it.next()).value; const c = (await it.next()).done; \
|
||
return a + ',' + b + ',' + c; } run()"
|
||
),
|
||
"\"1,2,true\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn for_await_of_break_closes_iterator() {
|
||
// 数组解构的 DONE 结果不得覆盖外层 for-await-of 迭代器的结果：break 提前
|
||
// 退出时 CLOSE 按自身条目判 done，须调用 return() 关闭迭代器。
|
||
assert_eq!(
|
||
eval(
|
||
"let closed=false;\
|
||
const iter={[Symbol.asyncIterator](){return{next(){return Promise.resolve({value:1,done:false})},return(){closed=true;return Promise.resolve({done:true})}}}};\
|
||
(async()=>{ for await (const [a,b] of iter) { break; } })();\
|
||
Promise.resolve().then(()=>closed)"
|
||
),
|
||
"true"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn for_await_of_natural_done_skips_return() {
|
||
// for-await-of 迭代自然结束（next 返回 done:true）时不调用 return()。
|
||
assert_eq!(
|
||
eval(
|
||
"let closed=false;\
|
||
const iter={[Symbol.asyncIterator](){return{next(){return Promise.resolve({value:1,done:true})},return(){closed=true;return Promise.resolve({done:true})}}}};\
|
||
(async()=>{ for await (const x of iter) { } })();\
|
||
Promise.resolve().then(()=>closed)"
|
||
),
|
||
"false"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn for_await_of_nested_sync_for_of_break_close_respective() {
|
||
// for-await-of 内嵌同步 for-of：内层 break 只关内层同步迭代器，外层异步
|
||
// 迭代器保持打开（条目配对，互不覆盖结果）。
|
||
assert_eq!(
|
||
eval(
|
||
"let log=[];\
|
||
const sync={[Symbol.iterator](){return{next(){return{value:1,done:false}},return(){log.push('s');return{}}}}};\
|
||
const asyncIter={[Symbol.asyncIterator](){return{next(){return Promise.resolve({value:1,done:false})},return(){log.push('a');return Promise.resolve({done:true})}}}};\
|
||
(async()=>{ for await (const x of asyncIter) { for (const y of sync) { break; } break; } })();\
|
||
Promise.resolve().then(()=>log.join(','))"
|
||
),
|
||
"\"s,a\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn for_await_of_body_throw_closes_and_original_error_wins() {
|
||
// for-await-of 循环体抛错：先调 return() 关闭迭代器，原错误优先传播给 catch。
|
||
assert_eq!(
|
||
eval(
|
||
"let log=[];\
|
||
const it={[Symbol.asyncIterator](){return{next(){return Promise.resolve({value:1,done:false})},return(){log.push('r');return Promise.resolve({done:true})}}}};\
|
||
(async()=>{ try { for await (const x of it) { throw 'orig'; } } catch(e) { log.push('c:'+e); } return log.join(','); })()"
|
||
),
|
||
"\"r,c:orig\""
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn for_await_of_return_escape_defers_async_close() {
|
||
// return 逃出 for-await-of：异步迭代器 return() 的 promise 须 await 后结算，
|
||
// 走异步关闭机制（后续阶段）；阶段 1 同步逃出路径不得同步调用异步 return()。
|
||
// 断言循环体已执行且没有同步副作用泄露。
|
||
assert_eq!(
|
||
eval(
|
||
"let log=[];\
|
||
const it={[Symbol.asyncIterator](){return{next(){return Promise.resolve({value:1,done:false})},return(){log.push('close');return Promise.resolve({done:true})}}}};\
|
||
(async()=>{ for await (const x of it) { log.push('body'); return 1; } })();\
|
||
Promise.resolve().then(()=>log.join(','))"
|
||
),
|
||
"\"body\""
|
||
);
|
||
}
|
||
|
||
// ── class/object 生成器方法（异步） ──
|
||
|
||
// class async 生成器方法：yield 顺序与 done 收敛。顶层 then 链驱动
|
||
// （普通回调帧内读取类绑定不触发 upvalue cell 误报）。
|
||
#[test]
|
||
fn class_async_generator_method_yields_in_order() {
|
||
assert_eq!(
|
||
eval(
|
||
"class E { async *ag() { yield 1; yield 2; } }\
|
||
var it = new E().ag(); var a, b, c;\
|
||
var p = it.next().then(function (r) { a = r.value; return it.next(); })\
|
||
.then(function (r) { b = r.value; return it.next(); })\
|
||
.then(function (r) { c = r.done; return a + ',' + b + ',' + c; });\
|
||
p"
|
||
),
|
||
"\"1,2,true\""
|
||
);
|
||
}
|
||
|
||
// class async 生成器方法 throw：异常进挂起点，被 body 内 catch 拦截后继续 yield。
|
||
#[test]
|
||
fn class_async_generator_method_throw_reaches_inner_catch() {
|
||
assert_eq!(
|
||
eval(
|
||
"class F { async *t() { try { yield 1; } catch (e) { yield 'caught:' + e; } } }\
|
||
var it = new F().t();\
|
||
var p = it.next().then(function (r) { return it.throw('boom'); })\
|
||
.then(function (r) { return r.value; });\
|
||
p"
|
||
),
|
||
"\"caught:boom\""
|
||
);
|
||
}
|
||
|
||
// object async 生成器方法：方法形态的 async generator 语义与函数式一致。
|
||
#[test]
|
||
fn object_async_generator_method_yields() {
|
||
assert_eq!(
|
||
eval(
|
||
"var o = { async *gen() { yield 5; } };\
|
||
var it = o.gen(); var a, d;\
|
||
var p = it.next().then(function (r) { a = r.value; return it.next(); })\
|
||
.then(function (r) { d = r.done; return a + ':' + d; });\
|
||
p"
|
||
),
|
||
"\"5:true\""
|
||
);
|
||
}
|