139 lines
4.5 KiB
TypeScript
139 lines
4.5 KiB
TypeScript
/*
|
|
* Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
|
|
* - test/language/statements/for-await-of/ticks-with-sync-iter-resolved-promise-and-constructor-lookup.js
|
|
* - test/language/statements/for-await-of/async-func-dstr-let-ary-ptrn-elem-id-iter-val.js
|
|
* - test/language/statements/for-await-of/async-func-decl-dstr-array-rest-after-element.js
|
|
*
|
|
* Copyright (C) 2019 André Bargull. All rights reserved.
|
|
* Test262 portions are governed by the BSD license in LICENSE.test262.
|
|
*/
|
|
import { describe, expect, test } from "bun:test"
|
|
import { Effect } from "effect"
|
|
import { CodeMode } from "../src/index.js"
|
|
|
|
const execute = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {} }))
|
|
|
|
const value = async (code: string) => {
|
|
const result = await execute(code)
|
|
if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
|
|
return result.value
|
|
}
|
|
|
|
describe("Test262 for-await-of adaptations", () => {
|
|
test("awaits promise and plain values from a synchronous array", async () => {
|
|
expect(
|
|
await value(`
|
|
const values = []
|
|
for await (const item of [Promise.resolve(1), 2, new Promise((resolve) => resolve(3))]) {
|
|
values.push(item)
|
|
}
|
|
return values
|
|
`),
|
|
).toEqual([1, 2, 3])
|
|
})
|
|
|
|
test("defers the body even for an already-resolved or plain value", async () => {
|
|
expect(
|
|
await value(`
|
|
const events = []
|
|
const before = Promise.resolve().then(() => events.push("before"))
|
|
for await (const item of [Promise.resolve(1), 2]) events.push("body " + item)
|
|
await before
|
|
return events
|
|
`),
|
|
).toEqual(["before", "body 1", "body 2"])
|
|
})
|
|
|
|
test("an awaited rejection exits through normal try/catch", async () => {
|
|
const result = await execute(`
|
|
const values = []
|
|
try {
|
|
for await (const item of [Promise.resolve(1), Promise.reject("stop"), Promise.resolve(3)]) {
|
|
values.push(item)
|
|
}
|
|
} catch (error) {
|
|
return [values, error]
|
|
}
|
|
return "missed"
|
|
`)
|
|
expect(result.ok).toBe(true)
|
|
if (!result.ok) return
|
|
expect(result.value).toEqual([[1], "stop"])
|
|
expect(result.warnings ?? []).toEqual([])
|
|
})
|
|
|
|
test("destructures after resolving each yielded value", async () => {
|
|
expect(
|
|
await value(`
|
|
const values = []
|
|
for await (const [first, ...rest] of [Promise.resolve([1, 2, 3])]) {
|
|
values.push(first, rest)
|
|
}
|
|
return values
|
|
`),
|
|
).toEqual([1, [2, 3]])
|
|
})
|
|
|
|
test("supports assignment targets", async () => {
|
|
expect(
|
|
await value(`
|
|
let first
|
|
let rest
|
|
for await ([first, ...rest] of [Promise.resolve([1, 2, 3])]) {}
|
|
return [first, rest]
|
|
`),
|
|
).toEqual([1, [2, 3]])
|
|
})
|
|
|
|
test("preserves fresh lexical bindings per iteration", async () => {
|
|
expect(
|
|
await value(`
|
|
const reads = []
|
|
for await (const item of [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)]) {
|
|
reads.push(() => item)
|
|
}
|
|
return reads.map((read) => read())
|
|
`),
|
|
).toEqual([1, 2, 3])
|
|
})
|
|
|
|
test("supports every existing collection iterable", async () => {
|
|
expect(
|
|
await value(`
|
|
const string = []
|
|
for await (const item of "ab") string.push(item)
|
|
|
|
const set = []
|
|
for await (const item of new Set([Promise.resolve(1), 2])) set.push(item)
|
|
|
|
const map = []
|
|
for await (const [key, item] of new Map([["a", 1], ["b", 2]])) map.push(key, item)
|
|
|
|
const params = []
|
|
for await (const [key, item] of new URLSearchParams("a=1&b=2")) params.push(key, item)
|
|
return { string, set, map, params }
|
|
`),
|
|
).toEqual({ string: ["a", "b"], set: [1, 2], map: ["a", 1, "b", 2], params: ["a", "1", "b", "2"] })
|
|
})
|
|
|
|
test("preserves labeled break and continue behavior", async () => {
|
|
expect(
|
|
await value(`
|
|
const values = []
|
|
outer: for await (const item of [1, 2, 3, 4]) {
|
|
if (item === 2) continue outer
|
|
if (item === 4) break outer
|
|
values.push(item)
|
|
}
|
|
return values
|
|
`),
|
|
).toEqual([1, 3])
|
|
})
|
|
|
|
test("keeps custom iterator objects outside the supported subset", async () => {
|
|
const result = await execute(`for await (const item of { values: [1, 2] }) {}`)
|
|
expect(result.ok).toBe(false)
|
|
if (result.ok) return
|
|
expect(result.error.message).toContain("for await...of requires an array, string, Map, Set, or URLSearchParams")
|
|
})
|
|
})
|