Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

96 files changed, 5207 insertions, 0 deletions

diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-async-mapped-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-async-mapped-awaits-once.js
new file mode 100644
index 0000000000..19fea4fdfa
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-async-mapped-awaits-once.js
@@ -0,0 +1,31 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Async-iterable awaits each input once with mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  async function* generateInput () {
+    yield* [ 0, 1, 2 ];
+  }
+  const input = generateInput();
+  let awaitCounter = 0;
+  await Array.fromAsync(input, v => {
+    return {
+      // This “then” method should occur three times:
+      // one for each value from the input.
+      then (resolve, reject) {
+        awaitCounter ++;
+        resolve(v);
+      },
+    };
+  });
+  assert.sameValue(awaitCounter, 3);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-does-not-await-input.js b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-does-not-await-input.js
new file mode 100644
index 0000000000..7512a69e3f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-does-not-await-input.js
@@ -0,0 +1,39 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Async-iterable input does not await input values.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const prom = Promise.resolve({});
+  const expected = [ prom ];
+
+  function createInput () {
+    return {
+      // The following async iterator will yield one value
+      // (the promise named “prom”).
+      [Symbol.asyncIterator]() {
+        let i = 0;
+        return {
+          async next() {
+            if (i > 0) {
+              return { done: true };
+            }
+            i++;
+            return { value: prom, done: false }
+          },
+        };
+      },
+    };
+  }
+
+  const input = createInput();
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-iteration-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-iteration-err.js
new file mode 100644
index 0000000000..c4c9baec1e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input-iteration-err.js
@@ -0,0 +1,21 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync promise rejects if iteration of input fails.
+flags: [async]
+features: [Array.fromAsync]
+includes: [asyncHelpers.js]
+---*/
+
+asyncTest(async function () {
+  async function *generateInput () {
+    throw new Test262Error('This error should be propagated.');
+  }
+  const input = generateInput();
+  const outputPromise = Array.fromAsync(input);
+  await assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input.js b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input.js
new file mode 100644
index 0000000000..edf1c21de9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/async-iterable-input.js
@@ -0,0 +1,24 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Async-iterable input is transferred to the output array.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expected = [ 0, 1, 2 ];
+
+  async function* generateInput () {
+    yield* expected;
+  }
+
+  const input = generateInput();
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-empty.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-empty.js
new file mode 100644
index 0000000000..ac4687646e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-empty.js
@@ -0,0 +1,45 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync respects array mutation
+info: |
+  Array.fromAsync
+    3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).
+
+  IteratorStep
+    1. Let result be ? IteratorNext(iteratorRecord).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  %AsyncFromSyncIteratorPrototype%.next
+    6.a. Let result be Completion(IteratorNext(syncIteratorRecord)).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  Array.prototype [ @@iterator ] ( )
+  Array.prototype.values ( )
+    2. Return CreateArrayIterator(O, value).
+
+  CreateArrayIterator
+    1.b.iii. If index ≥ len, return NormalCompletion(undefined).
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = [];
+  const promise = Array.fromAsync(items);
+  // By the time we get here, the first next() call has already happened, and returned
+  // { done: true }. We then return from the loop in Array.fromAsync 3.j.ii. with the empty array,
+  // and the following line no longer affects that.
+  items.push(7);
+  const result = await promise;
+  assert.compareArray(result, []);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-singleton.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-singleton.js
new file mode 100644
index 0000000000..4cc0f501fa
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add-to-singleton.js
@@ -0,0 +1,44 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync respects array mutation
+info: |
+  Array.fromAsync
+    3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).
+
+  IteratorStep
+    1. Let result be ? IteratorNext(iteratorRecord).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  %AsyncFromSyncIteratorPrototype%.next
+    6.a. Let result be Completion(IteratorNext(syncIteratorRecord)).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  Array.prototype [ @@iterator ] ( )
+  Array.prototype.values ( )
+    2. Return CreateArrayIterator(O, value).
+
+  CreateArrayIterator
+    1.b.iii. If index ≥ len, return NormalCompletion(undefined).
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = [1];
+  const promise = Array.fromAsync(items);
+  // At this point, the first element of `items` has been read, but the iterator will take other
+  // changes into account.
+  items.push(7);
+  const result = await promise;
+  assert.compareArray(result, [1, 7]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add.js
new file mode 100644
index 0000000000..6cf02babb9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-add.js
@@ -0,0 +1,44 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync respects array mutation
+info: |
+  Array.fromAsync
+    3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).
+
+  IteratorStep
+    1. Let result be ? IteratorNext(iteratorRecord).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  %AsyncFromSyncIteratorPrototype%.next
+    6.a. Let result be Completion(IteratorNext(syncIteratorRecord)).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  Array.prototype [ @@iterator ] ( )
+  Array.prototype.values ( )
+    2. Return CreateArrayIterator(O, value).
+
+  CreateArrayIterator
+    1.b.iii. If index ≥ len, return NormalCompletion(undefined).
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = [1, 2, 3];
+  const promise = Array.fromAsync(items);
+  // At this point, the first element of `items` has been read, but the iterator will take other
+  // changes into account.
+  items.push(4);
+  const result = await promise;
+  assert.compareArray(result, [1, 2, 3, 4]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-mutate.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-mutate.js
new file mode 100644
index 0000000000..2d910d2524
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-mutate.js
@@ -0,0 +1,45 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync respects array mutation
+info: |
+  Array.fromAsync
+    3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).
+
+  IteratorStep
+    1. Let result be ? IteratorNext(iteratorRecord).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  %AsyncFromSyncIteratorPrototype%.next
+    6.a. Let result be Completion(IteratorNext(syncIteratorRecord)).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  Array.prototype [ @@iterator ] ( )
+  Array.prototype.values ( )
+    2. Return CreateArrayIterator(O, value).
+
+  CreateArrayIterator
+    1.b.iii. If index ≥ len, return NormalCompletion(undefined).
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = [1, 2, 3];
+  const promise = Array.fromAsync(items);
+  // At this point, the first element of `items` has been read, but the iterator will take other
+  // changes into account.
+  items[0] = 7;
+  items[1] = 8;
+  const result = await promise;
+  assert.compareArray(result, [1, 8, 3]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-remove.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-remove.js
new file mode 100644
index 0000000000..6733b42260
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-array-remove.js
@@ -0,0 +1,44 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync respects array mutation
+info: |
+  Array.fromAsync
+    3.j.ii.3. Let next be ? Await(IteratorStep(iteratorRecord)).
+
+  IteratorStep
+    1. Let result be ? IteratorNext(iteratorRecord).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  %AsyncFromSyncIteratorPrototype%.next
+    6.a. Let result be Completion(IteratorNext(syncIteratorRecord)).
+
+  IteratorNext
+    1.a. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[Iterator]]).
+
+  Array.prototype [ @@iterator ] ( )
+  Array.prototype.values ( )
+    2. Return CreateArrayIterator(O, value).
+
+  CreateArrayIterator
+    1.b.iii. If index ≥ len, return NormalCompletion(undefined).
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = [1, 2, 3];
+  const promise = Array.fromAsync(items);
+  // At this point, the first element of `items` has been read, but the iterator will take other
+  // changes into account.
+  items.pop();
+  const result = await promise;
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraybuffer.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraybuffer.js
new file mode 100644
index 0000000000..59df9897b5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraybuffer.js
@@ -0,0 +1,18 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync doesn't special-case ArrayBuffer
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const items = new ArrayBuffer(7);
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, []);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-holes.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-holes.js
new file mode 100644
index 0000000000..5396f9015b
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-holes.js
@@ -0,0 +1,25 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Array-like object with holes treats the holes as undefined
+info: |
+  3.k.vii.2. Let _kValue_ be ? Get(_arrayLike_, _Pk_).
+features: [Array.fromAsync]
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+---*/
+
+asyncTest(async function () {
+  const arrayLike = Object.create(null);
+  arrayLike.length = 5;
+  arrayLike[0] = 0;
+  arrayLike[1] = 1;
+  arrayLike[2] = 2;
+  arrayLike[4] = 4;
+
+  const array = await Array.fromAsync(arrayLike);
+  assert.compareArray(array, [0, 1, 2, undefined, 4], "holes in array-like treated as undefined");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-length-accessor-throws.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-length-accessor-throws.js
new file mode 100644
index 0000000000..81932ec791
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-length-accessor-throws.js
@@ -0,0 +1,26 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Rejects on array-like object whose length cannot be gotten
+info: |
+  3.k.iii. Let _len_ be ? LengthOfArrayLike(_arrayLike_).
+features: [Array.fromAsync]
+flags: [async]
+includes: [asyncHelpers.js]
+---*/
+
+asyncTest(async function () {
+  await assert.throwsAsync(Test262Error, () => Array.fromAsync({
+    get length() {
+      throw new Test262Error('accessing length property fails');
+    }
+  }), "Promise should be rejected if array-like length getter throws");
+
+  await assert.throwsAsync(TypeError, () => Array.fromAsync({
+    length: 1n,
+    0: 0
+  }), "Promise should be rejected if array-like length can't be converted to a number");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-promise.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-promise.js
new file mode 100644
index 0000000000..141ce7f08c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-promise.js
@@ -0,0 +1,32 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync tries the various properties in order and awaits promises
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const actual = [];
+  const items = TemporalHelpers.propertyBagObserver(actual, {
+    length: 2,
+    0: Promise.resolve(2),
+    1: Promise.resolve(1),
+  }, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [2, 1]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+    "get items.length",
+    "get items.length.valueOf",
+    "call items.length.valueOf",
+    "get items[0]",
+    "get items[1]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-too-long.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-too-long.js
new file mode 100644
index 0000000000..c634be42ec
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-arraylike-too-long.js
@@ -0,0 +1,32 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Promise is rejected if the length of the array-like to copy is out of range
+info: |
+  j. If _iteratorRecord_ is not *undefined*, then
+    ...
+  k. Else,
+    ...
+    iv. If IsConstructor(_C_) is *true*, then
+      ...
+    v. Else,
+      1. Let _A_ be ? ArrayCreate(_len_).
+
+  ArrayCreate, step 1:
+    1. If _length_ > 2³² - 1, throw a *RangeError* exception.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const notConstructor = {};
+
+  await assert.throwsAsync(RangeError, () => Array.fromAsync.call(notConstructor, {
+    length: 4294967296  // 2³²
+  }), "Array-like with excessive length");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-exists.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-exists.js
new file mode 100644
index 0000000000..7f4511990d
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-exists.js
@@ -0,0 +1,33 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync tries the various properties in order
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  async function * asyncGen() {
+    for (let i = 0; i < 4; i++) {
+      yield Promise.resolve(i * 2);
+    }
+  }
+
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, asyncGen, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [0, 2, 4, 6]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-not-callable.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-not-callable.js
new file mode 100644
index 0000000000..f9406f5a29
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-not-callable.js
@@ -0,0 +1,20 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync rejects if the @@asyncIterator property is not callable
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  for (const v of [true, "", Symbol(), 1, 1n, {}]) {
+    await assert.throwsAsync(TypeError,
+      () => Array.fromAsync({ [Symbol.asyncIterator]: v }),
+      `@@asyncIterator = ${typeof v}`);
+  }
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-null.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-null.js
new file mode 100644
index 0000000000..3375e3a1de
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-null.js
@@ -0,0 +1,31 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync tries the various properties in order
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, null, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [2, 1]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+    "get items.length",
+    "get items[0]",
+    "get items[1]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-sync.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-sync.js
new file mode 100644
index 0000000000..90fd4e607b
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-sync.js
@@ -0,0 +1,33 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync handles a sync iterator returned from @@asyncIterator
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function * syncGen() {
+    for (let i = 0; i < 4; i++) {
+      yield i * 2;
+    }
+  }
+
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, syncGen, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [0, 2, 4, 6]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-throws.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-throws.js
new file mode 100644
index 0000000000..22c78f236a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-asynciterator-throws.js
@@ -0,0 +1,17 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync rejects if getting the @@asyncIterator property throws
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  await assert.throwsAsync(Test262Error,
+    () => Array.fromAsync({ get [Symbol.asyncIterator]() { throw new Test262Error() } }));
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-bigint.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-bigint.js
new file mode 100644
index 0000000000..307b8da877
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-bigint.js
@@ -0,0 +1,21 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync treats a BigInt as an array-like
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  BigInt.prototype.length = 2;
+  BigInt.prototype[0] = 1;
+  BigInt.prototype[1] = 2;
+
+  const result = await Array.fromAsync(1n);
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-boolean.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-boolean.js
new file mode 100644
index 0000000000..62042774f2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-boolean.js
@@ -0,0 +1,21 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync treats a boolean as an array-like
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  Boolean.prototype.length = 2;
+  Boolean.prototype[0] = 1;
+  Boolean.prototype[1] = 2;
+
+  const result = await Array.fromAsync(true);
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-function.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-function.js
new file mode 100644
index 0000000000..80facef636
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-function.js
@@ -0,0 +1,22 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync treats a function as an array-like, reading elements up to fn.length
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const fn = function(a, b) {};
+  fn[0] = 1;
+  fn[1] = 2;
+  fn[2] = 3;
+
+  const result = await Array.fromAsync(fn);
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-exists.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-exists.js
new file mode 100644
index 0000000000..b964229285
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-exists.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync handles a sync iterator returned from @@iterator
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function * syncGen() {
+    for (let i = 0; i < 4; i++) {
+      yield i * 2;
+    }
+  }
+
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, syncGen, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [0, 2, 4, 6]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-not-callable.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-not-callable.js
new file mode 100644
index 0000000000..d672bba1dd
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-not-callable.js
@@ -0,0 +1,20 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync rejects if the @@iterator property is not callable
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  for (const v of [true, "", Symbol(), 1, 1n, {}]) {
+    await assert.throwsAsync(TypeError,
+      () => Array.fromAsync({ [Symbol.iterator]: v }),
+      `@@iterator = ${typeof v}`);
+  }
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-null.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-null.js
new file mode 100644
index 0000000000..9a8b071d02
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-null.js
@@ -0,0 +1,31 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync tries the various properties in order
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, null, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [2, 1]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+    "get items.length",
+    "get items[0]",
+    "get items[1]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-promise.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-promise.js
new file mode 100644
index 0000000000..b99e5af4cd
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-promise.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync handles an async iterator returned from @@iterator
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function * asyncGen() {
+    for (let i = 0; i < 4; i++) {
+      yield Promise.resolve(i * 2);
+    }
+  }
+
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, asyncGen, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [0, 2, 4, 6]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-throws.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-throws.js
new file mode 100644
index 0000000000..148c3d9dfe
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-iterator-throws.js
@@ -0,0 +1,17 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync rejects if getting the @@iterator property throws
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  await assert.throwsAsync(Test262Error,
+    () => Array.fromAsync({ get [Symbol.iterator]() { throw new Test262Error() } }));
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-null-undefined.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-null-undefined.js
new file mode 100644
index 0000000000..e78c18f199
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-null-undefined.js
@@ -0,0 +1,19 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync rejects with a TypeError if the asyncItems argument is null or undefined
+info: |
+  3.c. Let usingAsyncIterator be ? GetMethod(asyncItems, @@asyncIterator).
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  await assert.throwsAsync(TypeError, () => Array.fromAsync(null), "null asyncItems");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync(undefined), "undefined asyncItems");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-number.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-number.js
new file mode 100644
index 0000000000..2dd8ace8e9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-number.js
@@ -0,0 +1,21 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync treats a Number as an array-like
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  Number.prototype.length = 2;
+  Number.prototype[0] = 1;
+  Number.prototype[1] = 2;
+
+  const result = await Array.fromAsync(1);
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-object-not-arraylike.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-object-not-arraylike.js
new file mode 100644
index 0000000000..62f3dd27b4
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-object-not-arraylike.js
@@ -0,0 +1,24 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Treats an asyncItems object that isn't an array-like as a 0-length array-like
+info: |
+  3.k.iii. Let _len_ be ? LengthOfArrayLike(_arrayLike_).
+features: [Array.fromAsync]
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+---*/
+
+asyncTest(async function () {
+  const notArrayLike = Object.create(null);
+  notArrayLike[0] = 0;
+  notArrayLike[1] = 1;
+  notArrayLike[2] = 2;
+
+  const array = await Array.fromAsync(notArrayLike);
+  assert.compareArray(array, [], "non-array-like object is treated as 0-length array-like");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-operations.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-operations.js
new file mode 100644
index 0000000000..89b854e164
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-operations.js
@@ -0,0 +1,31 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync tries the various properties in order
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const actual = [];
+  const items = {};
+  TemporalHelpers.observeProperty(actual, items, Symbol.asyncIterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, Symbol.iterator, undefined, "items");
+  TemporalHelpers.observeProperty(actual, items, "length", 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 0, 2, "items");
+  TemporalHelpers.observeProperty(actual, items, 1, 1, "items");
+  const result = await Array.fromAsync(items);
+  assert.compareArray(result, [2, 1]);
+  assert.compareArray(actual, [
+    "get items[Symbol.asyncIterator]",
+    "get items[Symbol.iterator]",
+    "get items.length",
+    "get items[0]",
+    "get items[1]",
+  ]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-string.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-string.js
new file mode 100644
index 0000000000..d12cfb5453
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-string.js
@@ -0,0 +1,17 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync iterates over a string
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const result = await Array.fromAsync("test");
+  assert.compareArray(result, ["t", "e", "s", "t"]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-symbol.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-symbol.js
new file mode 100644
index 0000000000..335a1d1325
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-symbol.js
@@ -0,0 +1,21 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync treats a Symbol as an array-like
+includes: [asyncHelpers.js, compareArray.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  Symbol.prototype.length = 2;
+  Symbol.prototype[0] = 1;
+  Symbol.prototype[1] = 2;
+
+  const result = await Array.fromAsync(Symbol());
+  assert.compareArray(result, [1, 2]);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-uses-intrinsic-iterator-symbols.js b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-uses-intrinsic-iterator-symbols.js
new file mode 100644
index 0000000000..f0e76c4ae0
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/asyncitems-uses-intrinsic-iterator-symbols.js
@@ -0,0 +1,41 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Use the intrinsic @@iterator and @@asyncIterator to check iterability
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  // Replace the user-reachable Symbol.iterator and Symbol.asyncIterator with
+  // fake symbol keys
+  const originalSymbol = globalThis.Symbol;
+  const fakeIteratorSymbol = Symbol("iterator");
+  const fakeAsyncIteratorSymbol = Symbol("asyncIterator");
+  globalThis.Symbol = {
+    iterator: fakeIteratorSymbol,
+    asyncIterator: fakeAsyncIteratorSymbol,
+  };
+
+  const input = {
+    length: 3,
+    0: 0,
+    1: 1,
+    2: 2,
+    [fakeIteratorSymbol]() {
+      throw new Test262Error("The fake Symbol.iterator method should not be called");
+    },
+    [fakeAsyncIteratorSymbol]() {
+      throw new Test262Error("The fake Symbol.asyncIterator method should not be called");
+    }
+  };
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, [0, 1, 2]);
+
+  globalThis.Symbol = originalSymbol;
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/browser.js b/js/src/tests/test262/built-ins/Array/fromAsync/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/browser.js
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/builtin.js b/js/src/tests/test262/built-ins/Array/fromAsync/builtin.js
new file mode 100644
index 0000000000..79af2825bc
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/builtin.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Array.fromAsync meets the requirements for built-in objects
+info: |
+  Unless specified otherwise, a built-in object that is callable as a function
+  is a built-in function object with the characteristics described in 10.3.
+  Unless specified otherwise, the [[Extensible]] internal slot of a built-in
+  object initially has the value *true*.
+
+  Unless otherwise specified every built-in function and every built-in
+  constructor has the Function prototype object, which is the initial value of
+  the expression Function.prototype (20.2.3), as the value of its [[Prototype]]
+  internal slot.
+
+  Built-in functions that are not constructors do not have a "prototype"
+  property unless otherwise specified in the description of a particular
+  function.
+features: [Array.fromAsync]
+---*/
+
+assert(Object.isExtensible(Array.fromAsync), "Array.fromAsync is extensible");
+
+assert.sameValue(
+  Object.getPrototypeOf(Array.fromAsync),
+  Function.prototype,
+  "Prototype of Array.fromAsync is Function.prototype"
+);
+
+assert.sameValue(
+  Object.getOwnPropertyDescriptor(Array.fromAsync, "prototype"),
+  undefined,
+  "Array.fromAsync has no own prototype property"
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/length.js b/js/src/tests/test262/built-ins/Array/fromAsync/length.js
new file mode 100644
index 0000000000..949b749304
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/length.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Value and property descriptor of Array.fromAsync.length
+info: |
+  Every built-in function object, including constructors, has a *"length"*
+  property whose value is a non-negative integral Number. Unless otherwise
+  specified, this value is equal to the number of required parameters shown in
+  the subclause heading for the function description. Optional parameters and
+  rest parameters are not included in the parameter count.
+
+  Unless otherwise specified, the *"length"* property of a built-in function
+  object has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*,
+  [[Configurable]]: *true* }.
+includes: [propertyHelper.js]
+features: [Array.fromAsync]
+---*/
+
+verifyProperty(Array.fromAsync, "length", {
+  value: 1,
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-arraylike.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-arraylike.js
new file mode 100644
index 0000000000..5b6ddf60b1
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-arraylike.js
@@ -0,0 +1,36 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  An asynchronous mapping function is applied to each (awaited) item of an
+  arraylike.
+info: |
+  3.k.vii.4. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be ? Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    b. Let _mappedValue_ be ? Await(_mappedValue_).
+  ...
+  6. Perform ? CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+const arrayLike = {
+  length: 4,
+  0: 0,
+  1: 2,
+  2: Promise.resolve(4),
+  3: 6,
+};
+
+async function asyncMap(val, ix) {
+  return Promise.resolve(val * ix);
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync(arrayLike, asyncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "async mapfn should be applied to arraylike");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-async.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-async.js
new file mode 100644
index 0000000000..c7b01e8aa5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-async.js
@@ -0,0 +1,36 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  An asynchronous mapping function is applied to each item yielded by an
+  asynchronous iterable.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+    ...
+  ...
+  8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+async function* asyncGen() {
+  for (let i = 0; i < 4; i++) {
+    yield Promise.resolve(i * 2);
+  }
+}
+
+async function asyncMap(val, ix) {
+  return Promise.resolve(val * ix);
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync({ [Symbol.asyncIterator]: asyncGen }, asyncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "async mapfn should be applied to async iterable");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-sync.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-sync.js
new file mode 100644
index 0000000000..ded2dfd367
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-iterable-sync.js
@@ -0,0 +1,36 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  An asynchronous mapping function is applied to each item yielded by a
+  synchronous iterable.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+    ...
+  ...
+  8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+function* syncGen() {
+  for (let i = 0; i < 4; i++) {
+    yield i * 2;
+  }
+}
+
+async function asyncMap(val, ix) {
+  return Promise.resolve(val * ix);
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync({ [Symbol.iterator]: syncGen }, asyncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "async mapfn should be applied to sync iterable");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-async-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-async-iterator.js
new file mode 100644
index 0000000000..e2072a1e39
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-async-iterator.js
@@ -0,0 +1,41 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The iterator of an asynchronous iterable is closed when the asynchronous
+  mapping function throws.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+    d. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+let closed = false;
+const iterator = {
+  next() {
+    return Promise.resolve({ value: 1, done: false });
+  },
+  return() {
+    closed = true;
+    return Promise.resolve({ done: true });
+  },
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+
+asyncTest(async () => {
+  await assert.throwsAsync(Error, () => Array.fromAsync(iterator, async (val) => {
+    assert.sameValue(val, 1, "mapfn receives value from iterator");
+    throw new Error("mapfn throws");
+  }), "async mapfn rejecting should cause fromAsync to reject");
+  assert(closed, "async mapfn rejecting should close iterator")
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-sync-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-sync-iterator.js
new file mode 100644
index 0000000000..7a9480a698
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws-close-sync-iterator.js
@@ -0,0 +1,41 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The iterator of a synchronous iterable is closed when the asynchronous mapping
+  function throws.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+    d. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+let closed = false;
+const iterator = {
+  next() {
+    return { value: 1, done: false };
+  },
+  return() {
+    closed = true;
+    return { done: true };
+  },
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+
+asyncTest(async () => {
+  await assert.throwsAsync(Error, () => Array.fromAsync(iterator, async (val) => {
+    assert.sameValue(val, 1, "mapfn receives value from iterator");
+    throw new Error("mapfn throws");
+  }), "async mapfn rejecting should cause fromAsync to reject");
+  assert(closed, "async mapfn rejecting should close iterator")
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws.js
new file mode 100644
index 0000000000..663e2c9338
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-async-throws.js
@@ -0,0 +1,24 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The output promise rejects if the asynchronous mapping function rejects.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+    d. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await assert.throwsAsync(Test262Error, () => Array.fromAsync([1, 2, 3], async () => {
+    throw new Test262Error("mapfn throws");
+  }), "async mapfn rejecting should cause fromAsync to reject");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-not-callable.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-not-callable.js
new file mode 100644
index 0000000000..7f6e901f1c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-not-callable.js
@@ -0,0 +1,26 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  A TypeError is thrown if the mapfn argument to Array.fromAsync is not callable
+info: |
+  3.a. If _mapfn_ is *undefined*, let _mapping_ be *false*.
+    b. Else,
+      i. If IsCallable(_mapfn_) is *false*, throw a *TypeError* exception.
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync, BigInt, Symbol]
+---*/
+
+asyncTest(async () => {
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], null), "null mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], {}), "non-callable object mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], "String"), "string mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], true), "boolean mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], 3.1416), "number mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], 42n), "bigint mapfn");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync([], Symbol()), "symbol mapfn");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-result-awaited-once-per-iteration.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-result-awaited-once-per-iteration.js
new file mode 100644
index 0000000000..c7d9a0a901
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-result-awaited-once-per-iteration.js
@@ -0,0 +1,48 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The returned value from each invocation of the asynchronous mapping function
+  is awaited exactly once.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+    c. Set _mappedValue_ to Await(_mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js, temporalHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+const calls = [];
+const expected = [
+  "call mapping",
+  "get thenable_0.then",
+  "call thenable_0.then",
+  "call mapping",
+  "get thenable_1.then",
+  "call thenable_1.then",
+  "call mapping",
+  "get thenable_2.then",
+  "call thenable_2.then",
+];
+
+function mapping(val, ix) {
+  calls.push("call mapping");
+  const thenableName = `thenable_${ix}`;
+  return TemporalHelpers.propertyBagObserver(calls, {
+    then(resolve, reject) {
+      calls.push(`call ${thenableName}.then`);
+      resolve(val * 2);
+    }
+  }, thenableName)
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync([1, 2, 3], mapping);
+  assert.compareArray(result, [2, 4, 6], "mapping function applied");
+  assert.compareArray(calls, expected, "observable operations");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-arraylike.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-arraylike.js
new file mode 100644
index 0000000000..3d033f97f3
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-arraylike.js
@@ -0,0 +1,36 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  A synchronous mapping function is applied to each (awaited) item of an
+  arraylike.
+info: |
+  3.k.vii.4. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be ? Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+  ...
+  6. Perform ? CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+const arrayLike = {
+  length: 4,
+  0: 0,
+  1: 2,
+  2: Promise.resolve(4),
+  3: 6,
+};
+
+function syncMap(val, ix) {
+  return val * ix;
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync(arrayLike, syncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "sync mapfn should be applied to arraylike");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-async.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-async.js
new file mode 100644
index 0000000000..c790fedc82
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-async.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  A synchronous mapping function is applied to each item yielded by an
+  asynchronous iterable.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+  ...
+  8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+async function* asyncGen() {
+  for (let i = 0; i < 4; i++) {
+    yield Promise.resolve(i * 2);
+  }
+}
+
+function syncMap(val, ix) {
+  return val * ix;
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync({ [Symbol.asyncIterator]: asyncGen }, syncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "sync mapfn should be applied to async iterable");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-sync.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-sync.js
new file mode 100644
index 0000000000..97d7fe89c4
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-iterable-sync.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  A synchronous mapping function is applied to each item yielded by a
+  synchronous iterable.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    ...
+  ...
+  8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+flags: [async]
+includes: [asyncHelpers.js, compareArray.js]
+features: [Array.fromAsync]
+---*/
+
+function* syncGen() {
+  for (let i = 0; i < 4; i++) {
+    yield i * 2;
+  }
+}
+
+function syncMap(val, ix) {
+  return val * ix;
+}
+
+asyncTest(async () => {
+  const result = await Array.fromAsync({ [Symbol.iterator]: syncGen }, syncMap);
+  assert.compareArray(result, [0, 2, 8, 18], "sync mapfn should be applied to sync iterable");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-async-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-async-iterator.js
new file mode 100644
index 0000000000..a351445f1d
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-async-iterator.js
@@ -0,0 +1,40 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The iterator of an asynchronous iterable is closed when the synchronous
+  mapping function throws.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    b. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+    ...
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+let closed = false;
+const iterator = {
+  next() {
+    return Promise.resolve({ value: 1, done: false });
+  },
+  return() {
+    closed = true;
+    return Promise.resolve({ done: true });
+  },
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+
+asyncTest(async () => {
+  await assert.throwsAsync(Error, () => Array.fromAsync(iterator, (val) => {
+    assert.sameValue(val, 1, "mapfn receives value from iterator");
+    throw new Error("mapfn throws");
+  }), "sync mapfn throwing should cause fromAsync to reject");
+  assert(closed, "sync mapfn throwing should close iterator")
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-sync-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-sync-iterator.js
new file mode 100644
index 0000000000..3ea9e73e6d
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws-close-sync-iterator.js
@@ -0,0 +1,40 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The iterator of a synchronous iterable is closed when the synchronous mapping
+  function throws.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    b. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+    ...
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+let closed = false;
+const iterator = {
+  next() {
+    return { value: 1, done: false };
+  },
+  return() {
+    closed = true;
+    return { done: true };
+  },
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+
+asyncTest(async () => {
+  await assert.throwsAsync(Error, () => Array.fromAsync(iterator, (val) => {
+    assert.sameValue(val, 1, "mapfn receives value from iterator");
+    throw new Error("mapfn throws");
+  }), "sync mapfn throwing should cause fromAsync to reject");
+  assert(closed, "sync mapfn throwing should close iterator")
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws.js b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws.js
new file mode 100644
index 0000000000..cea2ff3a60
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/mapfn-sync-throws.js
@@ -0,0 +1,23 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  The output promise rejects if the synchronous mapping function throws.
+info: |
+  3.j.ii.6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+    b. IfAbruptCloseAsyncIterator(_mappedValue_, _iteratorRecord_).
+    ...
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await assert.throwsAsync(Test262Error, () => Array.fromAsync([1, 2, 3], () => {
+    throw new Test262Error("mapfn throws");
+  }), "sync mapfn throwing should cause fromAsync to reject");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/name.js b/js/src/tests/test262/built-ins/Array/fromAsync/name.js
new file mode 100644
index 0000000000..e335122192
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/name.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Value and property descriptor of Array.fromAsync.name
+info: |
+  Every built-in function object, including constructors, has a *"name"*
+  property whose value is a String. Unless otherwise specified, this value is
+  the name that is given to the function in this specification. [...]
+  For functions that are specified as properties of objects, the name value is
+  the property name string used to access the function.
+
+  Unless otherwise specified, the *"name"* property of a built-in function
+  object has the attributes { [[Writable]]: *false*, [[Enumerable]]: *false*,
+  [[Configurable]]: true }.
+includes: [propertyHelper.js]
+features: [Array.fromAsync]
+---*/
+
+verifyProperty(Array.fromAsync, "name", {
+  value: "fromAsync",
+  writable: false,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-does-not-use-array-prototype.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-does-not-use-array-prototype.js
new file mode 100644
index 0000000000..ba639aae1b
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-does-not-use-array-prototype.js
@@ -0,0 +1,47 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable input does not use Array.prototype
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+const arrayIterator = [].values();
+const IntrinsicArrayIteratorPrototype =
+Object.getPrototypeOf(arrayIterator);
+const intrinsicArrayIteratorPrototypeNext =
+IntrinsicArrayIteratorPrototype.next;
+
+try {
+// Temporarily mutate the array iterator prototype to have an invalid
+// “next” method. Just like Array.from, the fromAsync function should
+// still work on non-iterable arraylike arguments.
+IntrinsicArrayIteratorPrototype.next = function fakeNext () {
+  throw new Test262Error(
+    'This fake next function should not be called; ' +
+    'instead, each element should have been directly accessed.',
+  );
+};
+
+const expected = [ 0, 1, 2 ];
+const input = {
+  length: 3,
+  0: 0,
+  1: 1,
+  2: 2,
+};
+const output = await Array.fromAsync(input);
+assert.compareArray(output, expected);
+}
+
+finally {
+// Reset the intrinsic array iterator
+IntrinsicArrayIteratorPrototype.next =
+  intrinsicArrayIteratorPrototypeNext;
+}
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-element-access-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-element-access-err.js
new file mode 100644
index 0000000000..edbf4de710
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-element-access-err.js
@@ -0,0 +1,22 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Result promise rejects if element access fails
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const input = {
+    length: 1,
+    get 0 () {
+      throw new Test262Error;
+    },
+  };
+  const outputPromise = Array.fromAsync(input);
+  assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-awaits-callback-result-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-awaits-callback-result-once.js
new file mode 100644
index 0000000000..9bb78973a0
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-awaits-callback-result-once.js
@@ -0,0 +1,33 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable input with thenable result with async mapped awaits each callback result once.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  let awaitCounter = 0;
+  const input = {
+    length: 3,
+    0: 0,
+    1: Promise.resolve(1),
+    2: Promise.resolve(2),
+    3: Promise.resolve(3), // This is ignored because the length is 3.
+  };
+  await Array.fromAsync(input, async v => {
+    return {
+      // This “then” method should occur three times:
+      // one for each value from the input.
+      then (resolve, reject) {
+        awaitCounter ++;
+        resolve(v);
+      },
+    };
+  });
+  assert.sameValue(awaitCounter, 3);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-callback-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-callback-err.js
new file mode 100644
index 0000000000..edc811b792
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-async-mapped-callback-err.js
@@ -0,0 +1,28 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable input with thenable result promise rejects if async map function callback throws. 
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const inputThenable = {
+    then (resolve, reject) {
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  const outputPromise = Array.fromAsync(input, async v => {
+    throw new Test262Error;
+  });
+  assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-element-rejects.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-element-rejects.js
new file mode 100644
index 0000000000..f7b63c219e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-element-rejects.js
@@ -0,0 +1,27 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable input with thenable result promise rejects if thenable element rejects.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const expected = [ expectedValue ];
+  const inputThenable = {
+    then (resolve, reject) {
+      reject(new Test262Error);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  const output = Array.fromAsync(input);
+  await assert.throwsAsync(Test262Error, () => output);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-sync-mapped-callback-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-sync-mapped-callback-err.js
new file mode 100644
index 0000000000..c1543fe582
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable-sync-mapped-callback-err.js
@@ -0,0 +1,22 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non iterable result promise rejects if sync map function callback throws.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const input = {
+    length: 1,
+    0: 0,
+  };
+  const outputPromise = Array.fromAsync(input, v => {
+    throw new Test262Error;
+  });
+  assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable.js
new file mode 100644
index 0000000000..f37f8d01f5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input-with-thenable.js
@@ -0,0 +1,25 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Non iterable input with thenables is transferred to the output array.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expected = [ 0, 1, 2 ];
+  const input = {
+    length: 3,
+    0: 0,
+    1: Promise.resolve(1),
+    2: Promise.resolve(2),
+    3: Promise.resolve(3), // This is ignored because the length is 3.
+  };
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input.js
new file mode 100644
index 0000000000..3e0fd5994f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-input.js
@@ -0,0 +1,25 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Non iterable input without thenables is transferred to the output array.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expected = [ 0, 1, 2 ];
+  const input = {
+    length: 3,
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3, // This is ignored because the length is 3.
+  };
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-sync-mapped-callback-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-sync-mapped-callback-err.js
new file mode 100644
index 0000000000..72f48cce56
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-sync-mapped-callback-err.js
@@ -0,0 +1,28 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non iterable input with thenables awaits each input once without mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const inputThenable = {
+    then (resolve, reject) {
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  const outputPromise = Array.fromAsync(input, v => {
+    throw new Test262Error;
+  });
+  await assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-non-promise-thenable.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-non-promise-thenable.js
new file mode 100644
index 0000000000..89388e2790
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-non-promise-thenable.js
@@ -0,0 +1,27 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non iterable input with non-promise thenables works.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const expected = [ expectedValue ];
+  const inputThenable = {
+    then (resolve, reject) {
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-async-mapped-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-async-mapped-awaits-once.js
new file mode 100644
index 0000000000..080a9e6300
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-async-mapped-awaits-once.js
@@ -0,0 +1,30 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Non-iterable input with thenables awaits each input once without mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const expected = [ expectedValue ];
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter++;
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  await Array.fromAsync(input, async v => v);
+  assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-awaits-once.js
new file mode 100644
index 0000000000..89dbdc5c86
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-awaits-once.js
@@ -0,0 +1,28 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable with thenables awaits each input value once without mapping callback.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter ++;
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+ await Array.fromAsync(input);
+ assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-sync-mapped-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-sync-mapped-awaits-once.js
new file mode 100644
index 0000000000..a410783234
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-sync-mapped-awaits-once.js
@@ -0,0 +1,29 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Non-iterable input with thenables awaits each input once with mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter++;
+      resolve(expectedValue);
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  await Array.fromAsync(input, v => v);
+  assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-then-method-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-then-method-err.js
new file mode 100644
index 0000000000..4175c353f2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/non-iterable-with-thenable-then-method-err.js
@@ -0,0 +1,25 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Non-iterable input with thenable result promise is rejected if element's then method throws.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const inputThenable = {
+    then (resolve, reject) {
+      throw new Test262Error;
+    },
+  };
+  const input = {
+    length: 1,
+    0: inputThenable,
+  };
+  const outputPromise = Array.fromAsync(input);
+  assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/not-a-constructor.js b/js/src/tests/test262/built-ins/Array/fromAsync/not-a-constructor.js
new file mode 100644
index 0000000000..428ea909e6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/not-a-constructor.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Array.fromAsync is not a constructor
+info: |
+  Built-in function objects that are not identified as constructors do not
+  implement the [[Construct]] internal method unless otherwise specified in the
+  description of a particular function.
+includes: [isConstructor.js]
+features: [Array.fromAsync, Reflect.construct]
+---*/
+
+assert(!isConstructor(Array.fromAsync), "Array.fromAsync is not a constructor");
+
+assert.throws(TypeError, () => new Array.fromAsync(), "Array.fromAsync throws when constructed");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/prop-desc.js b/js/src/tests/test262/built-ins/Array/fromAsync/prop-desc.js
new file mode 100644
index 0000000000..803cc989dd
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/prop-desc.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Type and property descriptor of Array.fromAsync
+info: |
+  Every other data property described in clauses 19 through 28 and in Annex B.2
+  has the attributes { [[Writable]]: *true*, [[Enumerable]]: *false*,
+  [[Configurable]]: *true* } unless otherwise specified.
+includes: [propertyHelper.js]
+features: [Array.fromAsync]
+---*/
+
+assert.sameValue(typeof Array.fromAsync, "function", "Array.fromAsync is callable");
+
+verifyProperty(Array, 'fromAsync', {
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/returned-promise-resolves-to-array.js b/js/src/tests/test262/built-ins/Array/fromAsync/returned-promise-resolves-to-array.js
new file mode 100644
index 0000000000..b6ccf790af
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/returned-promise-resolves-to-array.js
@@ -0,0 +1,23 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Array.fromAsync returns a Promise that resolves to an Array in the normal case
+info: |
+  1. Let _C_ be the *this* value.
+  ...
+  3.e. If IsConstructor(_C_) is *true*, then
+    i. Let _A_ be ? Construct(_C_).
+features: [Array.fromAsync]
+flags: [async]
+includes: [asyncHelpers.js]
+---*/
+
+asyncTest(async function () {
+  const promise = Array.fromAsync([0, 1, 2]);
+  const array = await promise;
+  assert(Array.isArray(array), "Array.fromAsync returns a Promise that resolves to an Array");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/returns-promise.js b/js/src/tests/test262/built-ins/Array/fromAsync/returns-promise.js
new file mode 100644
index 0000000000..a8b456d66e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/returns-promise.js
@@ -0,0 +1,36 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Array.fromAsync returns a Promise
+info: |
+  5. Return _promiseCapability_.[[Promise]].
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  let p = Array.fromAsync([0, 1, 2]);
+
+  assert(p instanceof Promise, "Array.fromAsync returns a Promise");
+  assert.sameValue(
+    Object.getPrototypeOf(p),
+    Promise.prototype,
+    "Array.fromAsync returns an object with prototype Promise.prototype"
+  );
+
+  p = Array.fromAsync([0, 1, 2], () => {
+    throw new Test262Error("this will make the Promise reject");
+  })
+  assert(p instanceof Promise, "Array.fromAsync returns a Promise even on error");
+  assert.sameValue(
+    Object.getPrototypeOf(p),
+    Promise.prototype,
+    "Array.fromAsync returns an object with prototype Promise.prototype even on error"
+  );
+
+  await assert.throwsAsync(Test262Error, () => p, "Prevent unhandled rejection");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/shell.js b/js/src/tests/test262/built-ins/Array/fromAsync/shell.js
new file mode 100644
index 0000000000..3489e7ef68
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/shell.js
@@ -0,0 +1,2271 @@
+// GENERATED, DO NOT EDIT
+// file: asyncHelpers.js
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    A collection of assertion and wrapper functions for testing asynchronous built-ins.
+defines: [asyncTest]
+---*/
+
+function asyncTest(testFunc) {
+  if (!Object.hasOwn(globalThis, "$DONE")) {
+    throw new Test262Error("asyncTest called without async flag");
+  }
+  if (typeof testFunc !== "function") {
+    $DONE(new Test262Error("asyncTest called with non-function argument"));
+    return;
+  }
+  try {
+    testFunc().then(
+      function () {
+        $DONE();
+      },
+      function (error) {
+        $DONE(error);
+      }
+    );
+  } catch (syncError) {
+    $DONE(syncError);
+  }
+}
+
+assert.throwsAsync = async function (expectedErrorConstructor, func, message) {
+  var innerThenable;
+  if (message === undefined) {
+    message = "";
+  } else {
+    message += " ";
+  }
+  if (typeof func === "function") {
+    try {
+      innerThenable = func();
+      if (
+        innerThenable === null ||
+        typeof innerThenable !== "object" ||
+        typeof innerThenable.then !== "function"
+      ) {
+        message +=
+          "Expected to obtain an inner promise that would reject with a" +
+          expectedErrorConstructor.name +
+          " but result was not a thenable";
+        throw new Test262Error(message);
+      }
+    } catch (thrown) {
+      message +=
+        "Expected a " +
+        expectedErrorConstructor.name +
+        " to be thrown asynchronously but an exception was thrown synchronously while obtaining the inner promise";
+      throw new Test262Error(message);
+    }
+  } else {
+    message +=
+      "assert.throwsAsync called with an argument that is not a function";
+    throw new Test262Error(message);
+  }
+
+  try {
+    return innerThenable.then(
+      function () {
+        message +=
+          "Expected a " +
+          expectedErrorConstructor.name +
+          " to be thrown asynchronously but no exception was thrown at all";
+        throw new Test262Error(message);
+      },
+      function (thrown) {
+        var expectedName, actualName;
+        if (typeof thrown !== "object" || thrown === null) {
+          message += "Thrown value was not an object!";
+          throw new Test262Error(message);
+        } else if (thrown.constructor !== expectedErrorConstructor) {
+          expectedName = expectedErrorConstructor.name;
+          actualName = thrown.constructor.name;
+          if (expectedName === actualName) {
+            message +=
+              "Expected a " +
+              expectedName +
+              " but got a different error constructor with the same name";
+          } else {
+            message +=
+              "Expected a " + expectedName + " but got a " + actualName;
+          }
+          throw new Test262Error(message);
+        }
+      }
+    );
+  } catch (thrown) {
+    if (typeof thrown !== "object" || thrown === null) {
+      message +=
+        "Expected a " +
+        expectedErrorConstructor.name +
+        " to be thrown asynchronously but innerThenable synchronously threw a value that was not an object ";
+    } else {
+      message +=
+        "Expected a " +
+        expectedErrorConstructor.name +
+        " to be thrown asynchronously but a " +
+        thrown.constructor.name +
+        " was thrown synchronously";
+    }
+    throw new Test262Error(message);
+  }
+};
+
+// file: temporalHelpers.js
+// Copyright (C) 2021 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    This defines helper objects and functions for testing Temporal.
+defines: [TemporalHelpers]
+features: [Symbol.species, Symbol.iterator, Temporal]
+---*/
+
+const ASCII_IDENTIFIER = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/u;
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey))) {
+        if (ASCII_IDENTIFIER.test(propertyKey)) {
+          return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+        }
+        return `${objectName}['${propertyKey.replace(/'/g, "\\'")}']`
+      }
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+const SKIP_SYMBOL = Symbol("Skip");
+
+var TemporalHelpers = {
+  /*
+   * Codes and maximum lengths of months in the ISO 8601 calendar.
+   */
+  ISOMonths: [
+    { month: 1, monthCode: "M01", daysInMonth: 31 },
+    { month: 2, monthCode: "M02", daysInMonth: 29 },
+    { month: 3, monthCode: "M03", daysInMonth: 31 },
+    { month: 4, monthCode: "M04", daysInMonth: 30 },
+    { month: 5, monthCode: "M05", daysInMonth: 31 },
+    { month: 6, monthCode: "M06", daysInMonth: 30 },
+    { month: 7, monthCode: "M07", daysInMonth: 31 },
+    { month: 8, monthCode: "M08", daysInMonth: 31 },
+    { month: 9, monthCode: "M09", daysInMonth: 30 },
+    { month: 10, monthCode: "M10", daysInMonth: 31 },
+    { month: 11, monthCode: "M11", daysInMonth: 30 },
+    { month: 12, monthCode: "M12", daysInMonth: 31 }
+  ],
+
+  /*
+   * assertDuration(duration, years, ...,  nanoseconds[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * an expected value.
+   */
+  assertDuration(duration, years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, hours, `${prefix}hours result:`);
+    assert.sameValue(duration.minutes, minutes, `${prefix}minutes result:`);
+    assert.sameValue(duration.seconds, seconds, `${prefix}seconds result:`);
+    assert.sameValue(duration.milliseconds, milliseconds, `${prefix}milliseconds result:`);
+    assert.sameValue(duration.microseconds, microseconds, `${prefix}microseconds result:`);
+    assert.sameValue(duration.nanoseconds, nanoseconds, `${prefix}nanoseconds result`);
+  },
+
+  /*
+   * assertDateDuration(duration, years, months, weeks, days, [, description]):
+   *
+   * Shorthand for asserting that each date field of a Temporal.Duration is
+   * equal to an expected value.
+   */
+  assertDateDuration(duration, years, months, weeks, days, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(duration instanceof Temporal.Duration, `${prefix}instanceof`);
+    assert.sameValue(duration.years, years, `${prefix}years result:`);
+    assert.sameValue(duration.months, months, `${prefix}months result:`);
+    assert.sameValue(duration.weeks, weeks, `${prefix}weeks result:`);
+    assert.sameValue(duration.days, days, `${prefix}days result:`);
+    assert.sameValue(duration.hours, 0, `${prefix}hours result should be zero:`);
+    assert.sameValue(duration.minutes, 0, `${prefix}minutes result should be zero:`);
+    assert.sameValue(duration.seconds, 0, `${prefix}seconds result should be zero:`);
+    assert.sameValue(duration.milliseconds, 0, `${prefix}milliseconds result should be zero:`);
+    assert.sameValue(duration.microseconds, 0, `${prefix}microseconds result should be zero:`);
+    assert.sameValue(duration.nanoseconds, 0, `${prefix}nanoseconds result should be zero:`);
+  },
+
+  /*
+   * assertDurationsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.Duration is equal to
+   * the corresponding field in another Temporal.Duration.
+   */
+  assertDurationsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Duration, `${prefix}expected value should be a Temporal.Duration`);
+    TemporalHelpers.assertDuration(actual, expected.years, expected.months, expected.weeks, expected.days, expected.hours, expected.minutes, expected.seconds, expected.milliseconds, expected.microseconds, expected.nanoseconds, description);
+  },
+
+  /*
+   * assertInstantsEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.Instants are of the correct type
+   * and equal according to their equals() methods.
+   */
+  assertInstantsEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.Instant, `${prefix}expected value should be a Temporal.Instant`);
+    assert(actual instanceof Temporal.Instant, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainDate(date, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDate is equal to
+   * an expected value. (Except the `calendar` property, since callers may want
+   * to assert either object equality with an object they put in there, or the
+   * value of date.calendarId.)
+   */
+  assertPlainDate(date, year, month, monthCode, day, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(date instanceof Temporal.PlainDate, `${prefix}instanceof`);
+    assert.sameValue(date.era, era, `${prefix}era result:`);
+    assert.sameValue(date.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(date.year, year, `${prefix}year result:`);
+    assert.sameValue(date.month, month, `${prefix}month result:`);
+    assert.sameValue(date.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(date.day, day, `${prefix}day result:`);
+  },
+
+  /*
+   * assertPlainDateTime(datetime, year, ..., nanosecond[, description[, era, eraYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainDateTime is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of datetime.calendarId.)
+   */
+  assertPlainDateTime(datetime, year, month, monthCode, day, hour, minute, second, millisecond, microsecond, nanosecond, description = "", era = undefined, eraYear = undefined) {
+    const prefix = description ? `${description}: ` : "";
+    assert(datetime instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert.sameValue(datetime.era, era, `${prefix}era result:`);
+    assert.sameValue(datetime.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(datetime.year, year, `${prefix}year result:`);
+    assert.sameValue(datetime.month, month, `${prefix}month result:`);
+    assert.sameValue(datetime.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(datetime.day, day, `${prefix}day result:`);
+    assert.sameValue(datetime.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(datetime.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(datetime.second, second, `${prefix}second result:`);
+    assert.sameValue(datetime.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(datetime.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(datetime.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their calendar internal slots are the same value.
+   */
+  assertPlainDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainDateTime, `${prefix}expected value should be a Temporal.PlainDateTime`);
+    assert(actual instanceof Temporal.PlainDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertPlainMonthDay(monthDay, monthCode, day[, description [, referenceISOYear]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainMonthDay is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of monthDay.calendarId().)
+   */
+  assertPlainMonthDay(monthDay, monthCode, day, description = "", referenceISOYear = 1972) {
+    const prefix = description ? `${description}: ` : "";
+    assert(monthDay instanceof Temporal.PlainMonthDay, `${prefix}instanceof`);
+    assert.sameValue(monthDay.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(monthDay.day, day, `${prefix}day result:`);
+    assert.sameValue(monthDay.getISOFields().isoYear, referenceISOYear, `${prefix}referenceISOYear result:`);
+  },
+
+  /*
+   * assertPlainTime(time, hour, ..., nanosecond[, description]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainTime is equal to
+   * an expected value.
+   */
+  assertPlainTime(time, hour, minute, second, millisecond, microsecond, nanosecond, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(time instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert.sameValue(time.hour, hour, `${prefix}hour result:`);
+    assert.sameValue(time.minute, minute, `${prefix}minute result:`);
+    assert.sameValue(time.second, second, `${prefix}second result:`);
+    assert.sameValue(time.millisecond, millisecond, `${prefix}millisecond result:`);
+    assert.sameValue(time.microsecond, microsecond, `${prefix}microsecond result:`);
+    assert.sameValue(time.nanosecond, nanosecond, `${prefix}nanosecond result:`);
+  },
+
+  /*
+   * assertPlainTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.PlainTimes are of the correct
+   * type and equal according to their equals() methods.
+   */
+  assertPlainTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.PlainTime, `${prefix}expected value should be a Temporal.PlainTime`);
+    assert(actual instanceof Temporal.PlainTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+  },
+
+  /*
+   * assertPlainYearMonth(yearMonth, year, month, monthCode[, description[, era, eraYear, referenceISODay]]):
+   *
+   * Shorthand for asserting that each field of a Temporal.PlainYearMonth is
+   * equal to an expected value. (Except the `calendar` property, since callers
+   * may want to assert either object equality with an object they put in there,
+   * or the value of yearMonth.calendarId.)
+   */
+  assertPlainYearMonth(yearMonth, year, month, monthCode, description = "", era = undefined, eraYear = undefined, referenceISODay = 1) {
+    const prefix = description ? `${description}: ` : "";
+    assert(yearMonth instanceof Temporal.PlainYearMonth, `${prefix}instanceof`);
+    assert.sameValue(yearMonth.era, era, `${prefix}era result:`);
+    assert.sameValue(yearMonth.eraYear, eraYear, `${prefix}eraYear result:`);
+    assert.sameValue(yearMonth.year, year, `${prefix}year result:`);
+    assert.sameValue(yearMonth.month, month, `${prefix}month result:`);
+    assert.sameValue(yearMonth.monthCode, monthCode, `${prefix}monthCode result:`);
+    assert.sameValue(yearMonth.getISOFields().isoDay, referenceISODay, `${prefix}referenceISODay result:`);
+  },
+
+  /*
+   * assertZonedDateTimesEqual(actual, expected[, description]):
+   *
+   * Shorthand for asserting that two Temporal.ZonedDateTimes are of the correct
+   * type, equal according to their equals() methods, and additionally that
+   * their time zones and calendar internal slots are the same value.
+   */
+  assertZonedDateTimesEqual(actual, expected, description = "") {
+    const prefix = description ? `${description}: ` : "";
+    assert(expected instanceof Temporal.ZonedDateTime, `${prefix}expected value should be a Temporal.ZonedDateTime`);
+    assert(actual instanceof Temporal.ZonedDateTime, `${prefix}instanceof`);
+    assert(actual.equals(expected), `${prefix}equals method`);
+    assert.sameValue(actual.timeZone, expected.timeZone, `${prefix}time zone same value:`);
+    assert.sameValue(
+      actual.getISOFields().calendar,
+      expected.getISOFields().calendar,
+      `${prefix}calendar same value:`
+    );
+  },
+
+  /*
+   * assertUnreachable(description):
+   *
+   * Helper for asserting that code is not executed. This is useful for
+   * assertions that methods of user calendars and time zones are not called.
+   */
+  assertUnreachable(description) {
+    let message = "This code should not be executed";
+    if (description) {
+      message = `${message}: ${description}`;
+    }
+    throw new Test262Error(message);
+  },
+
+  /*
+   * checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls):
+   *
+   * When an options object with a largestUnit property is synthesized inside
+   * Temporal and passed to user code such as calendar.dateUntil(), the value of
+   * the largestUnit property should be in the singular form, even if the input
+   * was given in the plural form.
+   * (This doesn't apply when the options object is passed through verbatim.)
+   *
+   * func(calendar, largestUnit, index) is the operation under test. It's called
+   * with an instance of a calendar that keeps track of which largestUnit is
+   * passed to dateUntil(), each key of expectedLargestUnitCalls in turn, and
+   * the key's numerical index in case the function needs to generate test data
+   * based on the index. At the end, the actual values passed to dateUntil() are
+   * compared with the array values of expectedLargestUnitCalls.
+   */
+  checkCalendarDateUntilLargestUnitSingular(func, expectedLargestUnitCalls) {
+    const actual = [];
+
+    class DateUntilOptionsCalendar extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateUntil(earlier, later, options) {
+        actual.push(options.largestUnit);
+        return super.dateUntil(earlier, later, options);
+      }
+
+      toString() {
+        return "date-until-options";
+      }
+    }
+
+    const calendar = new DateUntilOptionsCalendar();
+    Object.entries(expectedLargestUnitCalls).forEach(([largestUnit, expected], index) => {
+      func(calendar, largestUnit, index);
+      assert.compareArray(actual, expected, `largestUnit passed to calendar.dateUntil() for largestUnit ${largestUnit}`);
+      actual.splice(0); // empty it for the next check
+    });
+  },
+
+  /*
+   * checkPlainDateTimeConversionFastPath(func):
+   *
+   * ToTemporalDate and ToTemporalTime should both, if given a
+   * Temporal.PlainDateTime instance, convert to the desired type by reading the
+   * PlainDateTime's internal slots, rather than calling any getters.
+   *
+   * func(datetime, calendar) is the actual operation to test, that must
+   * internally call the abstract operation ToTemporalDate or ToTemporalTime.
+   * It is passed a Temporal.PlainDateTime instance, as well as the instance's
+   * calendar object (so that it doesn't have to call the calendar getter itself
+   * if it wants to make any assertions about the calendar.)
+   */
+  checkPlainDateTimeConversionFastPath(func, message = "checkPlainDateTimeConversionFastPath") {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const datetime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDateTime.prototype);
+    ["year", "month", "monthCode", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(datetime, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return {
+            toString() {
+              actual.push(`toString ${formatPropertyName(property)}`);
+              return value.toString();
+            },
+            valueOf() {
+              actual.push(`valueOf ${formatPropertyName(property)}`);
+              return value;
+            },
+          };
+        },
+      });
+    });
+    Object.defineProperty(datetime, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(datetime, calendar);
+    assert.compareArray(actual, expected, `${message}: property getters not called`);
+  },
+
+  /*
+   * Check that an options bag that accepts units written in the singular form,
+   * also accepts the same units written in the plural form.
+   * func(unit) should call the method with the appropriate options bag
+   * containing unit as a value. This will be called twice for each element of
+   * validSingularUnits, once with singular and once with plural, and the
+   * results of each pair should be the same (whether a Temporal object or a
+   * primitive value.)
+   */
+  checkPluralUnitsAccepted(func, validSingularUnits) {
+    const plurals = {
+      year: 'years',
+      month: 'months',
+      week: 'weeks',
+      day: 'days',
+      hour: 'hours',
+      minute: 'minutes',
+      second: 'seconds',
+      millisecond: 'milliseconds',
+      microsecond: 'microseconds',
+      nanosecond: 'nanoseconds',
+    };
+
+    validSingularUnits.forEach((unit) => {
+      const singularValue = func(unit);
+      const pluralValue = func(plurals[unit]);
+      const desc = `Plural ${plurals[unit]} produces the same result as singular ${unit}`;
+      if (singularValue instanceof Temporal.Duration) {
+        TemporalHelpers.assertDurationsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.Instant) {
+        TemporalHelpers.assertInstantsEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainDateTime) {
+        TemporalHelpers.assertPlainDateTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.PlainTime) {
+        TemporalHelpers.assertPlainTimesEqual(pluralValue, singularValue, desc);
+      } else if (singularValue instanceof Temporal.ZonedDateTime) {
+        TemporalHelpers.assertZonedDateTimesEqual(pluralValue, singularValue, desc);
+      } else {
+        assert.sameValue(pluralValue, singularValue);
+      }
+    });
+  },
+
+  /*
+   * checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc):
+   *
+   * Checks the type handling of the roundingIncrement option.
+   * checkFunc(roundingIncrement) is a function which takes the value of
+   * roundingIncrement to test, and calls the method under test with it,
+   * returning the result. assertTrueResultFunc(result, description) should
+   * assert that result is the expected result with roundingIncrement: true, and
+   * assertObjectResultFunc(result, description) should assert that result is
+   * the expected result with roundingIncrement being an object with a valueOf()
+   * method.
+   */
+  checkRoundingIncrementOptionWrongType(checkFunc, assertTrueResultFunc, assertObjectResultFunc) {
+    // null converts to 0, which is out of range
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to either 0 or 1, and 1 is allowed
+    const trueResult = checkFunc(true);
+    assertTrueResultFunc(trueResult, "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols and BigInts cannot convert to numbers
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    assert.throws(TypeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their valueOf() methods when converting to a number
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      "get roundingIncrement.valueOf",
+      "call roundingIncrement.valueOf",
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, 2, "roundingIncrement");
+    const objectResult = checkFunc(observer);
+    assertObjectResultFunc(objectResult, "object with valueOf");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc):
+   *
+   * Checks the type handling of a string option, of which there are several in
+   * Temporal.
+   * propertyName is the name of the option, and value is the value that
+   * assertFunc should expect it to have.
+   * checkFunc(value) is a function which takes the value of the option to test,
+   * and calls the method under test with it, returning the result.
+   * assertFunc(result, description) should assert that result is the expected
+   * result with the option value being an object with a toString() method
+   * which returns the given value.
+   */
+  checkStringOptionWrongType(propertyName, value, checkFunc, assertFunc) {
+    // null converts to the string "null", which is an invalid string value
+    assert.throws(RangeError, () => checkFunc(null), "null");
+    // Booleans convert to the strings "true" or "false", which are invalid
+    assert.throws(RangeError, () => checkFunc(true), "true");
+    assert.throws(RangeError, () => checkFunc(false), "false");
+    // Symbols cannot convert to strings
+    assert.throws(TypeError, () => checkFunc(Symbol()), "symbol");
+    // Numbers convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2), "number");
+    // BigInts convert to strings which are invalid
+    assert.throws(RangeError, () => checkFunc(2n), "bigint");
+
+    // Objects prefer their toString() methods when converting to a string
+    assert.throws(RangeError, () => checkFunc({}), "plain object");
+
+    const expected = [
+      `get ${propertyName}.toString`,
+      `call ${propertyName}.toString`,
+    ];
+    const actual = [];
+    const observer = TemporalHelpers.toPrimitiveObserver(actual, value, propertyName);
+    const result = checkFunc(observer);
+    assertFunc(result, "object with toString");
+    assert.compareArray(actual, expected, "order of operations");
+  },
+
+  /*
+   * checkSubclassingIgnored(construct, constructArgs, method, methodArgs,
+   *   resultAssertions):
+   *
+   * Methods of Temporal classes that return a new instance of the same class,
+   * must not take the constructor of a subclass into account, nor the @@species
+   * property. This helper runs tests to ensure this.
+   *
+   * construct(...constructArgs) must yield a valid instance of the Temporal
+   * class. instance[method](...methodArgs) is the method call under test, which
+   * must also yield a valid instance of the same Temporal class, not a
+   * subclass. See below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnored(...args) {
+    this.checkSubclassConstructorNotObject(...args);
+    this.checkSubclassConstructorUndefined(...args);
+    this.checkSubclassConstructorThrows(...args);
+    this.checkSubclassConstructorNotCalled(...args);
+    this.checkSubclassSpeciesInvalidResult(...args);
+    this.checkSubclassSpeciesNotAConstructor(...args);
+    this.checkSubclassSpeciesNull(...args);
+    this.checkSubclassSpeciesUndefined(...args);
+    this.checkSubclassSpeciesThrows(...args);
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the instance with
+   * various primitive values does not affect the returned new instance.
+   */
+  checkSubclassConstructorNotObject(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = value;
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+  },
+
+  /*
+   * Checks that replacing the 'constructor' property of the subclass with
+   * undefined does not affect the returned new instance.
+   */
+  checkSubclassConstructorUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = undefined;
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that making the 'constructor' property of the instance throw when
+   * called does not affect the returned new instance.
+   */
+  checkSubclassConstructorThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+    const instance = new construct(...constructArgs);
+    Object.defineProperty(instance, "constructor", {
+      get() {
+        throw new CustomError();
+      }
+    });
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Checks that when subclassing, the subclass constructor is not called by
+   * the method under test.
+   */
+  checkSubclassConstructorNotCalled(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's a
+   * constructor that returns a non-object value.
+   */
+  checkSubclassSpeciesInvalidResult(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: function() {
+          return value;
+        },
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's not a
+   * constructor.
+   */
+  checkSubclassSpeciesNotAConstructor(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const instance = new construct(...constructArgs);
+      instance.constructor = {
+        [Symbol.species]: value,
+      };
+      const result = instance[method](...methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype, description);
+      resultAssertions(result);
+    }
+
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "Symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "plain object");
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's null.
+   */
+  checkSubclassSpeciesNull(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: null,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it's
+   * undefined.
+   */
+  checkSubclassSpeciesUndefined(construct, constructArgs, method, methodArgs, resultAssertions) {
+    let called = 0;
+
+    class MySubclass extends construct {
+      constructor() {
+        ++called;
+        super(...constructArgs);
+      }
+    }
+
+    const instance = new MySubclass();
+    assert.sameValue(called, 1);
+
+    MySubclass.prototype.constructor = {
+      [Symbol.species]: undefined,
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(called, 1);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that the constructor's @@species property is ignored when it throws,
+   * i.e. it is not called at all.
+   */
+  checkSubclassSpeciesThrows(construct, constructArgs, method, methodArgs, resultAssertions) {
+    function CustomError() {}
+
+    const instance = new construct(...constructArgs);
+    instance.constructor = {
+      get [Symbol.species]() {
+        throw new CustomError();
+      },
+    };
+
+    const result = instance[method](...methodArgs);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+  },
+
+  /*
+   * checkSubclassingIgnoredStatic(construct, method, methodArgs, resultAssertions):
+   *
+   * Static methods of Temporal classes that return a new instance of the class,
+   * must not use the this-value as a constructor. This helper runs tests to
+   * ensure this.
+   *
+   * construct[method](...methodArgs) is the static method call under test, and
+   * must yield a valid instance of the Temporal class, not a subclass. See
+   * below for the individual tests that this runs.
+   * resultAssertions() is a function that performs additional assertions on the
+   * instance returned by the method under test.
+   */
+  checkSubclassingIgnoredStatic(...args) {
+    this.checkStaticInvalidReceiver(...args);
+    this.checkStaticReceiverNotCalled(...args);
+    this.checkThisValueNotCalled(...args);
+  },
+
+  /*
+   * Check that calling the static method with a receiver that's not callable,
+   * still calls the intrinsic constructor.
+   */
+  checkStaticInvalidReceiver(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const result = construct[method].apply(value, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that calling the static method with a receiver that returns a value
+   * that's not callable, still calls the intrinsic constructor.
+   */
+  checkStaticReceiverNotCalled(construct, method, methodArgs, resultAssertions) {
+    function check(value, description) {
+      const receiver = function () {
+        return value;
+      };
+      const result = construct[method].apply(receiver, methodArgs);
+      assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+      resultAssertions(result);
+    }
+
+    check(undefined, "undefined");
+    check(null, "null");
+    check(true, "true");
+    check("test", "string");
+    check(Symbol(), "symbol");
+    check(7, "number");
+    check(7n, "bigint");
+    check({}, "Non-callable object");
+  },
+
+  /*
+   * Check that the receiver isn't called.
+   */
+  checkThisValueNotCalled(construct, method, methodArgs, resultAssertions) {
+    let called = false;
+
+    class MySubclass extends construct {
+      constructor(...args) {
+        called = true;
+        super(...args);
+      }
+    }
+
+    const result = MySubclass[method](...methodArgs);
+    assert.sameValue(called, false);
+    assert.sameValue(Object.getPrototypeOf(result), construct.prototype);
+    resultAssertions(result);
+  },
+
+  /*
+   * Check that any iterable returned from a custom time zone's
+   * getPossibleInstantsFor() method is exhausted.
+   * The custom time zone object is passed in to func().
+   * expected is an array of strings representing the expected calls to the
+   * getPossibleInstantsFor() method. The PlainDateTimes that it is called with,
+   * are compared (using their toString() results) with the array.
+   */
+  checkTimeZonePossibleInstantsIterable(func, expected) {
+    // A custom time zone that returns an iterable instead of an array from its
+    // getPossibleInstantsFor() method, and for testing purposes skips
+    // 00:00-01:00 UTC on January 1, 2030, and repeats 00:00-01:00 UTC+1 on
+    // January 3, 2030. Otherwise identical to the UTC time zone.
+    class TimeZonePossibleInstantsIterable extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+        this.getPossibleInstantsForCallCount = 0;
+        this.getPossibleInstantsForCalledWith = [];
+        this.getPossibleInstantsForReturns = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "Custom/Iterable";
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (Temporal.Instant.compare(instant, "2030-01-01T00:00Z") >= 0 &&
+          Temporal.Instant.compare(instant, "2030-01-03T01:00Z") < 0) {
+          return 3600_000_000_000;
+        } else {
+          return 0;
+        }
+      }
+
+      getPossibleInstantsFor(dateTime) {
+        this.getPossibleInstantsForCallCount++;
+        this.getPossibleInstantsForCalledWith.push(dateTime);
+
+        // Fake DST transition
+        let retval = super.getPossibleInstantsFor(dateTime);
+        if (dateTime.toPlainDate().equals("2030-01-01") && dateTime.hour === 0) {
+          retval = [];
+        } else if (dateTime.toPlainDate().equals("2030-01-03") && dateTime.hour === 0) {
+          retval.push(retval[0].subtract({ hours: 1 }));
+        } else if (dateTime.year === 2030 && dateTime.month === 1 && dateTime.day >= 1 && dateTime.day <= 2) {
+          retval[0] = retval[0].subtract({ hours: 1 });
+        }
+
+        this.getPossibleInstantsForReturns.push(retval);
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.getPossibleInstantsForCallCount - 1,
+          timeZone: this,
+          *[Symbol.iterator]() {
+            yield* this.timeZone.getPossibleInstantsForReturns[this.callIndex];
+            this.timeZone.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+
+    const timeZone = new TimeZonePossibleInstantsIterable();
+    func(timeZone);
+
+    assert.sameValue(timeZone.getPossibleInstantsForCallCount, expected.length, "getPossibleInstantsFor() method called correct number of times");
+
+    for (let index = 0; index < expected.length; index++) {
+      assert.sameValue(timeZone.getPossibleInstantsForCalledWith[index].toString(), expected[index], "getPossibleInstantsFor() called with expected PlainDateTime");
+      assert(timeZone.iteratorExhausted[index], "iterated through the whole iterable");
+    }
+  },
+
+  /*
+   * Check that any calendar-carrying Temporal object has its [[Calendar]]
+   * internal slot read by ToTemporalCalendar, and does not fetch the calendar
+   * by calling getters.
+   * The custom calendar object is passed in to func() so that it can do its
+   * own additional assertions involving the calendar if necessary. (Sometimes
+   * there is nothing to assert as the calendar isn't stored anywhere that can
+   * be asserted about.)
+   */
+  checkToTemporalCalendarFastPath(func) {
+    class CalendarFastPathCheck extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      monthDayFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.monthDayFromFields(...args).getISOFields();
+        return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+      }
+
+      yearMonthFromFields(...args) {
+        const { isoYear, isoMonth, isoDay } = super.yearMonthFromFields(...args).getISOFields();
+        return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+      }
+
+      toString() {
+        return "fast-path-check";
+      }
+    }
+    const calendar = new CalendarFastPathCheck();
+
+    const plainDate = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const plainDateTime = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321, calendar);
+    const plainMonthDay = new Temporal.PlainMonthDay(5, 2, calendar);
+    const plainYearMonth = new Temporal.PlainYearMonth(2000, 5, calendar);
+    const zonedDateTime = new Temporal.ZonedDateTime(1_000_000_000_000_000_000n, "UTC", calendar);
+
+    [plainDate, plainDateTime, plainMonthDay, plainYearMonth, zonedDateTime].forEach((temporalObject) => {
+      const actual = [];
+      const expected = [];
+
+      Object.defineProperty(temporalObject, "calendar", {
+        get() {
+          actual.push("get calendar");
+          return calendar;
+        },
+      });
+
+      func(temporalObject, calendar);
+      assert.compareArray(actual, expected, "calendar getter not called");
+    });
+  },
+
+  checkToTemporalInstantFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const datetime = new Temporal.ZonedDateTime(1_000_000_000_987_654_321n, "UTC");
+    Object.defineProperty(datetime, 'toString', {
+      get() {
+        actual.push("get toString");
+        return function (options) {
+          actual.push("call toString");
+          return Temporal.ZonedDateTime.prototype.toString.call(this, options);
+        };
+      },
+    });
+
+    func(datetime);
+    assert.compareArray(actual, expected, "toString not called");
+  },
+
+  checkToTemporalPlainDateTimeFastPath(func) {
+    const actual = [];
+    const expected = [];
+
+    const calendar = new Temporal.Calendar("iso8601");
+    const date = new Temporal.PlainDate(2000, 5, 2, calendar);
+    const prototypeDescrs = Object.getOwnPropertyDescriptors(Temporal.PlainDate.prototype);
+    ["year", "month", "monthCode", "day"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          const value = prototypeDescrs[property].get.call(this);
+          return TemporalHelpers.toPrimitiveObserver(actual, value, property);
+        },
+      });
+    });
+    ["hour", "minute", "second", "millisecond", "microsecond", "nanosecond"].forEach((property) => {
+      Object.defineProperty(date, property, {
+        get() {
+          actual.push(`get ${formatPropertyName(property)}`);
+          return undefined;
+        },
+      });
+    });
+    Object.defineProperty(date, "calendar", {
+      get() {
+        actual.push("get calendar");
+        return calendar;
+      },
+    });
+
+    func(date, calendar);
+    assert.compareArray(actual, expected, "property getters not called");
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * fromFields methods are always called with a null-prototype fields object.
+   */
+  calendarCheckFieldsPrototypePollution() {
+    class CalendarCheckFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+      }
+
+      // toString must remain "iso8601", so that some methods don't throw due to
+      // incompatible calendars
+
+      dateFromFields(fields, options = {}) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "dateFromFields should be called with null-prototype fields object");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options = {}) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "yearMonthFromFields should be called with null-prototype fields object");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options = {}) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "monthDayFromFields should be called with null-prototype fields object");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+
+    return new CalendarCheckFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that the
+   * mergeFields() method is always called with null-prototype fields objects.
+   */
+  calendarCheckMergeFieldsPrototypePollution() {
+    class CalendarCheckMergeFieldsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-null-proto";
+      }
+
+      mergeFields(fields, additionalFields) {
+        this.mergeFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(fields), null, "mergeFields should be called with null-prototype fields object (first argument)");
+        assert.sameValue(Object.getPrototypeOf(additionalFields), null, "mergeFields should be called with null-prototype fields object (second argument)");
+        return super.mergeFields(fields, additionalFields);
+      }
+    }
+
+    return new CalendarCheckMergeFieldsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar used in prototype pollution checks. Verifies that methods
+   * are always called with a null-prototype options object.
+   */
+  calendarCheckOptionsPrototypePollution() {
+    class CalendarCheckOptionsPrototypePollution extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.yearMonthFromFieldsCallCount = 0;
+        this.dateUntilCallCount = 0;
+      }
+
+      toString() {
+        return "options-null-proto";
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "yearMonthFromFields should be called with null-prototype options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      dateUntil(one, two, options) {
+        this.dateUntilCallCount++;
+        assert.sameValue(Object.getPrototypeOf(options), null, "dateUntil should be called with null-prototype options");
+        return super.dateUntil(one, two, options);
+      }
+    }
+
+    return new CalendarCheckOptionsPrototypePollution();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with the
+   * options parameter having the value undefined.
+   */
+  calendarDateAddUndefinedOptions() {
+    class CalendarDateAddUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+      }
+
+      toString() {
+        return "dateadd-undef-options";
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert.sameValue(options, undefined, "dateAdd shouldn't be called with options");
+        return super.dateAdd(date, duration, options);
+      }
+    }
+    return new CalendarDateAddUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that asserts its dateAdd() method is called with a
+   * PlainDate instance. Optionally, it also asserts that the PlainDate instance
+   * is the specific object `this.specificPlainDate`, if it is set by the
+   * calling code.
+   */
+  calendarDateAddPlainDateInstance() {
+    class CalendarDateAddPlainDateInstance extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateAddCallCount = 0;
+        this.specificPlainDate = undefined;
+      }
+
+      toString() {
+        return "dateadd-plain-date-instance";
+      }
+
+      dateFromFields(...args) {
+        return super.dateFromFields(...args).withCalendar(this);
+      }
+
+      dateAdd(date, duration, options) {
+        this.dateAddCallCount++;
+        assert(date instanceof Temporal.PlainDate, "dateAdd() should be called with a PlainDate instance");
+        if (this.dateAddCallCount === 1 && this.specificPlainDate) {
+          assert.sameValue(date, this.specificPlainDate, `dateAdd() should be called first with the specific PlainDate instance ${this.specificPlainDate}`);
+        }
+        return super.dateAdd(date, duration, options).withCalendar(this);
+      }
+    }
+    return new CalendarDateAddPlainDateInstance();
+  },
+
+  /*
+   * A custom calendar that returns an iterable instead of an array from its
+   * fields() method, otherwise identical to the ISO calendar.
+   */
+  calendarFieldsIterable() {
+    class CalendarFieldsIterable extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.fieldsCallCount = 0;
+        this.fieldsCalledWith = [];
+        this.iteratorExhausted = [];
+      }
+
+      toString() {
+        return "fields-iterable";
+      }
+
+      fields(fieldNames) {
+        this.fieldsCallCount++;
+        this.fieldsCalledWith.push(fieldNames.slice());
+        this.iteratorExhausted.push(false);
+        return {
+          callIndex: this.fieldsCallCount - 1,
+          calendar: this,
+          *[Symbol.iterator]() {
+            yield* this.calendar.fieldsCalledWith[this.callIndex];
+            this.calendar.iteratorExhausted[this.callIndex] = true;
+          },
+        };
+      }
+    }
+    return new CalendarFieldsIterable();
+  },
+
+  /*
+   * A custom calendar that asserts its ...FromFields() methods are called with
+   * the options parameter having the value undefined.
+   */
+  calendarFromFieldsUndefinedOptions() {
+    class CalendarFromFieldsUndefinedOptions extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "from-fields-undef-options";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "dateFromFields shouldn't be called with options");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "yearMonthFromFields shouldn't be called with options");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        assert.sameValue(options, undefined, "monthDayFromFields shouldn't be called with options");
+        return super.monthDayFromFields(fields, options);
+      }
+    }
+    return new CalendarFromFieldsUndefinedOptions();
+  },
+
+  /*
+   * A custom calendar that modifies the fields object passed in to
+   * dateFromFields, sabotaging its time properties.
+   */
+  calendarMakeInfinityTime() {
+    class CalendarMakeInfinityTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        fields.hour = Infinity;
+        fields.minute = Infinity;
+        fields.second = Infinity;
+        fields.millisecond = Infinity;
+        fields.microsecond = Infinity;
+        fields.nanosecond = Infinity;
+        return retval;
+      }
+    }
+    return new CalendarMakeInfinityTime();
+  },
+
+  /*
+   * A custom calendar that defines getters on the fields object passed into
+   * dateFromFields that throw, sabotaging its time properties.
+   */
+  calendarMakeInvalidGettersTime() {
+    class CalendarMakeInvalidGettersTime extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+
+      dateFromFields(fields, options) {
+        const retval = super.dateFromFields(fields, options);
+        const throwingDescriptor = {
+          get() {
+            throw new Test262Error("reading a sabotaged time field");
+          },
+        };
+        Object.defineProperties(fields, {
+          hour: throwingDescriptor,
+          minute: throwingDescriptor,
+          second: throwingDescriptor,
+          millisecond: throwingDescriptor,
+          microsecond: throwingDescriptor,
+          nanosecond: throwingDescriptor,
+        });
+        return retval;
+      }
+    }
+    return new CalendarMakeInvalidGettersTime();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a proxy object with
+   * all of its Get and HasProperty operations observable, as well as adding a
+   * "shouldNotBeCopied": true property.
+   */
+  calendarMergeFieldsGetters() {
+    class CalendarMergeFieldsGetters extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+        this.mergeFieldsReturnOperations = [];
+      }
+
+      toString() {
+        return "merge-fields-getters";
+      }
+
+      dateFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        assert.sameValue(fields.shouldNotBeCopied, undefined, "extra fields should not be copied");
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields(fields, additionalFields) {
+        const retval = super.mergeFields(fields, additionalFields);
+        retval._calendar = this;
+        retval.shouldNotBeCopied = true;
+        return new Proxy(retval, {
+          get(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`get ${key}`);
+            const result = target[key];
+            if (result === undefined) {
+              return undefined;
+            }
+            return TemporalHelpers.toPrimitiveObserver(target._calendar.mergeFieldsReturnOperations, result, key);
+          },
+          has(target, key) {
+            target._calendar.mergeFieldsReturnOperations.push(`has ${key}`);
+            return key in target;
+          },
+        });
+      }
+    }
+    return new CalendarMergeFieldsGetters();
+  },
+
+  /*
+   * A custom calendar whose mergeFields() method returns a primitive value,
+   * given by @primitive, and which records the number of calls made to its
+   * dateFromFields(), yearMonthFromFields(), and monthDayFromFields() methods.
+   */
+  calendarMergeFieldsReturnsPrimitive(primitive) {
+    class CalendarMergeFieldsPrimitive extends Temporal.Calendar {
+      constructor(mergeFieldsReturnValue) {
+        super("iso8601");
+        this._mergeFieldsReturnValue = mergeFieldsReturnValue;
+        this.dateFromFieldsCallCount = 0;
+        this.monthDayFromFieldsCallCount = 0;
+        this.yearMonthFromFieldsCallCount = 0;
+      }
+
+      toString() {
+        return "merge-fields-primitive";
+      }
+
+      dateFromFields(fields, options) {
+        this.dateFromFieldsCallCount++;
+        return super.dateFromFields(fields, options);
+      }
+
+      yearMonthFromFields(fields, options) {
+        this.yearMonthFromFieldsCallCount++;
+        return super.yearMonthFromFields(fields, options);
+      }
+
+      monthDayFromFields(fields, options) {
+        this.monthDayFromFieldsCallCount++;
+        return super.monthDayFromFields(fields, options);
+      }
+
+      mergeFields() {
+        return this._mergeFieldsReturnValue;
+      }
+    }
+    return new CalendarMergeFieldsPrimitive(primitive);
+  },
+
+  /*
+   * A custom calendar whose fields() method returns the same value as the
+   * iso8601 calendar, with the addition of extraFields provided as parameter.
+   */
+  calendarWithExtraFields(fields) {
+    class CalendarWithExtraFields extends Temporal.Calendar {
+      constructor(extraFields) {
+        super("iso8601");
+        this._extraFields = extraFields;
+      }
+
+      fields(fieldNames) {
+        return super.fields(fieldNames).concat(this._extraFields);
+      }
+    }
+
+    return new CalendarWithExtraFields(fields);
+  },
+
+  /*
+   * crossDateLineTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single transition where the time zone moves from one side of the
+   * International Date Line to the other, for the purpose of testing time zone
+   * calculations without depending on system time zone data.
+   *
+   * The transition occurs at epoch second 1325239200 and goes from offset
+   * -10:00 to +14:00. In other words, the time zone skips the whole calendar
+   * day of 2011-12-30. This is the same as the real-life transition in the
+   * Pacific/Apia time zone.
+   */
+  crossDateLineTimeZone() {
+    const { compare } = Temporal.PlainDate;
+    const skippedDay = new Temporal.PlainDate(2011, 12, 30);
+    const transitionEpoch = 1325239200_000_000_000n;
+    const beforeOffset = new Temporal.TimeZone("-10:00");
+    const afterOffset = new Temporal.TimeZone("+14:00");
+
+    class CrossDateLineTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("+14:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) {
+          return beforeOffset.getOffsetNanosecondsFor(instant);
+        }
+        return afterOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        const comparison = compare(datetime.toPlainDate(), skippedDay);
+        if (comparison === 0) {
+          return [];
+        }
+        if (comparison < 0) {
+          return [beforeOffset.getInstantFor(datetime)];
+        }
+        return [afterOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < transitionEpoch) return new Temporal.Instant(transitionEpoch);
+        return null;
+      }
+
+      toString() {
+        return "Custom/Date_Line";
+      }
+    }
+    return new CrossDateLineTimeZone();
+  },
+
+  /*
+   * observeProperty(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls to its accessors to the array @calls.
+   */
+  observeProperty(calls, object, propertyName, value, objectName = "") {
+    Object.defineProperty(object, propertyName, {
+      get() {
+        calls.push(`get ${formatPropertyName(propertyName, objectName)}`);
+        return value;
+      },
+      set(v) {
+        calls.push(`set ${formatPropertyName(propertyName, objectName)}`);
+      }
+    });
+  },
+
+  /*
+   * observeMethod(calls, object, propertyName, value):
+   *
+   * Defines an own property @object.@propertyName with value @value, that
+   * will log any calls of @value to the array @calls.
+   */
+  observeMethod(calls, object, propertyName, objectName = "") {
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      calls.push(`call ${formatPropertyName(propertyName, objectName)}`);
+      return method.apply(object, arguments);
+    };
+  },
+
+  /*
+   * Used for substituteMethod to indicate default behavior instead of a
+   * substituted value
+   */
+  SUBSTITUTE_SKIP: SKIP_SYMBOL,
+
+  /*
+   * substituteMethod(object, propertyName, values):
+   *
+   * Defines an own property @object.@propertyName that will, for each
+   * subsequent call to the method previously defined as
+   * @object.@propertyName:
+   *  - Call the method, if no more values remain
+   *  - Call the method, if the value in @values for the corresponding call
+   *    is SUBSTITUTE_SKIP
+   *  - Otherwise, return the corresponding value in @value
+   */
+  substituteMethod(object, propertyName, values) {
+    let calls = 0;
+    const method = object[propertyName];
+    object[propertyName] = function () {
+      if (calls >= values.length) {
+        return method.apply(object, arguments);
+      } else if (values[calls] === SKIP_SYMBOL) {
+        calls++;
+        return method.apply(object, arguments);
+      } else {
+        return values[calls++];
+      }
+    };
+  },
+
+  /*
+   * calendarObserver:
+   * A custom calendar that behaves exactly like the ISO 8601 calendar but
+   * tracks calls to any of its methods, and Get/Has operations on its
+   * properties, by appending messages to an array. This is for the purpose of
+   * testing order of operations that are observable from user code.
+   * objectName is used in the log.
+   */
+  calendarObserver(calls, objectName, methodOverrides = {}) {
+    function removeExtraHasPropertyChecks(objectName, calls) {
+      // Inserting the tracking calendar into the return values of methods
+      // that we chain up into the ISO calendar for, causes extra HasProperty
+      // checks, which we observe. This removes them so that we don't leak
+      // implementation details of the helper into the test code.
+      assert.sameValue(calls.pop(), `has ${objectName}.yearOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.yearMonthFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.year`);
+      assert.sameValue(calls.pop(), `has ${objectName}.weekOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthsInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthDayFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.monthCode`);
+      assert.sameValue(calls.pop(), `has ${objectName}.month`);
+      assert.sameValue(calls.pop(), `has ${objectName}.mergeFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.inLeapYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.id`);
+      assert.sameValue(calls.pop(), `has ${objectName}.fields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.daysInMonth`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfYear`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dayOfWeek`);
+      assert.sameValue(calls.pop(), `has ${objectName}.day`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateUntil`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateFromFields`);
+      assert.sameValue(calls.pop(), `has ${objectName}.dateAdd`);
+    }
+
+    const iso8601 = new Temporal.Calendar("iso8601");
+    const trackingMethods = {
+      dateFromFields(...args) {
+        calls.push(`call ${objectName}.dateFromFields`);
+        if ('dateFromFields' in methodOverrides) {
+          const value = methodOverrides.dateFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      yearMonthFromFields(...args) {
+        calls.push(`call ${objectName}.yearMonthFromFields`);
+        if ('yearMonthFromFields' in methodOverrides) {
+          const value = methodOverrides.yearMonthFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.yearMonthFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      monthDayFromFields(...args) {
+        calls.push(`call ${objectName}.monthDayFromFields`);
+        if ('monthDayFromFields' in methodOverrides) {
+          const value = methodOverrides.monthDayFromFields;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.monthDayFromFields(...args);
+        // Replace the calendar in the result with the call-tracking calendar
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      dateAdd(...args) {
+        calls.push(`call ${objectName}.dateAdd`);
+        if ('dateAdd' in methodOverrides) {
+          const value = methodOverrides.dateAdd;
+          return typeof value === "function" ? value(...args) : value;
+        }
+        const originalResult = iso8601.dateAdd(...args);
+        const {isoYear, isoMonth, isoDay} = originalResult.getISOFields();
+        const result = new Temporal.PlainDate(isoYear, isoMonth, isoDay, this);
+        removeExtraHasPropertyChecks(objectName, calls);
+        return result;
+      },
+      id: "iso8601",
+    };
+    // Automatically generate the other methods that don't need any custom code
+    [
+      "dateUntil",
+      "day",
+      "dayOfWeek",
+      "dayOfYear",
+      "daysInMonth",
+      "daysInWeek",
+      "daysInYear",
+      "era",
+      "eraYear",
+      "fields",
+      "inLeapYear",
+      "mergeFields",
+      "month",
+      "monthCode",
+      "monthsInYear",
+      "toString",
+      "weekOfYear",
+      "year",
+      "yearOfWeek",
+    ].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return iso8601[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom calendar that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  calendarThrowEverything() {
+    class CalendarThrowEverything extends Temporal.Calendar {
+      constructor() {
+        super("iso8601");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+      dateFromFields() {
+        TemporalHelpers.assertUnreachable("dateFromFields should not be called");
+      }
+      yearMonthFromFields() {
+        TemporalHelpers.assertUnreachable("yearMonthFromFields should not be called");
+      }
+      monthDayFromFields() {
+        TemporalHelpers.assertUnreachable("monthDayFromFields should not be called");
+      }
+      dateAdd() {
+        TemporalHelpers.assertUnreachable("dateAdd should not be called");
+      }
+      dateUntil() {
+        TemporalHelpers.assertUnreachable("dateUntil should not be called");
+      }
+      era() {
+        TemporalHelpers.assertUnreachable("era should not be called");
+      }
+      eraYear() {
+        TemporalHelpers.assertUnreachable("eraYear should not be called");
+      }
+      year() {
+        TemporalHelpers.assertUnreachable("year should not be called");
+      }
+      month() {
+        TemporalHelpers.assertUnreachable("month should not be called");
+      }
+      monthCode() {
+        TemporalHelpers.assertUnreachable("monthCode should not be called");
+      }
+      day() {
+        TemporalHelpers.assertUnreachable("day should not be called");
+      }
+      fields() {
+        TemporalHelpers.assertUnreachable("fields should not be called");
+      }
+      mergeFields() {
+        TemporalHelpers.assertUnreachable("mergeFields should not be called");
+      }
+    }
+
+    return new CalendarThrowEverything();
+  },
+
+  /*
+   * oneShiftTimeZone(shiftInstant, shiftNanoseconds):
+   *
+   * In the case of a spring-forward time zone offset transition (skipped time),
+   * and disambiguation === 'earlier', BuiltinTimeZoneGetInstantFor subtracts a
+   * negative number of nanoseconds from a PlainDateTime, which should balance
+   * with the microseconds field.
+   *
+   * This returns an instance of a custom time zone class which skips a length
+   * of time equal to shiftNanoseconds (a number), at the Temporal.Instant
+   * shiftInstant. Before shiftInstant, it's identical to UTC, and after
+   * shiftInstant it's a constant-offset time zone.
+   *
+   * It provides a getPossibleInstantsForCalledWith member which is an array
+   * with the result of calling toString() on any PlainDateTimes passed to
+   * getPossibleInstantsFor().
+   */
+  oneShiftTimeZone(shiftInstant, shiftNanoseconds) {
+    class OneShiftTimeZone extends Temporal.TimeZone {
+      constructor(shiftInstant, shiftNanoseconds) {
+        super("+00:00");
+        this._shiftInstant = shiftInstant;
+        this._epoch1 = shiftInstant.epochNanoseconds;
+        this._epoch2 = this._epoch1 + BigInt(shiftNanoseconds);
+        this._shiftNanoseconds = shiftNanoseconds;
+        this._shift = new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, this._shiftNanoseconds);
+        this.getPossibleInstantsForCalledWith = [];
+      }
+
+      _isBeforeShift(instant) {
+        return instant.epochNanoseconds < this._epoch1;
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        return this._isBeforeShift(instant) ? 0 : this._shiftNanoseconds;
+      }
+
+      getPossibleInstantsFor(plainDateTime) {
+        this.getPossibleInstantsForCalledWith.push(plainDateTime.toString({ calendarName: "never" }));
+        const [instant] = super.getPossibleInstantsFor(plainDateTime);
+        if (this._shiftNanoseconds > 0) {
+          if (this._isBeforeShift(instant)) return [instant];
+          if (instant.epochNanoseconds < this._epoch2) return [];
+          return [instant.subtract(this._shift)];
+        }
+        if (instant.epochNanoseconds < this._epoch2) return [instant];
+        const shifted = instant.subtract(this._shift);
+        if (this._isBeforeShift(instant)) return [instant, shifted];
+        return [shifted];
+      }
+
+      getNextTransition(instant) {
+        return this._isBeforeShift(instant) ? this._shiftInstant : null;
+      }
+
+      getPreviousTransition(instant) {
+        return this._isBeforeShift(instant) ? null : this._shiftInstant;
+      }
+
+      toString() {
+        return "Custom/One_Shift";
+      }
+    }
+    return new OneShiftTimeZone(shiftInstant, shiftNanoseconds);
+  },
+
+  /*
+   * propertyBagObserver():
+   * Returns an object that behaves like the given propertyBag but tracks Get
+   * and Has operations on any of its properties, by appending messages to an
+   * array. If the value of a property in propertyBag is a primitive, the value
+   * of the returned object's property will additionally be a
+   * TemporalHelpers.toPrimitiveObserver that will track calls to its toString
+   * and valueOf methods in the same array. This is for the purpose of testing
+   * order of operations that are observable from user code. objectName is used
+   * in the log.
+   */
+  propertyBagObserver(calls, propertyBag, objectName) {
+    return new Proxy(propertyBag, {
+      ownKeys(target) {
+        calls.push(`ownKeys ${objectName}`);
+        return Reflect.ownKeys(target);
+      },
+      getOwnPropertyDescriptor(target, key) {
+        calls.push(`getOwnPropertyDescriptor ${formatPropertyName(key, objectName)}`);
+        return Reflect.getOwnPropertyDescriptor(target, key);
+      },
+      get(target, key, receiver) {
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        const result = Reflect.get(target, key, receiver);
+        if (result === undefined) {
+          return undefined;
+        }
+        if ((result !== null && typeof result === "object") || typeof result === "function") {
+          return result;
+        }
+        return TemporalHelpers.toPrimitiveObserver(calls, result, `${formatPropertyName(key, objectName)}`);
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * specificOffsetTimeZone():
+   *
+   * This returns an instance of a custom time zone class, which returns a
+   * specific custom value from its getOffsetNanosecondsFrom() method. This is
+   * for the purpose of testing the validation of what this method returns.
+   *
+   * It also returns an empty array from getPossibleInstantsFor(), so as to
+   * trigger calls to getOffsetNanosecondsFor() when used from the
+   * BuiltinTimeZoneGetInstantFor operation.
+   */
+  specificOffsetTimeZone(offsetValue) {
+    class SpecificOffsetTimeZone extends Temporal.TimeZone {
+      constructor(offsetValue) {
+        super("UTC");
+        this._offsetValue = offsetValue;
+      }
+
+      getOffsetNanosecondsFor() {
+        return this._offsetValue;
+      }
+
+      getPossibleInstantsFor(dt) {
+        if (typeof this._offsetValue !== 'number' || Math.abs(this._offsetValue) >= 86400e9 || isNaN(this._offsetValue)) return [];
+        const zdt = dt.toZonedDateTime("UTC").add({ nanoseconds: -this._offsetValue });
+        return [zdt.toInstant()];
+      }
+
+      get id() {
+        return this.getOffsetStringFor(new Temporal.Instant(0n));
+      }
+    }
+    return new SpecificOffsetTimeZone(offsetValue);
+  },
+
+  /*
+   * springForwardFallBackTimeZone():
+   *
+   * This returns an instance of a custom time zone class that implements one
+   * single spring-forward/fall-back transition, for the purpose of testing the
+   * disambiguation option, without depending on system time zone data.
+   *
+   * The spring-forward occurs at epoch second 954669600 (2000-04-02T02:00
+   * local) and goes from offset -08:00 to -07:00.
+   *
+   * The fall-back occurs at epoch second 972810000 (2000-10-29T02:00 local) and
+   * goes from offset -07:00 to -08:00.
+   */
+  springForwardFallBackTimeZone() {
+    const { compare } = Temporal.PlainDateTime;
+    const springForwardLocal = new Temporal.PlainDateTime(2000, 4, 2, 2);
+    const springForwardEpoch = 954669600_000_000_000n;
+    const fallBackLocal = new Temporal.PlainDateTime(2000, 10, 29, 1);
+    const fallBackEpoch = 972810000_000_000_000n;
+    const winterOffset = new Temporal.TimeZone('-08:00');
+    const summerOffset = new Temporal.TimeZone('-07:00');
+
+    class SpringForwardFallBackTimeZone extends Temporal.TimeZone {
+      constructor() {
+        super("-08:00");
+      }
+
+      getOffsetNanosecondsFor(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch ||
+          instant.epochNanoseconds >= fallBackEpoch) {
+          return winterOffset.getOffsetNanosecondsFor(instant);
+        }
+        return summerOffset.getOffsetNanosecondsFor(instant);
+      }
+
+      getPossibleInstantsFor(datetime) {
+        if (compare(datetime, springForwardLocal) >= 0 && compare(datetime, springForwardLocal.add({ hours: 1 })) < 0) {
+          return [];
+        }
+        if (compare(datetime, fallBackLocal) >= 0 && compare(datetime, fallBackLocal.add({ hours: 1 })) < 0) {
+          return [summerOffset.getInstantFor(datetime), winterOffset.getInstantFor(datetime)];
+        }
+        if (compare(datetime, springForwardLocal) < 0 || compare(datetime, fallBackLocal) >= 0) {
+          return [winterOffset.getInstantFor(datetime)];
+        }
+        return [summerOffset.getInstantFor(datetime)];
+      }
+
+      getPreviousTransition(instant) {
+        if (instant.epochNanoseconds > fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        if (instant.epochNanoseconds > springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        return null;
+      }
+
+      getNextTransition(instant) {
+        if (instant.epochNanoseconds < springForwardEpoch) return new Temporal.Instant(springForwardEpoch);
+        if (instant.epochNanoseconds < fallBackEpoch) return new Temporal.Instant(fallBackEpoch);
+        return null;
+      }
+
+      get id() {
+        return "Custom/Spring_Fall";
+      }
+
+      toString() {
+        return "Custom/Spring_Fall";
+      }
+    }
+    return new SpringForwardFallBackTimeZone();
+  },
+
+  /*
+   * timeZoneObserver:
+   * A custom calendar that behaves exactly like the UTC time zone but tracks
+   * calls to any of its methods, and Get/Has operations on its properties, by
+   * appending messages to an array. This is for the purpose of testing order of
+   * operations that are observable from user code. objectName is used in the
+   * log. methodOverrides is an optional object containing properties with the
+   * same name as Temporal.TimeZone methods. If the property value is a function
+   * it will be called with the proper arguments instead of the UTC method.
+   * Otherwise, the property value will be returned directly.
+   */
+  timeZoneObserver(calls, objectName, methodOverrides = {}) {
+    const utc = new Temporal.TimeZone("UTC");
+    const trackingMethods = {
+      id: "UTC",
+    };
+    // Automatically generate the methods
+    ["getOffsetNanosecondsFor", "getPossibleInstantsFor", "toString"].forEach((methodName) => {
+      trackingMethods[methodName] = function (...args) {
+        calls.push(`call ${formatPropertyName(methodName, objectName)}`);
+        if (methodName in methodOverrides) {
+          const value = methodOverrides[methodName];
+          return typeof value === "function" ? value(...args) : value;
+        }
+        return utc[methodName](...args);
+      };
+    });
+    return new Proxy(trackingMethods, {
+      get(target, key, receiver) {
+        const result = Reflect.get(target, key, receiver);
+        calls.push(`get ${formatPropertyName(key, objectName)}`);
+        return result;
+      },
+      has(target, key) {
+        calls.push(`has ${formatPropertyName(key, objectName)}`);
+        return Reflect.has(target, key);
+      },
+    });
+  },
+
+  /*
+   * A custom time zone that does not allow any of its methods to be called, for
+   * the purpose of asserting that a particular operation does not call into
+   * user code.
+   */
+  timeZoneThrowEverything() {
+    class TimeZoneThrowEverything extends Temporal.TimeZone {
+      constructor() {
+        super("UTC");
+      }
+      getOffsetNanosecondsFor() {
+        TemporalHelpers.assertUnreachable("getOffsetNanosecondsFor should not be called");
+      }
+      getPossibleInstantsFor() {
+        TemporalHelpers.assertUnreachable("getPossibleInstantsFor should not be called");
+      }
+      toString() {
+        TemporalHelpers.assertUnreachable("toString should not be called");
+      }
+    }
+
+    return new TimeZoneThrowEverything();
+  },
+
+  /*
+   * Returns an object that will append logs of any Gets or Calls of its valueOf
+   * or toString properties to the array calls. Both valueOf and toString will
+   * return the actual primitiveValue. propertyName is used in the log.
+   */
+  toPrimitiveObserver(calls, primitiveValue, propertyName) {
+    return {
+      get valueOf() {
+        calls.push(`get ${propertyName}.valueOf`);
+        return function () {
+          calls.push(`call ${propertyName}.valueOf`);
+          return primitiveValue;
+        };
+      },
+      get toString() {
+        calls.push(`get ${propertyName}.toString`);
+        return function () {
+          calls.push(`call ${propertyName}.toString`);
+          if (primitiveValue === undefined) return undefined;
+          return primitiveValue.toString();
+        };
+      },
+    };
+  },
+
+  /*
+   * An object containing further methods that return arrays of ISO strings, for
+   * testing parsers.
+   */
+  ISO: {
+    /*
+     * PlainMonthDay strings that are not valid.
+     */
+    plainMonthDayStringsInvalid() {
+      return [
+        "11-18junk",
+        "11-18[u-ca=gregory]",
+        "11-18[u-ca=hebrew]",
+      ];
+    },
+
+    /*
+     * PlainMonthDay strings that are valid and that should produce October 1st.
+     */
+    plainMonthDayStringsValid() {
+      return [
+        "10-01",
+        "1001",
+        "1965-10-01",
+        "1976-10-01T152330.1+00:00",
+        "19761001T15:23:30.1+00:00",
+        "1976-10-01T15:23:30.1+0000",
+        "1976-10-01T152330.1+0000",
+        "19761001T15:23:30.1+0000",
+        "19761001T152330.1+00:00",
+        "19761001T152330.1+0000",
+        "+001976-10-01T152330.1+00:00",
+        "+0019761001T15:23:30.1+00:00",
+        "+001976-10-01T15:23:30.1+0000",
+        "+001976-10-01T152330.1+0000",
+        "+0019761001T15:23:30.1+0000",
+        "+0019761001T152330.1+00:00",
+        "+0019761001T152330.1+0000",
+        "1976-10-01T15:23:00",
+        "1976-10-01T15:23",
+        "1976-10-01T15",
+        "1976-10-01",
+        "--10-01",
+        "--1001",
+      ];
+    },
+
+    /*
+     * PlainTime strings that may be mistaken for PlainMonthDay or
+     * PlainYearMonth strings, and so require a time designator.
+     */
+    plainTimeStringsAmbiguous() {
+      const ambiguousStrings = [
+        "2021-12",  // ambiguity between YYYY-MM and HHMM-UU
+        "2021-12[-12:00]",  // ditto, TZ does not disambiguate
+        "1214",     // ambiguity between MMDD and HHMM
+        "0229",     //   ditto, including MMDD that doesn't occur every year
+        "1130",     //   ditto, including DD that doesn't occur in every month
+        "12-14",    // ambiguity between MM-DD and HH-UU
+        "12-14[-14:00]",  // ditto, TZ does not disambiguate
+        "202112",   // ambiguity between YYYYMM and HHMMSS
+        "202112[UTC]",  // ditto, TZ does not disambiguate
+      ];
+      // Adding a calendar annotation to one of these strings must not cause
+      // disambiguation in favour of time.
+      const stringsWithCalendar = ambiguousStrings.map((s) => s + '[u-ca=iso8601]');
+      return ambiguousStrings.concat(stringsWithCalendar);
+    },
+
+    /*
+     * PlainTime strings that are of similar form to PlainMonthDay and
+     * PlainYearMonth strings, but are not ambiguous due to components that
+     * aren't valid as months or days.
+     */
+    plainTimeStringsUnambiguous() {
+      return [
+        "2021-13",          // 13 is not a month
+        "202113",           //   ditto
+        "2021-13[-13:00]",  //   ditto
+        "202113[-13:00]",   //   ditto
+        "0000-00",          // 0 is not a month
+        "000000",           //   ditto
+        "0000-00[UTC]",     //   ditto
+        "000000[UTC]",      //   ditto
+        "1314",             // 13 is not a month
+        "13-14",            //   ditto
+        "1232",             // 32 is not a day
+        "0230",             // 30 is not a day in February
+        "0631",             // 31 is not a day in June
+        "0000",             // 0 is neither a month nor a day
+        "00-00",            //   ditto
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are not valid.
+     */
+    plainYearMonthStringsInvalid() {
+      return [
+        "2020-13",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November
+     * 1976 in the ISO 8601 calendar.
+     */
+    plainYearMonthStringsValid() {
+      return [
+        "1976-11",
+        "1976-11-10",
+        "1976-11-01T09:00:00+00:00",
+        "1976-11-01T00:00:00+05:00",
+        "197611",
+        "+00197611",
+        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T152330.1+00:00",
+        "19761118T15:23:30.1+00:00",
+        "1976-11-18T15:23:30.1+0000",
+        "1976-11-18T152330.1+0000",
+        "19761118T15:23:30.1+0000",
+        "19761118T152330.1+00:00",
+        "19761118T152330.1+0000",
+        "+001976-11-18T152330.1+00:00",
+        "+0019761118T15:23:30.1+00:00",
+        "+001976-11-18T15:23:30.1+0000",
+        "+001976-11-18T152330.1+0000",
+        "+0019761118T15:23:30.1+0000",
+        "+0019761118T152330.1+00:00",
+        "+0019761118T152330.1+0000",
+        "1976-11-18T15:23",
+        "1976-11-18T15",
+        "1976-11-18",
+      ];
+    },
+
+    /*
+     * PlainYearMonth-like strings that are valid and should produce November of
+     * the ISO year -9999.
+     */
+    plainYearMonthStringsValidNegativeYear() {
+      return [
+        "\u2212009999-11",
+      ];
+    },
+  }
+};
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-non-promise-thenable.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-non-promise-thenable.js
new file mode 100644
index 0000000000..7bdaf5942a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-non-promise-thenable.js
@@ -0,0 +1,24 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync-iterable input with non-promise thenables works.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const expected = [ expectedValue ];
+  const inputThenable = {
+    then (resolve, reject) {
+      resolve(expectedValue);
+    },
+  };
+  const input = [ inputThenable ].values();
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-thenable.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-thenable.js
new file mode 100644
index 0000000000..59b7f5392c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input-with-thenable.js
@@ -0,0 +1,18 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync-iterable input with thenables is transferred to the output array.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expected = [ 0, 1, 2 ];
+  const input = [  0, Promise.resolve(1), Promise.resolve(2) ].values();
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input.js
new file mode 100644
index 0000000000..283f12d8ab
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-input.js
@@ -0,0 +1,18 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync-iterable input with no promises is transferred to the output array.
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expected = [ 0, 1, 2 ];
+  const input = [ 0, 1, 2 ].values();
+  const output = await Array.fromAsync(input);
+  assert.compareArray(output, expected);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-iteration-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-iteration-err.js
new file mode 100644
index 0000000000..91b110e4ed
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-iteration-err.js
@@ -0,0 +1,20 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync iterable result promise rejects if iteration of input fails.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function *generateInput () {
+    throw new Test262Error;
+  }
+  const input = generateInput();
+  const outputPromise = Array.fromAsync(input);
+  await assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-awaits-once.js
new file mode 100644
index 0000000000..1b3bdbf2e7
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-awaits-once.js
@@ -0,0 +1,26 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Sync-iterable input with thenables awaits each input once with async mapping callback.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter++;
+      resolve(expectedValue);
+    },
+  };
+  const input = [ inputThenable ].values();
+  await Array.fromAsync(input, async v => v);
+  assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-callback-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-callback-err.js
new file mode 100644
index 0000000000..d77da6aa10
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-async-mapped-callback-err.js
@@ -0,0 +1,19 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync-iterable input with thenable result promise rejects if async map function callback throws. 
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const input = [ Promise.resolve(0) ].values();
+  const outputPromise = Array.fromAsync(input, async v => {
+    throw new Test262Error;
+  });
+  await assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-awaits-once.js
new file mode 100644
index 0000000000..00dd71407c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-awaits-once.js
@@ -0,0 +1,26 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Sync-iterable input with thenables awaits each input once without mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter++;
+      resolve(expectedValue);
+    },
+  };
+  const input = [ inputThenable ].values();
+  await Array.fromAsync(input);
+  assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-element-rejects.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-element-rejects.js
new file mode 100644
index 0000000000..b5b0a6c3e4
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-element-rejects.js
@@ -0,0 +1,22 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Result promise rejects if then method of input fails. 
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const inputThenable = {
+    then (resolve, reject) {
+      reject(new Test262Error);
+    },
+  };
+  const input = [ inputThenable ].values();
+  const output = Array.fromAsync(input);
+  await assert.throwsAsync(Test262Error, () => output);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-awaits-once.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-awaits-once.js
new file mode 100644
index 0000000000..324a7b1701
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-awaits-once.js
@@ -0,0 +1,26 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Sync-iterable input with mapfn awaits each input once with sync mapping callback
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  let awaitCounter = 0;
+  const inputThenable = {
+    then (resolve, reject) {
+      awaitCounter++;
+      resolve(expectedValue);
+    },
+  };
+  const input = [ inputThenable ].values();
+  await Array.fromAsync(input, v => v);
+  assert.sameValue(awaitCounter, 1);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-callback-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-callback-err.js
new file mode 100644
index 0000000000..d502ec0209
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-sync-mapped-callback-err.js
@@ -0,0 +1,19 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Sync-iterable input with thenable result promise rejects if sync map function callback throws. 
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const input = [ Promise.resolve(0) ].values();
+  const outputPromise = Array.fromAsync(input, v => {
+    throw new Test262Error;
+  });
+  await assert.throwsAsync(Test262Error, () => outputPromise);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-then-method-err.js b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-then-method-err.js
new file mode 100644
index 0000000000..30bd54dac6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/sync-iterable-with-thenable-then-method-err.js
@@ -0,0 +1,24 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: Result promise rejects if then method of input fails. 
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const expectedValue = {};
+  const expected = [ expectedValue ];
+  const inputThenable = {
+    then (resolve, reject) {
+      throw new Test262Error();
+    },
+  };
+  const input = [ inputThenable ].values();
+  const output = Array.fromAsync(input);
+  await assert.throwsAsync(Test262Error, () => output);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-operations.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-operations.js
new file mode 100644
index 0000000000..ee96890677
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-operations.js
@@ -0,0 +1,74 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Order of user-observable operations on a custom this-value and its instances
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+function formatPropertyName(propertyKey, objectName = "") {
+  switch (typeof propertyKey) {
+    case "symbol":
+      if (Symbol.keyFor(propertyKey) !== undefined) {
+        return `${objectName}[Symbol.for('${Symbol.keyFor(propertyKey)}')]`;
+      } else if (propertyKey.description.startsWith('Symbol.')) {
+        return `${objectName}[${propertyKey.description}]`;
+      } else {
+        return `${objectName}[Symbol('${propertyKey.description}')]`
+      }
+    case "string":
+      if (propertyKey !== String(Number(propertyKey)))
+        return objectName ? `${objectName}.${propertyKey}` : propertyKey;
+      // fall through
+    default:
+      // integer or string integer-index
+      return `${objectName}[${propertyKey}]`;
+  }
+}
+
+asyncTest(async function () {
+  const expectedCalls = [
+    "construct MyArray",
+    "defineProperty A[0]",
+    "defineProperty A[1]",
+    "set A.length"
+  ];
+  const actualCalls = [];
+
+  function MyArray(...args) {
+    actualCalls.push("construct MyArray");
+    return new Proxy(Object.create(null), {
+      set(target, key, value) {
+        actualCalls.push(`set ${formatPropertyName(key, "A")}`);
+        return Reflect.set(target, key, value);
+      },
+      defineProperty(target, key, descriptor) {
+        actualCalls.push(`defineProperty ${formatPropertyName(key, "A")}`);
+        return Reflect.defineProperty(target, key, descriptor);
+      }
+    });
+  }
+
+  let result = await Array.fromAsync.call(MyArray, [1, 2]);
+  assert.compareArray(expectedCalls, actualCalls, "order of operations for array argument");
+
+  actualCalls.splice(0);  // reset
+
+  const expectedCallsForArrayLike = [
+    "construct MyArray",
+    "defineProperty A[0]",
+    "defineProperty A[1]",
+    "set A.length"
+  ];
+  result = await Array.fromAsync.call(MyArray, {
+    length: 2,
+    0: 1,
+    1: 2
+  });
+  assert.compareArray(expectedCallsForArrayLike, actualCalls, "order of operations for array-like argument");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-bad-length-setter.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-bad-length-setter.js
new file mode 100644
index 0000000000..b3cf982af7
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-bad-length-setter.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Rejects the promise if setting the length fails on an instance of a custom
+  this-value
+info: |
+  3.j.ii.4.a. Perform ? Set(_A_, *"length"*, 𝔽(_k_), *true*).
+  ...
+  3.k.viii. Perform ? Set(_A_, *"length"*, 𝔽(_len_), *true*)
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  class MyArray {
+    set length(v) {
+      throw new Test262Error("setter of length property throws")
+    }
+  }
+
+  await assert.throwsAsync(Test262Error, () => Array.fromAsync.call(MyArray, [0, 1, 2]), "Promise rejected if setting length fails");
+
+  await assert.throwsAsync(Test262Error, () => Array.fromAsync.call(MyArray, {
+    length: 3,
+    0: 0,
+    1: 1,
+    2: 2
+  }), "Promise rejected if setting length from array-like fails");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-elements.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-elements.js
new file mode 100644
index 0000000000..112824f6e6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-elements.js
@@ -0,0 +1,51 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Overwrites non-writable element properties on an instance of a custom
+  this-value
+info: |
+  3.j.ii.8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+  ...
+  3.k.vii.6. Perform ? CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function MyArray() {
+    this.length = 4;
+    for (let ix = 0; ix < this.length; ix++) {
+      Object.defineProperty(this, ix, {
+        enumerable: true,
+        writable: false,
+        configurable: true,
+        value: 99
+      });
+    }
+  }
+
+  let result = await Array.fromAsync.call(MyArray, [0, 1, 2]);
+  assert.sameValue(result.length, 3, "Length property is overwritten");
+  assert.sameValue(result[0], 0, "Read-only element 0 is overwritten");
+  assert.sameValue(result[1], 1, "Read-only element 1 is overwritten");
+  assert.sameValue(result[2], 2, "Read-only element 2 is overwritten");
+  assert.sameValue(result[3], 99, "Element 3 is not overwritten");
+
+  result = await Array.fromAsync.call(MyArray, {
+    length: 3,
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3  // ignored
+  });
+  assert.sameValue(result.length, 3, "Length property is overwritten");
+  assert.sameValue(result[0], 0, "Read-only element 0 is overwritten");
+  assert.sameValue(result[1], 1, "Read-only element 1 is overwritten");
+  assert.sameValue(result[2], 2, "Read-only element 2 is overwritten");
+  assert.sameValue(result[3], 99, "Element 3 is not overwritten");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-length.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-length.js
new file mode 100644
index 0000000000..f5f9495004
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-readonly-length.js
@@ -0,0 +1,39 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Promise is rejected if length property on an instance of a custom this-value
+  is non-writable
+info: |
+  3.j.ii.4.a. Perform ? Set(_A_, *"length"*, 𝔽(_k_), *true*).
+  ...
+  3.k.viii. Perform ? Set(_A_, *"length"*, 𝔽(_len_), *true*).
+
+  Note that there is no difference between strict mode and sloppy mode, because
+  we are not following runtime evaluation semantics.
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function MyArray() {
+    Object.defineProperty(this, "length", {
+      enumerable: true,
+      writable: false,
+      configurable: true,
+      value: 99
+    });
+  }
+
+  await assert.throwsAsync(TypeError, () => Array.fromAsync.call(MyArray, [0, 1, 2]), "Setting read-only length fails");
+  await assert.throwsAsync(TypeError, () => Array.fromAsync.call(MyArray, {
+    length: 3,
+    0: 0,
+    1: 1,
+    2: 2
+  }), "Setting read-only length fails in array-like case");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-async-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-async-iterator.js
new file mode 100644
index 0000000000..4986847991
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-async-iterator.js
@@ -0,0 +1,44 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Closes an async iterator if setting an element fails on an instance of a
+  custom this-value
+info: |
+  3.j.ii.8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+  9. If _defineStatus_ is an abrupt completion, return ? AsyncIteratorClose(_iteratorRecord_, _defineStatus_).
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function MyArray() {
+    Object.defineProperty(this, 0, {
+      enumerable: true,
+      writable: true,
+      configurable: false,
+      value: 0
+    });
+  }
+
+  let closed = false;
+  const iterator = {
+    next() {
+      return Promise.resolve({ value: 1, done: false });
+    },
+    return() {
+      closed = true;
+      return Promise.resolve({ done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  }
+
+  await assert.throwsAsync(TypeError, () => Array.fromAsync.call(MyArray, iterator), "Promise rejected if defining element fails");
+  assert(closed, "element define failure should close iterator");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-sync-iterator.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-sync-iterator.js
new file mode 100644
index 0000000000..8138532547
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element-closes-sync-iterator.js
@@ -0,0 +1,44 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Closes a sync iterator if setting an element fails on an instance of a custom
+  this-value
+info: |
+  3.j.ii.8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+  9. If _defineStatus_ is an abrupt completion, return ? AsyncIteratorClose(_iteratorRecord_, _defineStatus_).
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function MyArray() {
+    Object.defineProperty(this, 0, {
+      enumerable: true,
+      writable: true,
+      configurable: false,
+      value: 0
+    });
+  }
+
+  let closed = false;
+  const iterator = {
+    next() {
+      return { value: 1, done: false };
+    },
+    return() {
+      closed = true;
+      return { done: true };
+    },
+    [Symbol.iterator]() {
+      return this;
+    }
+  }
+
+  await assert.throwsAsync(TypeError, () => Array.fromAsync.call(MyArray, iterator), "Promise rejected if defining element fails");
+  assert(closed, "element define failure should close iterator");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element.js
new file mode 100644
index 0000000000..de283488f7
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor-with-unsettable-element.js
@@ -0,0 +1,29 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Rejects the promise if setting an element fails on an instance of a custom
+  this-value
+info: |
+  3.j.ii.8. Let _defineStatus_ be CreateDataPropertyOrThrow(_A_, _Pk_, _mappedValue_).
+  9. If _defineStatus_ is an abrupt completion, return ? AsyncIteratorClose(_iteratorRecord_, _defineStatus_).
+includes: [asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  function MyArray() {
+    Object.defineProperty(this, 0, {
+      enumerable: true,
+      writable: true,
+      configurable: false,
+      value: 0
+    });
+  }
+
+  await assert.throwsAsync(TypeError, () => Array.fromAsync.call(MyArray, [0, 1, 2]), "Promise rejected if defining element fails");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor.js
new file mode 100644
index 0000000000..e8c2c1948f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-constructor.js
@@ -0,0 +1,53 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Constructs the this-value once if asyncItems is iterable, twice if not, and
+  length and element properties are set correctly on the result
+info: |
+  3.e. If IsConstructor(_C_) is *true*, then
+    i. Let _A_ be ? Construct(_C_).
+  ...
+  j. If _iteratorRecord_ is not *undefined*, then
+    ...
+  k. Else,
+    ...
+    iv. If IsConstructor(_C_) is *true*, then
+      1. Let _A_ be ? Construct(_C_, « 𝔽(_len_) »).
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const constructorCalls = [];
+
+  function MyArray(...args) {
+    constructorCalls.push(args);
+  }
+
+  let result = await Array.fromAsync.call(MyArray, [1, 2]);
+  assert(result instanceof MyArray, "result is an instance of the constructor this-value");
+  assert.sameValue(result.length, 2, "length is set on result");
+  assert.sameValue(result[0], 1, "element 0 is set on result");
+  assert.sameValue(result[1], 2, "element 1 is set on result");
+  assert.sameValue(constructorCalls.length, 1, "constructor is called once");
+  assert.compareArray(constructorCalls[0], [], "constructor is called with no arguments");
+
+  constructorCalls.splice(0);  // reset
+
+  result = await Array.fromAsync.call(MyArray, {
+    length: 2,
+    0: 1,
+    1: 2
+  });
+  assert(result instanceof MyArray, "result is an instance of the constructor this-value");
+  assert.sameValue(result.length, 2, "length is set on result");
+  assert.sameValue(result[0], 1, "element 0 is set on result");
+  assert.sameValue(result[1], 2, "element 1 is set on result");
+  assert.sameValue(constructorCalls.length, 1, "constructor is called once");
+  assert.compareArray(constructorCalls[0], [2], "constructor is called with a length argument");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/this-non-constructor.js b/js/src/tests/test262/built-ins/Array/fromAsync/this-non-constructor.js
new file mode 100644
index 0000000000..10934a855a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/this-non-constructor.js
@@ -0,0 +1,49 @@
+// |reftest| async
+// Copyright (C) 2023 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  Constructs an intrinsic Array if this-value is not a constructor, and length
+  and element properties are set accordingly.
+info: |
+  3.e. If IsConstructor(_C_) is *true*, then
+    ...
+  f. Else,
+    i. Let _A_ be ! ArrayCreate(0).
+
+  ...
+  j. If _iteratorRecord_ is not *undefined*, then
+    ...
+  k. Else,
+    ...
+    iv. If IsConstructor(_C_) is *true*, then
+      ...
+    v. Else,
+      1. Let _A_ be ? ArrayCreate(_len_).
+includes: [compareArray.js, asyncHelpers.js]
+flags: [async]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async function () {
+  const thisValue = {
+    length: 4000,
+    0: 32,
+    1: 64,
+    2: 128
+  };
+
+  let result = await Array.fromAsync.call(thisValue, [1, 2]);
+  assert(Array.isArray(result), "result is an intrinsic Array");
+  assert.compareArray(result, [1, 2], "result is not disrupted by properties of this-value");
+
+  result = await Array.fromAsync.call(thisValue, {
+    length: 2,
+    0: 1,
+    1: 2
+  });
+  assert(Array.isArray(result), "result is an intrinsic Array");
+  assert.compareArray(result, [1, 2], "result is not disrupted by properties of this-value");
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-object.js b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-object.js
new file mode 100644
index 0000000000..5d2c9cdc53
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-object.js
@@ -0,0 +1,22 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: If thisArg is an object, it's bound to mapfn as the this-value
+info: |
+  6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+flags: [async]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  const myThisValue = {};
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, myThisValue, "thisArg should be bound as the this-value of mapfn");
+  }, myThisValue);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-sloppy.js b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-sloppy.js
new file mode 100644
index 0000000000..c3440dd99c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-sloppy.js
@@ -0,0 +1,34 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  If thisArg is omitted, mapfn is called with the global object as the
+  this-value in sloppy mode
+info: |
+  6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+
+  OrdinaryCallBindThis, when _F_.[[ThisMode]] is ~global~, where _F_ is the
+  function object:
+  6. Else,
+    a. If _thisArgument_ is *undefined* or *null*, then
+      i. Let _globalEnv_ be _calleeRealm_.[[GlobalEnv]].
+      ii. Assert: _globalEnv_ is a Global Environment Record.
+      iii. Let _thisValue_ be _globalEnv_.[[GlobalThisValue]].
+flags: [async, noStrict]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(
+      this,
+      globalThis,
+      "the global should be bound as the this-value of mapfn when thisArg is omitted"
+    );
+  });
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-strict-strict.js b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-strict-strict.js
new file mode 100644
index 0000000000..1f78261466
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-omitted-strict-strict.js
@@ -0,0 +1,30 @@
+// |reftest| async
+'use strict';
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  If thisArg is omitted, mapfn is called with undefined as the this-value in
+  strict mode
+info: |
+  6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+
+  In OrdinaryCallBindThis, _thisArgument_ is always bound as the this-value in
+  strict mode (_F_.[[ThisMode]] is ~strict~, where _F_ is the function object.)
+flags: [async, onlyStrict]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(
+      this,
+      undefined,
+      "undefined should be bound as the this-value of mapfn when thisArg is omitted"
+    );
+  });
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-sloppy.js b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-sloppy.js
new file mode 100644
index 0000000000..244be840a8
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-sloppy.js
@@ -0,0 +1,76 @@
+// |reftest| async
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  If thisArg is a primitive, mapfn is called with a wrapper this-value or the
+  global, according to the usual rules of sloppy mode
+info: |
+  6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+
+  OrdinaryCallBindThis, when _F_.[[ThisMode]] is ~global~, where _F_ is the
+  function object:
+  6. Else,
+    a. If _thisArgument_ is *undefined* or *null*, then
+      i. Let _globalEnv_ be _calleeRealm_.[[GlobalEnv]].
+      ii. Assert: _globalEnv_ is a Global Environment Record.
+      iii. Let _thisValue_ be _globalEnv_.[[GlobalThisValue]].
+    b. Else,
+      i. Let _thisValue_ be ! ToObject(_thisArgument_).
+      ii. NOTE: ToObject produces wrapper objects using _calleeRealm_.
+flags: [async, noStrict]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(
+      this,
+      globalThis,
+      "the global should be bound as the this-value of mapfn when thisArg is undefined"
+    );
+  }, undefined);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(
+      this,
+      globalThis,
+      "the global should be bound as the this-value of mapfn when thisArg is null"
+    );
+  }, null);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.notSameValue(this, "string", "string thisArg should not be bound as the this-value of mapfn");
+    assert.sameValue(typeof this, "object", "a String wrapper object should be bound as the this-value of mapfn when thisArg is a string")
+    assert.sameValue(this.valueOf(), "string", "String wrapper object should have the same primitive value as thisArg");
+  }, "string");
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.notSameValue(this, 3.1416, "number thisArg should be not bound as the this-value of mapfn");
+    assert.sameValue(typeof this, "object", "a Number wrapper object should be bound as the this-value of mapfn when thisArg is a number")
+    assert.sameValue(this.valueOf(), 3.1416, "Number wrapper object should have the same primitive value as thisArg");
+  }, 3.1416);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.notSameValue(this, 42n, "bigint thisArg should not be bound as the this-value of mapfn");
+    assert.sameValue(typeof this, "object", "a BigInt wrapper object should be bound as the this-value of mapfn when thisArg is a bigint")
+    assert.sameValue(this.valueOf(), 42n, "BigInt wrapper object should have the same primitive value as thisArg");
+  }, 42n);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.notSameValue(this, true, "boolean thisArg should not be bound as the this-value of mapfn");
+    assert.sameValue(typeof this, "object", "a Boolean wrapper object should be bound as the this-value of mapfn when thisArg is a boolean")
+    assert.sameValue(this.valueOf(), true, "Boolean wrapper object should have the same primitive value as thisArg");
+  }, true);
+
+  const symbolThis = Symbol("symbol");
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.notSameValue(this, symbolThis, "symbol thisArg should not be bound as the this-value of mapfn");
+    assert.sameValue(typeof this, "object", "a Symbol wrapper object should be bound as the this-value of mapfn when thisArg is a symbol")
+    assert.sameValue(this.valueOf(), symbolThis, "Symbol wrapper object should have the same primitive value as thisArg");
+  }, symbolThis);
+});
diff --git a/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-strict-strict.js b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-strict-strict.js
new file mode 100644
index 0000000000..c66582ebde
--- /dev/null
+++ b/js/src/tests/test262/built-ins/Array/fromAsync/thisarg-primitive-strict-strict.js
@@ -0,0 +1,51 @@
+// |reftest| async
+'use strict';
+// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-array.fromasync
+description: >
+  If thisArg is a primitive, mapfn is called with it as the this-value in strict
+  mode
+info: |
+  6. If _mapping_ is *true*, then
+    a. Let _mappedValue_ be Call(_mapfn_, _thisArg_, « _nextValue_, 𝔽(_k_) »).
+
+  In OrdinaryCallBindThis, _thisArgument_ is always bound as the this-value in
+  strict mode (_F_.[[ThisMode]] is ~strict~, where _F_ is the function object.)
+flags: [async, onlyStrict]
+includes: [asyncHelpers.js]
+features: [Array.fromAsync]
+---*/
+
+asyncTest(async () => {
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, undefined, "undefined thisArg should be bound as the this-value of mapfn");
+  }, undefined);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, null, "null thisArg should be bound as the this-value of mapfn");
+  }, null);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, "string", "string thisArg should be bound as the this-value of mapfn");
+  }, "string");
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, 3.1416, "number thisArg should be bound as the this-value of mapfn");
+  }, 3.1416);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, 42n, "bigint thisArg should be bound as the this-value of mapfn");
+  }, 42n);
+
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, true, "boolean thisArg should be bound as the this-value of mapfn");
+  }, true);
+
+  const symbolThis = Symbol("symbol");
+  await Array.fromAsync([1, 2, 3], async function () {
+    assert.sameValue(this, symbolThis, "symbol thisArg should be bound as the this-value of mapfn");
+  }, symbolThis);
+});