packages/codemode/test/set-methods-test262.test.ts
Rama dev · réplica de lectura del repositorio original.
/*
* Portions adapted from Test262 at revision 250f204f23a9249ff204be2baec29600faae7b75:
* - test/built-ins/Set/prototype/union/combines-sets.js
* - test/built-ins/Set/prototype/union/combines-empty-sets.js
* - test/built-ins/Set/prototype/union/combines-itself.js
* - test/built-ins/Set/prototype/union/combines-same-sets.js
* - test/built-ins/Set/prototype/union/combines-Map.js
* - test/built-ins/Set/prototype/union/result-order.js
* - test/built-ins/Set/prototype/union/appends-new-values.js
* - test/built-ins/Set/prototype/union/allows-set-like-object.js
* - test/built-ins/Set/prototype/union/size-is-a-number.js
* - test/built-ins/Set/prototype/union/has-is-callable.js
* - test/built-ins/Set/prototype/union/keys-is-callable.js
* - test/built-ins/Set/prototype/union/array-throws.js
* - test/built-ins/Set/prototype/union/converts-negative-zero.js
* - test/built-ins/Set/prototype/union/set-like-class-mutation.js
* - test/built-ins/Set/prototype/intersection/combines-sets.js
* - test/built-ins/Set/prototype/intersection/combines-itself.js
* - test/built-ins/Set/prototype/intersection/result-order.js
* - test/built-ins/Set/prototype/intersection/size-is-a-number.js
* - test/built-ins/Set/prototype/intersection/converts-negative-zero.js
* - test/built-ins/Set/prototype/intersection/combines-Map.js
* - test/built-ins/Set/prototype/intersection/allows-set-like-object.js
* - test/built-ins/Set/prototype/intersection/set-like-class-mutation.js
* - test/built-ins/Set/prototype/difference/combines-sets.js
* - test/built-ins/Set/prototype/difference/combines-itself.js
* - test/built-ins/Set/prototype/difference/result-order.js
* - test/built-ins/Set/prototype/difference/size-is-a-number.js
* - test/built-ins/Set/prototype/difference/converts-negative-zero.js
* - test/built-ins/Set/prototype/difference/combines-Map.js
* - test/built-ins/Set/prototype/difference/allows-set-like-object.js
* - test/built-ins/Set/prototype/difference/set-like-class-mutation.js
* - test/built-ins/Set/prototype/symmetricDifference/combines-sets.js
* - test/built-ins/Set/prototype/symmetricDifference/combines-itself.js
* - test/built-ins/Set/prototype/symmetricDifference/result-order.js
* - test/built-ins/Set/prototype/symmetricDifference/size-is-a-number.js
* - test/built-ins/Set/prototype/symmetricDifference/converts-negative-zero.js
* - test/built-ins/Set/prototype/symmetricDifference/set-like-class-mutation.js
* - test/built-ins/Set/prototype/symmetricDifference/combines-Map.js
* - test/built-ins/Set/prototype/symmetricDifference/allows-set-like-object.js
* - test/built-ins/Set/prototype/isSubsetOf/compares-sets.js
* - test/built-ins/Set/prototype/isSubsetOf/size-is-a-number.js
* - test/built-ins/Set/prototype/isSubsetOf/compares-Map.js
* - test/built-ins/Set/prototype/isSubsetOf/allows-set-like-object.js
* - test/built-ins/Set/prototype/isSubsetOf/compares-itself.js
* - test/built-ins/Set/prototype/isSubsetOf/compares-same-sets.js
* - test/built-ins/Set/prototype/isSubsetOf/set-like-class-mutation.js
* - test/built-ins/Set/prototype/isSupersetOf/compares-sets.js
* - test/built-ins/Set/prototype/isSupersetOf/size-is-a-number.js
* - test/built-ins/Set/prototype/isSupersetOf/compares-Map.js
* - test/built-ins/Set/prototype/isSupersetOf/allows-set-like-object.js
* - test/built-ins/Set/prototype/isSupersetOf/compares-itself.js
* - test/built-ins/Set/prototype/isSupersetOf/compares-same-sets.js
* - test/built-ins/Set/prototype/isSupersetOf/converts-negative-zero.js
* - test/built-ins/Set/prototype/isDisjointFrom/compares-sets.js
* - test/built-ins/Set/prototype/isDisjointFrom/size-is-a-number.js
* - test/built-ins/Set/prototype/isDisjointFrom/compares-Map.js
* - test/built-ins/Set/prototype/isDisjointFrom/allows-set-like-object.js
* - test/built-ins/Set/prototype/isDisjointFrom/compares-itself.js
* - test/built-ins/Set/prototype/isDisjointFrom/compares-same-sets.js
* - test/built-ins/Set/prototype/isDisjointFrom/converts-negative-zero.js
* - test/built-ins/Set/prototype/isDisjointFrom/set-like-class-mutation.js
*
* Copyright (C) 2023 Anthony Frehner. All rights reserved.
* Copyright (C) 2023 Anthony Frehner and Kevin Gibbons. All rights reserved.
* Copyright (C) 2023 Kevin Gibbons. All rights reserved.
* Copyright (C) 2023 Kevin Gibbons, Anthony Frehner. All rights reserved.
* Test262 portions are governed by the BSD license in LICENSE.test262.
* Set-like `keys` methods return arrays instead of iterator objects because
* CodeMode materializes supported iterators and does not support generators.
*/
import { describe, expect, test } from "bun:test"
import { Effect } from "effect"
import { CodeMode } from "./lib/index.js"
const value = async (code: string) => {
const result = await Effect.runPromise(CodeMode.execute({ code, tools: {} }))
if (!result.ok) throw new Error(`expected success, got ${result.error.kind}: ${result.error.message}`)
return result.value
}
describe("Set composition Test262 parity", () => {
test("combines Sets without mutating either operand", async () => {
expect(
await value(`
const left = new Set([1, 2])
const right = new Set([2, 3])
const union = left.union(right)
const intersection = left.intersection(right)
const difference = left.difference(right)
const symmetric = left.symmetricDifference(right)
return [
[...union], union instanceof Set,
[...intersection], intersection instanceof Set,
[...difference], difference instanceof Set,
[...symmetric], symmetric instanceof Set,
[...left], [...right],
[...left.union(left)], left.union(left) !== left,
[...left.intersection(left)], left.intersection(left) !== left,
[...left.difference(left)], left.difference(left) !== left,
[...left.symmetricDifference(left)], left.symmetricDifference(left) !== left,
[...left.union(new Set())], [...new Set().union(left)],
]
`),
).toEqual([
[1, 2, 3],
true,
[2],
true,
[1],
true,
[1, 3],
true,
[1, 2],
[2, 3],
[1, 2],
true,
[1, 2],
true,
[],
true,
[],
true,
[1, 2],
[1, 2],
])
})
test("preserves the specified result order", async () => {
expect(
await value(`
return [
[...new Set([1, 3, 5]).intersection(new Set([3, 2, 1]))],
[...new Set([3, 2, 1, 0]).intersection(new Set([1, 3, 5]))],
[...new Set([1, 2, 3, 4]).difference(new Set([6, 5, 3, 2]))],
[...new Set([6, 5, 3, 2]).difference(new Set([1, 2, 3, 4]))],
[...new Set([1, 2, 3, 4]).symmetricDifference(new Set([6, 5, 4, 3]))],
[...new Set([2, 3]).union(new Set([1, 2]))],
[...new Set([1, 2, -3]).union(new Set([-1, 0]))],
]
`),
).toEqual([
[1, 3],
[1, 3],
[1, 4],
[6, 5],
[1, 2, 6, 5],
[2, 3, 1],
[1, 2, -3, -1, 0],
])
})
test("accepts Maps as Set-like operands", async () => {
expect(
await value(`
const set = new Set([1, 2])
const map = new Map([[2, "two"], [3, "three"]])
return [
[...set.union(map)],
[...set.intersection(map)],
[...set.difference(map)],
[...set.symmetricDifference(map)],
]
`),
).toEqual([[1, 2, 3], [2], [1], [1, 3]])
})
test("accepts supported Set-like objects and uses the size-selected method", async () => {
expect(
await value(`
const keysOnly = {
size: 1,
has: () => { throw new Error("has should not be called") },
keys: () => [2, 3],
}
const hasOnly = {
size: 2,
has: (value) => value === 2,
keys: () => { throw new Error("keys should not be called") },
}
const set = new Set([1, 2])
return [
[...set.union(keysOnly)],
[...set.intersection(hasOnly)],
[...set.difference(hasOnly)],
[...set.symmetricDifference(keysOnly)],
]
`),
).toEqual([[1, 2, 3], [2], [1], [1, 3]])
})
test("normalizes negative zero", async () => {
expect(
await value(`
const setlike = {
size: 1,
has: () => { throw new Error("has should not be called") },
keys: () => [-0],
}
return [
1 / [...new Set([1]).union(setlike)][1] === Infinity,
1 / [...new Set([0, 1, 2]).intersection(setlike)][0] === Infinity,
[...new Set([0, 1]).difference(setlike)],
1 / [...new Set([1, 2]).symmetricDifference(setlike)][2] === Infinity,
]
`),
).toEqual([true, true, [1], true])
})
test("handles duplicate Set-like keys using receiver membership", async () => {
expect(
await value(`
const other = {
size: 4,
has: () => { throw new Error("has should not be called") },
keys: () => [2, 2, 3, 3],
}
return [...new Set([1, 2]).symmetricDifference(other)]
`),
).toEqual([1, 3])
})
test("copies receiver data before Set-like key iteration mutates it", async () => {
expect(
await value(`
const unionBase = new Set(["a", "b", "c", "d", "e"])
const unionOther = {
size: 2,
has: () => { throw new Error("has should not be called") },
keys: () => {
unionBase.delete("b")
unionBase.delete("c")
unionBase.add("b")
return ["x", "y"]
},
}
const union = unionBase.union(unionOther)
const intersectionBase = new Set(["a", "b", "c", "d", "e"])
const intersectionOther = {
size: 3,
has: () => { throw new Error("has should not be called") },
keys: () => {
intersectionBase.delete("b")
intersectionBase.delete("c")
intersectionBase.add("b")
return ["x", "b", "b"]
},
}
const intersection = intersectionBase.intersection(intersectionOther)
const differenceBase = new Set(["a", "b", "c", "d", "e"])
const differenceOther = {
size: 3,
has: () => { throw new Error("has should not be called") },
keys: () => {
differenceBase.delete("b")
differenceBase.delete("c")
differenceBase.add("b")
return ["x", "b", "b"]
},
}
const difference = differenceBase.difference(differenceOther)
const symmetricBase = new Set(["a", "b", "c", "d", "e"])
const symmetricOther = {
size: 4,
has: () => { throw new Error("has should not be called") },
keys: () => {
symmetricBase.delete("b")
symmetricBase.delete("c")
symmetricBase.add("b")
return ["x", "b", "c", "c"]
},
}
const symmetric = symmetricBase.symmetricDifference(symmetricOther)
return [
[...union], [...unionBase],
[...intersection], [...intersectionBase],
[...difference], [...differenceBase],
[...symmetric], [...symmetricBase],
]
`),
).toEqual([
["a", "b", "c", "d", "e", "x", "y"],
["a", "d", "e", "b"],
["b"],
["a", "d", "e", "b"],
["a", "c", "d", "e"],
["a", "d", "e", "b"],
["a", "c", "d", "e", "x"],
["a", "d", "e", "b"],
])
})
})
describe("Set relation Test262 parity", () => {
test("compares Sets", async () => {
expect(
await value(`
const set = new Set([1, 2])
return [
set.isSubsetOf(new Set([2, 3])), set.isSubsetOf(new Set([1, 2, 3])),
set.isSupersetOf(new Set([2, 3])), set.isSupersetOf(new Set([1])),
set.isDisjointFrom(new Set([2, 3])), set.isDisjointFrom(new Set([3])),
new Set().isSubsetOf(set), set.isSupersetOf(new Set()), new Set().isDisjointFrom(new Set()),
set.isSubsetOf(set), set.isSupersetOf(set), set.isDisjointFrom(set),
set.isSubsetOf(new Set([1, 2])), set.isSupersetOf(new Set([1, 2])),
]
`),
).toEqual([false, true, false, true, false, true, true, true, true, true, true, false, true, true])
})
test("compares Maps and supported Set-like objects", async () => {
expect(
await value(`
const set = new Set([1, 2])
const map = new Map([[1, "one"], [2, "two"], [3, "three"]])
const hasOnly = {
size: 2,
has: (value) => value === 1 || value === 2,
keys: () => { throw new Error("keys should not be called") },
}
const keysOnly = {
size: 1,
has: () => { throw new Error("has should not be called") },
keys: () => [1],
}
return [
set.isSubsetOf(map), set.isSupersetOf(map), set.isDisjointFrom(map),
set.isSubsetOf(hasOnly), set.isSupersetOf(keysOnly), set.isDisjointFrom(hasOnly),
]
`),
).toEqual([true, false, false, true, true, false])
})
test("normalizes negative zero from Set-like keys", async () => {
expect(
await value(`
const setlike = {
size: 1,
has: () => { throw new Error("has should not be called") },
keys: () => [-0],
}
return [
new Set([0, 1]).isSupersetOf(setlike),
new Set([0, 1]).isDisjointFrom(setlike),
]
`),
).toEqual([true, false])
})
test("observes live receiver mutation while calling Set-like has", async () => {
expect(
await value(`
const subset = new Set(["a", "b", "c"])
const subsetOther = {
size: 3,
has: (item) => {
if (item === "a") subset.delete("c")
return ["x", "a", "b"].includes(item)
},
keys: () => { throw new Error("keys should not be called") },
}
const disjoint = new Set(["a", "b", "c"])
const disjointOther = {
size: 3,
has: (item) => {
if (item === "a") {
disjoint.delete("b")
disjoint.delete("c")
disjoint.add("b")
}
if (item === "c") throw new Error("deleted value should not be visited")
return false
},
keys: () => { throw new Error("keys should not be called") },
}
return [
subset.isSubsetOf(subsetOther), [...subset],
disjoint.isDisjointFrom(disjointOther), [...disjoint],
]
`),
).toEqual([true, ["a", "b"], true, ["a", "b"]])
})
})
describe("Set-like validation Test262 parity", () => {
test("rejects arrays, invalid sizes, and non-callable methods with TypeError", async () => {
expect(
await value(`
const set = new Set([1])
const names = []
let coercionCalls = 0
const invalid = [
[],
{ size: undefined, has: () => false, keys: () => [] },
{ size: NaN, has: () => false, keys: () => [] },
{ size: { valueOf: () => { coercionCalls += 1; return NaN } }, has: () => false, keys: () => [] },
{ size: "string", has: () => false, keys: () => [] },
{ size: 0, has: undefined, keys: () => [] },
{ size: 0, has: {}, keys: () => [] },
{ size: 0, has: () => false, keys: undefined },
{ size: 0, has: () => false, keys: {} },
]
for (const other of invalid) {
try { set.union(other) } catch (error) { names.push(error.name) }
}
return [names, coercionCalls]
`),
).toEqual([
[
"TypeError",
"TypeError",
"TypeError",
"TypeError",
"TypeError",
"TypeError",
"TypeError",
"TypeError",
"TypeError",
],
1,
])
})
test("validates Set-like records for every method", async () => {
expect(
await value(`
const set = new Set([1])
const invalid = { size: NaN, has: () => false, keys: () => [] }
const names = []
const operations = [
() => set.union(invalid),
() => set.intersection(invalid),
() => set.difference(invalid),
() => set.symmetricDifference(invalid),
() => set.isSubsetOf(invalid),
() => set.isSupersetOf(invalid),
() => set.isDisjointFrom(invalid),
]
for (const operation of operations) {
try { operation() } catch (error) { names.push(error.name) }
}
return names
`),
).toEqual(["TypeError", "TypeError", "TypeError", "TypeError", "TypeError", "TypeError", "TypeError"])
})
test("requires Set-like keys to return CodeMode's materialized iterator representation", async () => {
expect(
await value(`
const set = new Set([1])
const names = []
for (const keys of [() => "ab", () => new Set([2]), () => new Map([[2, true]])]) {
try { set.union({ size: 1, has: () => false, keys }) } catch (error) { names.push(error.name) }
}
return names
`),
).toEqual(["TypeError", "TypeError", "TypeError"])
})
})