Adding upstream version 124.0.1.upstream/124.0.1

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

39 files changed, 1673 insertions, 0 deletions

diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/browser.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/browser.js
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/detached-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/detached-buffer.js
new file mode 100644
index 0000000000..912a877c91
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/detached-buffer.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Throws a TypeError if this has a detached buffer
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  2. Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  ...
+  5. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+  ...
+includes: [testBigIntTypedArray.js, detachArrayBuffer.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+var predicate = function() {
+  throw new Test262Error();
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  $DETACHBUFFER(sample.buffer);
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(predicate);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/get-length-ignores-length-prop.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/get-length-ignores-length-prop.js
new file mode 100644
index 0000000000..6ebea5d93e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/get-length-ignores-length-prop.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  [[Get]] of "length" uses [[ArrayLength]]
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  3. Let len be O.[[ArrayLength]].
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+Object.defineProperty(TypedArray.prototype, "length", {
+  get: function() {
+    throw new Test262Error();
+  }
+});
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  Object.defineProperty(TA.prototype, "length", {
+    get: function() {
+      throw new Test262Error();
+    }
+  });
+
+  var sample = new TA([42n]);
+
+  Object.defineProperty(sample, "length", {
+    get: function() {
+      throw new Test262Error();
+    },
+    configurable: true
+  });
+
+  assert.sameValue(
+    sample.findLastIndex(function() { return true; }),
+    0
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-changes-value.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-changes-value.js
new file mode 100644
index 0000000000..a2e1ee53d2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-changes-value.js
@@ -0,0 +1,60 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Change values during predicate call
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [compareArray.js, testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var arr = [10n, 20n, 30n];
+  var sample;
+  var result;
+
+  sample = new TA(3);
+  sample.findLastIndex(function(val, i) {
+    sample[i] = arr[i];
+
+    assert.sameValue(val, 0n, "value is not mapped to instance");
+  });
+  assert(compareArray(sample, arr), "values set during each predicate call");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i === 2 ) {
+      sample[0] = 7n;
+    }
+    return val === 7n;
+  });
+  assert.sameValue(result, 0, "value found");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i === 2 ) {
+      sample[0] = 7n;
+    }
+    return val === 10n;
+  });
+  assert.sameValue(result, -1, "value not found");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i < 2 ) {
+      sample[2] = 7n;
+    }
+    return val === 7n;
+  });
+  assert.sameValue(result, -1, "value not found - changed after call");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-parameters.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-parameters.js
new file mode 100644
index 0000000000..e589cb2732
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-parameters.js
@@ -0,0 +1,52 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate called as F.call( thisArg, kValue, k, O ) for each array entry.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([39n, 2n, 62n]);
+  var results = [];
+  var result;
+
+  sample.foo = "bar"; // Ignores non integer index properties
+
+  sample.findLastIndex(function() {
+    results.push(arguments);
+  });
+
+  assert.sameValue(results.length, 3, "predicate is called for each index");
+
+  result = results[0];
+  assert.sameValue(result[0], 62n, "results[0][0] === 62, value");
+  assert.sameValue(result[1], 2, "results[0][1] === 2, index");
+  assert.sameValue(result[2], sample, "results[0][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[0].length === 3, arguments");
+
+  result = results[1];
+  assert.sameValue(result[0], 2n, "results[1][0] === 2, value");
+  assert.sameValue(result[1], 1, "results[1][1] === 1, index");
+  assert.sameValue(result[2], sample, "results[1][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[1].length === 3, arguments");
+
+  result = results[2];
+  assert.sameValue(result[0], 39n, "results[2][0] === 39, value");
+  assert.sameValue(result[1], 0, "results[2][1] === 0, index");
+  assert.sameValue(result[2], sample, "results[2][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[2].length === 3, arguments");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-non-strict.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-non-strict.js
new file mode 100644
index 0000000000..82c17225c6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-non-strict.js
@@ -0,0 +1,49 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Verify predicate this on non-strict mode
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+flags: [noStrict]
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+var T = this;
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  var result;
+
+  sample.findLastIndex(function() {
+    result = this;
+  });
+
+  assert.sameValue(result, T, "without thisArg, predicate this is the global");
+
+  result = null;
+  sample.findLastIndex(function() {
+    result = this;
+  }, undefined);
+
+  assert.sameValue(result, T, "predicate this is the global when thisArg is undefined");
+
+  var o = {};
+  result = null;
+  sample.findLastIndex(function() {
+    result = this;
+  }, o);
+
+  assert.sameValue(result, o, "thisArg becomes the predicate this");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-strict-strict.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-strict-strict.js
new file mode 100644
index 0000000000..d9219834fe
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-call-this-strict-strict.js
@@ -0,0 +1,44 @@
+'use strict';
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate thisArg as F.call( thisArg, kValue, k, O ) for each array entry.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    ...
+flags: [onlyStrict]
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  var result;
+
+  sample.findLastIndex(function() {
+    result = this;
+  });
+
+  assert.sameValue(
+    result,
+    undefined,
+    "without thisArg, predicate this is undefined"
+  );
+
+  var o = {};
+  sample.findLastIndex(function() {
+    result = this;
+  }, o);
+
+  assert.sameValue(result, o, "thisArg becomes the predicate this");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-is-not-callable-throws.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-is-not-callable-throws.js
new file mode 100644
index 0000000000..0ad12e72a1
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-is-not-callable-throws.js
@@ -0,0 +1,57 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Throws a TypeError exception if predicate is not callable.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  4. If IsCallable(predicate) is false, throw a TypeError exception.
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+  assert.throws(TypeError, function() {
+    sample.findLastIndex({});
+  }, "{}");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(null);
+  }, "null");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(undefined);
+  }, "undefined");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(false);
+  }, "false");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(true);
+  }, "true");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(1);
+  }, "1");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex("");
+  }, "string");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex([]);
+  }, "[]");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(/./);
+  }, "/./");
+});
+
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-may-detach-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-may-detach-buffer.js
new file mode 100644
index 0000000000..b4f8e774a9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-may-detach-buffer.js
@@ -0,0 +1,39 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate may detach the buffer
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0,
+    a. Let Pk be ! ToString(𝔽(k)).
+    b. Let kValue be ! Get(O, Pk).
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+
+  IntegerIndexedElementGet ( O, index )
+
+    Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
+    If IsDetachedBuffer(buffer) is true, return undefined.
+
+includes: [testBigIntTypedArray.js, detachArrayBuffer.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  var loops = 0;
+
+  sample.findLastIndex(function() {
+    if (loops === 0) {
+      $DETACHBUFFER(sample.buffer);
+    }
+    loops++;
+  });
+  assert.sameValue(loops, 2, "predicate is called once");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-not-called-on-empty-array.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-not-called-on-empty-array.js
new file mode 100644
index 0000000000..63090c3b54
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/predicate-not-called-on-empty-array.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate is not called on an empty instance
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    ...
+  7. Return -1.
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+  var called = false;
+
+  var predicate = function() {
+    called = true;
+    return true;
+  };
+
+  var result = sample.findLastIndex(predicate);
+
+  assert.sameValue(
+    called, false,
+    "does not call predicate"
+  );
+  assert.sameValue(
+    result, -1,
+    "returns -1 on an empty instance"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-predicate-call.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-predicate-call.js
new file mode 100644
index 0000000000..4f5b4d6f52
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-predicate-call.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return abrupt from predicate call.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+var predicate = function() {
+  throw new Test262Error();
+};
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  assert.throws(Test262Error, function() {
+    sample.findLastIndex(predicate);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-this-out-of-bounds.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-this-out-of-bounds.js
new file mode 100644
index 0000000000..512b17dacc
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-abrupt-from-this-out-of-bounds.js
@@ -0,0 +1,62 @@
+// |reftest| shell-option(--enable-arraybuffer-resizable) skip-if(!ArrayBuffer.prototype.resize||!xulRuntime.shell) -- resizable-arraybuffer is not enabled unconditionally, requires shell-options
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Return abrupt when "this" value fails buffer boundary checks
+includes: [testBigIntTypedArray.js]
+features: [ArrayBuffer, BigInt, TypedArray, array-find-from-last, arrow-function, resizable-arraybuffer]
+---*/
+
+assert.sameValue(
+  typeof TypedArray.prototype.findLastIndex,
+  'function',
+  'implements TypedArray.prototype.findLastIndex'
+);
+
+assert.sameValue(
+  typeof ArrayBuffer.prototype.resize,
+  'function',
+  'implements ArrayBuffer.prototype.resize'
+);
+
+testWithBigIntTypedArrayConstructors(TA => {
+  var BPE = TA.BYTES_PER_ELEMENT;
+  var ab = new ArrayBuffer(BPE * 4, {maxByteLength: BPE * 5});
+  var array = new TA(ab, BPE, 2);
+
+  try {
+    ab.resize(BPE * 5);
+  } catch (_) {}
+
+  // no error following grow:
+  array.findLastIndex(() => {});
+
+  try {
+    ab.resize(BPE * 3);
+  } catch (_) {}
+
+  // no error following shrink (within bounds):
+  array.findLastIndex(() => {});
+
+  var expectedError;
+  try {
+    ab.resize(BPE * 2);
+    // If the preceding "resize" operation is successful, the typed array will
+    // be out out of bounds, so the subsequent prototype method should produce
+    // a TypeError due to the semantics of ValidateTypedArray.
+    expectedError = TypeError;
+  } catch (_) {
+    // The host is permitted to fail any "resize" operation at its own
+    // discretion. If that occurs, the findLastIndex operation should complete
+    // successfully.
+    expectedError = Test262Error;
+  }
+
+  assert.throws(expectedError, () => {
+    array.findLastIndex(() => {});
+    throw new Test262Error('findLastIndex completed successfully');
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-index-predicate-result-is-true.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-index-predicate-result-is-true.js
new file mode 100644
index 0000000000..28a0bff79e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-index-predicate-result-is-true.js
@@ -0,0 +1,58 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return index if predicate return a boolean true value.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    d. If testResult is true, return 𝔽(k).
+  ...
+includes: [testBigIntTypedArray.js]
+features: [BigInt, Symbol, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([39n, 3n, 9n]);
+  var called = 0;
+
+  var result = sample.findLastIndex(function() {
+    called++;
+    return true;
+  });
+
+  assert.sameValue(result, 2, "returned true on sample[2]");
+  assert.sameValue(called, 1, "predicate was called once");
+
+  called = 0;
+  result = sample.findLastIndex(function(val) {
+    called++;
+    return val === 39n;
+  });
+
+  assert.sameValue(called, 3, "predicate was called three times");
+  assert.sameValue(result, 0, "returned true on sample[0]");
+
+  result = sample.findLastIndex(function() { return "string"; });
+  assert.sameValue(result, 2, "ToBoolean(string)");
+
+  result = sample.findLastIndex(function() { return {}; });
+  assert.sameValue(result, 2, "ToBoolean(object)");
+
+  result = sample.findLastIndex(function() { return Symbol(""); });
+  assert.sameValue(result, 2, "ToBoolean(symbol)");
+
+  result = sample.findLastIndex(function() { return 1; });
+  assert.sameValue(result, 2, "ToBoolean(number)");
+
+  result = sample.findLastIndex(function() { return -1; });
+  assert.sameValue(result, 2, "ToBoolean(negative number)");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-negative-one-if-predicate-returns-false-value.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-negative-one-if-predicate-returns-false-value.js
new file mode 100644
index 0000000000..eb08ec96ef
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/return-negative-one-if-predicate-returns-false-value.js
@@ -0,0 +1,52 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return -1 if predicate always returns a boolean false value.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    ...
+  7. Return -1𝔽.
+includes: [testBigIntTypedArray.js]
+features: [BigInt, TypedArray, array-find-from-last]
+---*/
+
+testWithBigIntTypedArrayConstructors(function(TA) {
+  var sample = new TA([1n, 2n, 3n]);
+  var called = 0;
+
+  var result = sample.findLastIndex(function() {
+    called++;
+    return false;
+  });
+
+  assert.sameValue(called, 3, "predicate was called three times");
+  assert.sameValue(result, -1, "result is -1 when predicate returns are false");
+
+  result = sample.findLastIndex(function() { return ""; });
+  assert.sameValue(result, -1, "ToBoolean(string)");
+
+  result = sample.findLastIndex(function() { return undefined; });
+  assert.sameValue(result, -1, "ToBoolean(undefined)");
+
+  result = sample.findLastIndex(function() { return null; });
+  assert.sameValue(result, -1, "ToBoolean(null)");
+
+  result = sample.findLastIndex(function() { return 0; });
+  assert.sameValue(result, -1, "ToBoolean(0)");
+
+  result = sample.findLastIndex(function() { return -0; });
+  assert.sameValue(result, -1, "ToBoolean(-0)");
+
+  result = sample.findLastIndex(function() { return NaN; });
+  assert.sameValue(result, -1, "ToBoolean(NaN)");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/shell.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/shell.js
new file mode 100644
index 0000000000..90ee9c114d
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/BigInt/shell.js
@@ -0,0 +1,42 @@
+// GENERATED, DO NOT EDIT
+// file: testBigIntTypedArray.js
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: |
+    Collection of functions used to assert the correctness of BigInt TypedArray objects.
+defines:
+  - TypedArray
+  - testWithBigIntTypedArrayConstructors
+---*/
+
+/**
+ * The %TypedArray% intrinsic constructor function.
+ */
+var TypedArray = Object.getPrototypeOf(Int8Array);
+
+/**
+ * Calls the provided function for every typed array constructor.
+ *
+ * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor.
+ * @param {Array} selected - An optional Array with filtered typed arrays
+ */
+function testWithBigIntTypedArrayConstructors(f, selected) {
+  /**
+   * Array containing every BigInt typed array constructor.
+   */
+  var constructors = selected || [
+    BigInt64Array,
+    BigUint64Array
+  ];
+
+  for (var i = 0; i < constructors.length; ++i) {
+    var constructor = constructors[i];
+    try {
+      f(constructor);
+    } catch (e) {
+      e.message += " (Testing with " + constructor.name + ".)";
+      throw e;
+    }
+  }
+}
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/browser.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/browser.js
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/callbackfn-resize.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/callbackfn-resize.js
new file mode 100644
index 0000000000..49814daf75
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/callbackfn-resize.js
@@ -0,0 +1,76 @@
+// |reftest| shell-option(--enable-arraybuffer-resizable) skip-if(!ArrayBuffer.prototype.resize||!xulRuntime.shell) -- resizable-arraybuffer is not enabled unconditionally, requires shell-options
+// Copyright (C) 2021 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Instance buffer can be resized during iteration
+includes: [testTypedArray.js, compareArray.js]
+features: [TypedArray, resizable-arraybuffer]
+---*/
+
+// If the host chooses to throw as allowed by the specification, the observed
+// behavior will be identical to the case where `ArrayBuffer.prototype.resize`
+// has not been implemented. The following assertion prevents this test from
+// passing in runtimes which have not implemented the method.
+assert.sameValue(typeof ArrayBuffer.prototype.resize, 'function');
+
+testWithTypedArrayConstructors(function(TA) {
+  var BPE = TA.BYTES_PER_ELEMENT;
+  var buffer = new ArrayBuffer(BPE * 3, {maxByteLength: BPE * 4});
+  var sample = new TA(buffer);
+  var secondElement, expectedElements, expectedIndices, expectedArrays;
+  var elements, indices, arrays, result;
+
+  elements = [];
+  indices = [];
+  arrays = [];
+  result = sample.findLastIndex(function(element, index, array) {
+    if (elements.length === 0) {
+      try {
+        buffer.resize(BPE);
+        secondElement = undefined;
+        expectedElements = [0];
+        expectedIndices = [0];
+        expectedArrays = [sample];
+      } catch (_) {
+        secondElement = 0;
+        expectedElements = [0, 0, 0];
+        expectedIndices = [2, 1, 0];
+        expectedArrays = [sample, sample, sample];
+      }
+    }
+
+    elements.push(element);
+    indices.push(index);
+    arrays.push(array);
+    return false;
+  });
+
+  assert.compareArray(elements, [0, secondElement, 0], 'elements (shrink)');
+  assert.compareArray(indices, [2, 1, 0], 'indices (shrink)');
+  assert.compareArray(arrays, [sample, sample, sample], 'arrays (shrink)');
+  assert.sameValue(result, -1, 'result (shrink)');
+
+  elements = [];
+  indices = [];
+  arrays = [];
+  result = sample.findLastIndex(function(element, index, array) {
+    if (elements.length === 0) {
+      try {
+        buffer.resize(4 * BPE);
+      } catch (_) {}
+    }
+
+    elements.push(element);
+    indices.push(index);
+    arrays.push(array);
+    return false;
+  });
+
+  assert.compareArray(elements, expectedElements, 'elements (grow)');
+  assert.compareArray(indices, expectedIndices, 'indices (grow)');
+  assert.compareArray(arrays, expectedArrays, 'arrays (grow)');
+  assert.sameValue(result, -1, 'result (grow)');
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/detached-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/detached-buffer.js
new file mode 100644
index 0000000000..953b277879
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/detached-buffer.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Throws a TypeError if this has a detached buffer
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  2. Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  ...
+  5. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
+  ...
+includes: [testTypedArray.js, detachArrayBuffer.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var predicate = function() {
+  throw new Test262Error();
+};
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  $DETACHBUFFER(sample.buffer);
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(predicate);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/get-length-ignores-length-prop.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/get-length-ignores-length-prop.js
new file mode 100644
index 0000000000..389ec09afa
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/get-length-ignores-length-prop.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  [[Get]] of "length" uses [[ArrayLength]]
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  3. Let len be O.[[ArrayLength]].
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+Object.defineProperty(TypedArray.prototype, "length", {
+  get: function() {
+    throw new Test262Error();
+  }
+});
+
+testWithTypedArrayConstructors(function(TA) {
+  Object.defineProperty(TA.prototype, "length", {
+    get: function() {
+      throw new Test262Error();
+    }
+  });
+
+  var sample = new TA([42]);
+
+  Object.defineProperty(sample, "length", {
+    get: function() {
+      throw new Test262Error();
+    },
+    configurable: true
+  });
+
+  assert.sameValue(
+    sample.findLastIndex(function() { return true; }),
+    0
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-func.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-func.js
new file mode 100644
index 0000000000..bec6bb9b56
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-func.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Throws a TypeError exception when invoked as a function
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  2. Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  1. If Type(O) is not Object, throw a TypeError exception.
+  2. If O does not have a [[TypedArrayName]] internal slot, throw a TypeError
+  exception.
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var findLastIndex = TypedArray.prototype.findLastIndex;
+
+assert.sameValue(typeof findLastIndex, 'function');
+
+assert.throws(TypeError, function() {
+  findLastIndex();
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-method.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-method.js
new file mode 100644
index 0000000000..89ee3f90f7
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/invoked-as-method.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Requires a [[TypedArrayName]] internal slot.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  1. If Type(O) is not Object, throw a TypeError exception.
+  2. If O does not have a [[TypedArrayName]] internal slot, throw a TypeError
+  exception.
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var TypedArrayPrototype = TypedArray.prototype;
+
+assert.sameValue(typeof TypedArrayPrototype.findLastIndex, 'function');
+
+assert.throws(TypeError, function() {
+  TypedArrayPrototype.findLastIndex();
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/length.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/length.js
new file mode 100644
index 0000000000..9586c335a5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/length.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  %TypedArray%.prototype.findLastIndex.length is 1.
+info: |
+  %TypedArray%.prototype.findLastIndex (predicate [ , thisArg ] )
+
+  17 ECMAScript Standard Built-in Objects:
+    Every built-in Function object, including constructors, has a length
+    property whose value is an integer. Unless otherwise specified, this
+    value is equal to the largest number of named arguments shown in the
+    subclause headings for the function description, including optional
+    parameters. However, rest parameters shown using the form “...name”
+    are not included in the default argument 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, testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+assert.sameValue(TypedArray.prototype.findLastIndex.length, 1);
+
+verifyProperty(TypedArray.prototype.findLastIndex, "length", {
+  enumerable: false,
+  writable: false,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/name.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/name.js
new file mode 100644
index 0000000000..87e4639963
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/name.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  %TypedArray%.prototype.findLastIndex.name is "findLastIndex".
+info: |
+  %TypedArray%.prototype.findLastIndex (predicate [ , thisArg ] )
+
+  17 ECMAScript Standard Built-in Objects:
+    Every built-in Function object, including constructors, that is not
+    identified as an anonymous function has a name property whose value
+    is a String.
+
+    Unless otherwise specified, the name property of a built-in Function
+    object, if it exists, has the attributes { [[Writable]]: false,
+    [[Enumerable]]: false, [[Configurable]]: true }.
+includes: [propertyHelper.js, testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+assert.sameValue(TypedArray.prototype.findLastIndex.name, "findLastIndex");
+
+verifyProperty(TypedArray.prototype.findLastIndex, "name", {
+  enumerable: false,
+  writable: false,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/not-a-constructor.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/not-a-constructor.js
new file mode 100644
index 0000000000..ec57906ae8
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/not-a-constructor.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-ecmascript-standard-built-in-objects
+description: >
+  TypedArray.prototype.findLastIndex does not implement [[Construct]], is not new-able
+info: |
+  ECMAScript Function Objects
+
+  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.
+
+  sec-evaluatenew
+
+  ...
+  7. If IsConstructor(constructor) is false, throw a TypeError exception.
+  ...
+includes: [isConstructor.js, testTypedArray.js]
+features: [Reflect.construct, arrow-function, TypedArray, array-find-from-last]
+---*/
+
+assert.sameValue(
+  isConstructor(TypedArray.prototype.findLastIndex),
+  false,
+  'isConstructor(TypedArray.prototype.findLastIndex) must return false'
+);
+
+assert.throws(TypeError, () => {
+  let u8 = new Uint8Array(1); new u8.findLastIndex(() => {});
+}, '`let u8 = new Uint8Array(1); new u8.findLastIndex(() => {})` throws TypeError');
+
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-changes-value.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-changes-value.js
new file mode 100644
index 0000000000..d288354edd
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-changes-value.js
@@ -0,0 +1,60 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Change values during predicate call
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [compareArray.js, testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var arr = [10, 20, 30];
+  var sample;
+  var result;
+
+  sample = new TA(3);
+  sample.findLastIndex(function(val, i) {
+    sample[i] = arr[i];
+
+    assert.sameValue(val, 0, "value is not mapped to instance");
+  });
+  assert(compareArray(sample, arr), "values set during each predicate call");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i === 2 ) {
+      sample[0] = 7;
+    }
+    return val === 7;
+  });
+  assert.sameValue(result, 0, "value found");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i === 2 ) {
+      sample[0] = 7;
+    }
+    return val === 10;
+  });
+  assert.sameValue(result, -1, "value not found");
+
+  sample = new TA(arr);
+  result = sample.findLastIndex(function(val, i) {
+    if ( i < 2) {
+      sample[2] = 7;
+    }
+    return val === 7;
+  });
+  assert.sameValue(result, -1, "value not found - changed after call");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-parameters.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-parameters.js
new file mode 100644
index 0000000000..6fd62813ea
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-parameters.js
@@ -0,0 +1,52 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate called as F.call( thisArg, kValue, k, O ) for each array entry.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 2, 62]);
+  var results = [];
+  var result;
+
+  sample.foo = "bar"; // Ignores non integer index properties
+
+  sample.findLastIndex(function() {
+    results.push(arguments);
+  });
+
+  assert.sameValue(results.length, 3, "predicate is called for each index");
+
+  result = results[0];
+  assert.sameValue(result[0], 62, "results[0][0] === 62, value");
+  assert.sameValue(result[1], 2, "results[0][1] === 2, index");
+  assert.sameValue(result[2], sample, "results[0][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[0].length === 3, arguments");
+
+  result = results[1];
+  assert.sameValue(result[0], 2, "results[1][0] === 2, value");
+  assert.sameValue(result[1], 1, "results[1][1] === 1, index");
+  assert.sameValue(result[2], sample, "results[1][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[1].length === 3, arguments");
+
+  result = results[2];
+  assert.sameValue(result[0], 39, "results[2][0] === 39, value");
+  assert.sameValue(result[1], 0, "results[2][1] === 0, index");
+  assert.sameValue(result[2], sample, "results[2][2] === sample, instance");
+  assert.sameValue(result.length, 3, "results[2].length === 3, arguments");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-non-strict.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-non-strict.js
new file mode 100644
index 0000000000..3c82732709
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-non-strict.js
@@ -0,0 +1,49 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Verify predicate this on non-strict mode
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+flags: [noStrict]
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var T = this;
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  var result;
+
+  sample.findLastIndex(function() {
+    result = this;
+  });
+
+  assert.sameValue(result, T, "without thisArg, predicate this is the global");
+
+  result = null;
+  sample.findLastIndex(function() {
+    result = this;
+  }, undefined);
+
+  assert.sameValue(result, T, "predicate this is the global when thisArg is undefined");
+
+  var o = {};
+  result = null;
+  sample.findLastIndex(function() {
+    result = this;
+  }, o);
+
+  assert.sameValue(result, o, "thisArg becomes the predicate this");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-strict-strict.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-strict-strict.js
new file mode 100644
index 0000000000..db22a84372
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-call-this-strict-strict.js
@@ -0,0 +1,44 @@
+'use strict';
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate thisArg as F.call( thisArg, kValue, k, O ) for each array entry.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+flags: [onlyStrict]
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  var result;
+
+  sample.findLastIndex(function() {
+    result = this;
+  });
+
+  assert.sameValue(
+    result,
+    undefined,
+    "without thisArg, predicate this is undefined"
+  );
+
+  var o = {};
+  sample.findLastIndex(function() {
+    result = this;
+  }, o);
+
+  assert.sameValue(result, o, "thisArg becomes the predicate this");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-is-not-callable-throws.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-is-not-callable-throws.js
new file mode 100644
index 0000000000..3785ecdac2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-is-not-callable-throws.js
@@ -0,0 +1,57 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Throws a TypeError exception if predicate is not callable.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  4. If IsCallable(predicate) is false, throw a TypeError exception.
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+  assert.throws(TypeError, function() {
+    sample.findLastIndex({});
+  }, "{}");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(null);
+  }, "null");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(undefined);
+  }, "undefined");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(false);
+  }, "false");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(true);
+  }, "true");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(1);
+  }, "1");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex("");
+  }, "string");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex([]);
+  }, "[]");
+
+  assert.throws(TypeError, function() {
+    sample.findLastIndex(/./);
+  }, "/./");
+});
+
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-may-detach-buffer.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-may-detach-buffer.js
new file mode 100644
index 0000000000..9edb72ff2f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-may-detach-buffer.js
@@ -0,0 +1,39 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate may detach the buffer
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0,
+    a. Let Pk be ! ToString(𝔽(k)).
+    b. Let kValue be ! Get(O, Pk).
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+
+  IntegerIndexedElementGet ( O, index )
+
+    Let buffer be the value of O's [[ViewedArrayBuffer]] internal slot.
+    If IsDetachedBuffer(buffer) is true, return undefined.
+
+includes: [testTypedArray.js, detachArrayBuffer.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(2);
+  var loops = 0;
+
+  sample.findLastIndex(function() {
+    if (loops === 0) {
+      $DETACHBUFFER(sample.buffer);
+    }
+    loops++;
+  });
+  assert.sameValue(loops, 2, "predicate is called once");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-not-called-on-empty-array.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-not-called-on-empty-array.js
new file mode 100644
index 0000000000..857a521897
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/predicate-not-called-on-empty-array.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Predicate is not called on an empty instance
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    ...
+  7. Return -1.
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA();
+  var called = false;
+
+  var predicate = function() {
+    called = true;
+    return true;
+  };
+
+  var result = sample.findLastIndex(predicate);
+
+  assert.sameValue(
+    called, false,
+    "does not call predicate"
+  );
+  assert.sameValue(
+    result, -1,
+    "returns -1 on an empty instance"
+  );
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/prop-desc.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/prop-desc.js
new file mode 100644
index 0000000000..344ab98b2f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/prop-desc.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  "findLastIndex" property of TypedArrayPrototype
+info: |
+  ES6 section 17: Every other data property described in clauses 18 through 26
+  and in Annex B.2 has the attributes { [[Writable]]: true,
+  [[Enumerable]]: false, [[Configurable]]: true } unless otherwise specified.
+includes: [propertyHelper.js, testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var TypedArrayPrototype = TypedArray.prototype;
+
+verifyProperty(TypedArray.prototype, "findLastIndex", {
+  enumerable: false,
+  writable: true,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-predicate-call.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-predicate-call.js
new file mode 100644
index 0000000000..e615464938
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-predicate-call.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return abrupt from predicate call.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var predicate = function() {
+  throw new Test262Error();
+};
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA(1);
+  assert.throws(Test262Error, function() {
+    sample.findLastIndex(predicate);
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-this-out-of-bounds.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-this-out-of-bounds.js
new file mode 100644
index 0000000000..52ab6a5cd6
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-abrupt-from-this-out-of-bounds.js
@@ -0,0 +1,62 @@
+// |reftest| shell-option(--enable-arraybuffer-resizable) skip-if(!ArrayBuffer.prototype.resize||!xulRuntime.shell) -- resizable-arraybuffer is not enabled unconditionally, requires shell-options
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Return abrupt when "this" value fails buffer boundary checks
+includes: [testTypedArray.js]
+features: [TypedArray, resizable-arraybuffer, array-find-from-last]
+---*/
+
+assert.sameValue(
+  typeof TypedArray.prototype.findLastIndex,
+  'function',
+  'implements TypedArray.prototype.findLastIndex'
+);
+
+assert.sameValue(
+  typeof ArrayBuffer.prototype.resize,
+  'function',
+  'implements ArrayBuffer.prototype.resize'
+);
+
+testWithTypedArrayConstructors(TA => {
+  var BPE = TA.BYTES_PER_ELEMENT;
+  var ab = new ArrayBuffer(BPE * 4, {maxByteLength: BPE * 5});
+  var array = new TA(ab, BPE, 2);
+
+  try {
+    ab.resize(BPE * 5);
+  } catch (_) {}
+
+  // no error following grow:
+  array.findLastIndex(() => {});
+
+  try {
+    ab.resize(BPE * 3);
+  } catch (_) {}
+
+  // no error following shrink (within bounds):
+  array.findLastIndex(() => {});
+
+  var expectedError;
+  try {
+    ab.resize(BPE * 2);
+    // If the preceding "resize" operation is successful, the typed array will
+    // be out out of bounds, so the subsequent prototype method should produce
+    // a TypeError due to the semantics of ValidateTypedArray.
+    expectedError = TypeError;
+  } catch (_) {
+    // The host is permitted to fail any "resize" operation at its own
+    // discretion. If that occurs, the findLastIndex operation should complete
+    // successfully.
+    expectedError = Test262Error;
+  }
+
+  assert.throws(expectedError, () => {
+    array.findLastIndex(() => {});
+    throw new Test262Error('findLastIndex completed successfully');
+  });
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-index-predicate-result-is-true.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-index-predicate-result-is-true.js
new file mode 100644
index 0000000000..c81fb38cdf
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-index-predicate-result-is-true.js
@@ -0,0 +1,58 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return index if predicate return a boolean true value.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    d. If testResult is true, return 𝔽(k).
+  ...
+includes: [testTypedArray.js]
+features: [Symbol, TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([39, 3, 9]);
+  var called = 0;
+
+  var result = sample.findLastIndex(function() {
+    called++;
+    return true;
+  });
+
+  assert.sameValue(result, 2, "returned true on sample[2]");
+  assert.sameValue(called, 1, "predicate was called once");
+
+  called = 0;
+  result = sample.findLastIndex(function(val) {
+    called++;
+    return val === 39;
+  });
+
+  assert.sameValue(called, 3, "predicate was called three times");
+  assert.sameValue(result, 0, "returned true on sample[0]");
+
+  result = sample.findLastIndex(function() { return "string"; });
+  assert.sameValue(result, 2, "ToBoolean(string)");
+
+  result = sample.findLastIndex(function() { return {}; });
+  assert.sameValue(result, 2, "ToBoolean(object)");
+
+  result = sample.findLastIndex(function() { return Symbol(""); });
+  assert.sameValue(result, 2, "ToBoolean(symbol)");
+
+  result = sample.findLastIndex(function() { return 1; });
+  assert.sameValue(result, 2, "ToBoolean(number)");
+
+  result = sample.findLastIndex(function() { return -1; });
+  assert.sameValue(result, 2, "ToBoolean(negative number)");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-negative-one-if-predicate-returns-false-value.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-negative-one-if-predicate-returns-false-value.js
new file mode 100644
index 0000000000..e535075e9b
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/return-negative-one-if-predicate-returns-false-value.js
@@ -0,0 +1,52 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Return -1 if predicate always returns a boolean false value.
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  5. Let k be len - 1.
+  6. Repeat, while k ≥ 0
+    ...
+    c. Let testResult be ! ToBoolean(? Call(predicate, thisArg, « kValue, 𝔽(k), O »)).
+    ...
+  7. Return -1𝔽.
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+testWithTypedArrayConstructors(function(TA) {
+  var sample = new TA([1, 2, 3]);
+  var called = 0;
+
+  var result = sample.findLastIndex(function() {
+    called++;
+    return false;
+  });
+
+  assert.sameValue(called, 3, "predicate was called three times");
+  assert.sameValue(result, -1, "result is -1 when predicate returns are false");
+
+  result = sample.findLastIndex(function() { return ""; });
+  assert.sameValue(result, -1, "ToBoolean(string)");
+
+  result = sample.findLastIndex(function() { return undefined; });
+  assert.sameValue(result, -1, "ToBoolean(undefined)");
+
+  result = sample.findLastIndex(function() { return null; });
+  assert.sameValue(result, -1, "ToBoolean(null)");
+
+  result = sample.findLastIndex(function() { return 0; });
+  assert.sameValue(result, -1, "ToBoolean(0)");
+
+  result = sample.findLastIndex(function() { return -0; });
+  assert.sameValue(result, -1, "ToBoolean(-0)");
+
+  result = sample.findLastIndex(function() { return NaN; });
+  assert.sameValue(result, -1, "ToBoolean(NaN)");
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/shell.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/shell.js
new file mode 100644
index 0000000000..eda1477282
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/shell.js
@@ -0,0 +1,24 @@
+// GENERATED, DO NOT EDIT
+// file: isConstructor.js
+// Copyright (C) 2017 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+description: |
+    Test if a given function is a constructor function.
+defines: [isConstructor]
+features: [Reflect.construct]
+---*/
+
+function isConstructor(f) {
+    if (typeof f !== "function") {
+      throw new Test262Error("isConstructor invoked with a non-function value");
+    }
+
+    try {
+        Reflect.construct(function(){}, [], f);
+    } catch (e) {
+        return false;
+    }
+    return true;
+}
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-object.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-object.js
new file mode 100644
index 0000000000..1dbfc3115f
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-object.js
@@ -0,0 +1,53 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: Throws a TypeError exception when `this` is not Object
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  2. Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  1. If Type(O) is not Object, throw a TypeError exception.
+  ...
+includes: [testTypedArray.js]
+features: [Symbol, TypedArray, array-find-from-last]
+---*/
+
+var findLastIndex = TypedArray.prototype.findLastIndex;
+var predicate = function() {};
+
+assert.throws(TypeError, function() {
+  findLastIndex.call(undefined, predicate);
+}, "this is undefined");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call(null, predicate);
+}, "this is null");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call(42, predicate);
+}, "this is 42");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call("1", predicate);
+}, "this is a string");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call(true, predicate);
+}, "this is true");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call(false, predicate);
+}, "this is false");
+
+var s = Symbol("s");
+assert.throws(TypeError, function() {
+  findLastIndex.call(s, predicate);
+}, "this is a Symbol");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-typedarray-instance.js b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-typedarray-instance.js
new file mode 100644
index 0000000000..cc92b40bec
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArray/prototype/findLastIndex/this-is-not-typedarray-instance.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2021 Microsoft. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-%typedarray%.prototype.findlastindex
+description: >
+  Throws a TypeError exception when `this` is not a TypedArray instance
+info: |
+  %TypedArray%.prototype.findLastIndex ( predicate [ , thisArg ] )
+
+  ...
+  2. Perform ? ValidateTypedArray(O).
+  ...
+
+  22.2.3.5.1 Runtime Semantics: ValidateTypedArray ( O )
+
+  1. If Type(O) is not Object, throw a TypeError exception.
+  2. If O does not have a [[TypedArrayName]] internal slot, throw a TypeError
+  exception.
+  ...
+includes: [testTypedArray.js]
+features: [TypedArray, array-find-from-last]
+---*/
+
+var findLastIndex = TypedArray.prototype.findLastIndex;
+var predicate = function() {};
+
+assert.throws(TypeError, function() {
+  findLastIndex.call({}, predicate);
+}, "this is an Object");
+
+assert.throws(TypeError, function() {
+  findLastIndex.call([], predicate);
+}, "this is an Array");
+
+var ab = new ArrayBuffer(8);
+assert.throws(TypeError, function() {
+  findLastIndex.call(ab, predicate);
+}, "this is an ArrayBuffer instance");
+
+var dv = new DataView(new ArrayBuffer(8), 0, 1);
+assert.throws(TypeError, function() {
+  findLastIndex.call(dv, predicate);
+}, "this is a DataView instance");
+
+reportCompare(0, 0);