Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

15 files changed, 393 insertions, 0 deletions

diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/BYTES_PER_ELEMENT.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/BYTES_PER_ELEMENT.js
new file mode 100644
index 0000000000..db3c16b120
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/BYTES_PER_ELEMENT.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray.bytes_per_element
+description: >
+  The initial value of Uint16Array.BYTES_PER_ELEMENT is 2.
+info: |
+  The value of TypedArray.BYTES_PER_ELEMENT is the Number value of the
+  Element Size value specified in Table 49 for TypedArray.
+
+  This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
+includes: [propertyHelper.js]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Uint16Array.BYTES_PER_ELEMENT, 2);
+
+verifyNotEnumerable(Uint16Array, "BYTES_PER_ELEMENT");
+verifyNotWritable(Uint16Array, "BYTES_PER_ELEMENT");
+verifyNotConfigurable(Uint16Array, "BYTES_PER_ELEMENT");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/browser.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/browser.js
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/constructor.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/constructor.js
new file mode 100644
index 0000000000..fa1bd2dbde
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/constructor.js
@@ -0,0 +1,13 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray-constructors
+description: >
+  Uint16Array is a constructor function.
+features: [TypedArray]
+---*/
+
+assert.sameValue(typeof Uint16Array, 'function', 'typeof Uint16Array is "function"');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/is-a-constructor.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/is-a-constructor.js
new file mode 100644
index 0000000000..7f78905d2a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/is-a-constructor.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2020 Rick Waldron. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-ecmascript-standard-built-in-objects
+description: >
+  The Uint16Array constructor implements [[Construct]]
+info: |
+  IsConstructor ( argument )
+
+  The abstract operation IsConstructor takes argument argument (an ECMAScript language value).
+  It determines if argument is a function object with a [[Construct]] internal method.
+  It performs the following steps when called:
+
+  If Type(argument) is not Object, return false.
+  If argument has a [[Construct]] internal method, return true.
+  Return false.
+includes: [isConstructor.js]
+features: [Reflect.construct, TypedArray]
+---*/
+
+assert.sameValue(isConstructor(Uint16Array), true, 'isConstructor(Uint16Array) must return true');
+new Uint16Array();
+  
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/length.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/length.js
new file mode 100644
index 0000000000..ae7d22ccd5
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/length.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray-constructors
+description: Uint16Array.length property descriptor
+info: |
+  The TypedArray Constructors
+
+  The length property of the TypedArray constructor function is 3.
+
+  17 ECMAScript Standard Built-in Objects
+
+  ...
+
+  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: [TypedArray]
+---*/
+
+verifyProperty(Uint16Array, "length", {
+  value: 3,
+  writable: false,
+  enumerable: false,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/name.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/name.js
new file mode 100644
index 0000000000..35e59e9927
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/name.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-properties-of-the-typedarray-constructors
+description: >
+  Uint16Array.name is "Uint16Array".
+info: |
+  Each TypedArray constructor has a name property whose value is the
+  String value of the constructor name specified for it in Table 49.
+
+  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]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Uint16Array.name, "Uint16Array");
+
+verifyNotEnumerable(Uint16Array, "name");
+verifyNotWritable(Uint16Array, "name");
+verifyConfigurable(Uint16Array, "name");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/proto.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/proto.js
new file mode 100644
index 0000000000..1926d6eefe
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/proto.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-properties-of-the-typedarray-constructors
+description: >
+  The prototype of Uint16Array is %TypedArray%.
+info: |
+  The value of the [[Prototype]] internal slot of each TypedArray constructor is the %TypedArray% intrinsic object (22.2.1).
+includes: [testTypedArray.js]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Object.getPrototypeOf(Uint16Array), TypedArray);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype.js
new file mode 100644
index 0000000000..2aef9dea51
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray.prototype
+description: >
+  The initial value of Uint16Array.prototype is the Uint16Array prototype object.
+info: |
+  The initial value of TypedArray.prototype is the corresponding TypedArray prototype intrinsic object (22.2.6).
+
+  This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
+includes: [propertyHelper.js]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Uint16Array.prototype, Object.getPrototypeOf(new Uint16Array(0)));
+
+verifyNotEnumerable(Uint16Array, "prototype");
+verifyNotWritable(Uint16Array, "prototype");
+verifyNotConfigurable(Uint16Array, "prototype");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/BYTES_PER_ELEMENT.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/BYTES_PER_ELEMENT.js
new file mode 100644
index 0000000000..ebb9c9555b
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/BYTES_PER_ELEMENT.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray.prototype.bytes_per_element
+description: >
+  The initial value of Uint16Array.prototype.BYTES_PER_ELEMENT is 2.
+info: |
+  The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number value
+  of the Element Size value specified in Table 49 for TypedArray.
+
+  This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
+includes: [propertyHelper.js]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Uint16Array.prototype.BYTES_PER_ELEMENT, 2);
+
+verifyNotEnumerable(Uint16Array.prototype, "BYTES_PER_ELEMENT");
+verifyNotWritable(Uint16Array.prototype, "BYTES_PER_ELEMENT");
+verifyNotConfigurable(Uint16Array.prototype, "BYTES_PER_ELEMENT");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/browser.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/browser.js
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/constructor.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/constructor.js
new file mode 100644
index 0000000000..3be3a992dc
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/constructor.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-typedarray.prototype.constructor
+description: >
+  The initial value of Uint16Array.prototype.constructor is the Uint16Array object.
+info: |
+  The initial value of Uint16Array.prototype.constructor is the intrinsic
+  object %Uint16Array%.
+
+  17 ECMAScript Standard Built-in Objects:
+    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]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Uint16Array.prototype.constructor, Uint16Array);
+
+verifyNotEnumerable(Uint16Array.prototype, "constructor");
+verifyWritable(Uint16Array.prototype, "constructor");
+verifyConfigurable(Uint16Array.prototype, "constructor");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/not-typedarray-object.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/not-typedarray-object.js
new file mode 100644
index 0000000000..10e2c7123a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/not-typedarray-object.js
@@ -0,0 +1,19 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-properties-of-typedarray-prototype-objects
+description: >
+  Uint16Array.prototype is not a TypedArray instance object.
+info: |
+  A TypedArray prototype object is an ordinary object. It does not have
+  a [[ViewedArrayBuffer]] or any other of the internal slots that are
+  specific to TypedArray instance objects.
+features: [TypedArray]
+---*/
+
+assert.throws(TypeError, function() {
+  Uint16Array.prototype.buffer;
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/proto.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/proto.js
new file mode 100644
index 0000000000..b28264d2f9
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/proto.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2015 André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-properties-of-typedarray-prototype-objects
+description: >
+  The prototype of Uint16Array.prototype is %TypedArrayPrototype%.
+info: |
+  The value of the [[Prototype]] internal slot of a TypedArray prototype
+  object is the intrinsic object %TypedArrayPrototype% (22.2.3).
+includes: [testTypedArray.js]
+features: [TypedArray]
+---*/
+
+assert.sameValue(Object.getPrototypeOf(Uint16Array.prototype), TypedArray.prototype);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/shell.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/prototype/shell.js
diff --git a/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/shell.js b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/shell.js
new file mode 100644
index 0000000000..7b3c8c67d8
--- /dev/null
+++ b/js/src/tests/test262/built-ins/TypedArrayConstructors/Uint16Array/shell.js
@@ -0,0 +1,148 @@
+// 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;
+}
+
+// file: testTypedArray.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 TypedArray objects.
+defines:
+  - typedArrayConstructors
+  - floatArrayConstructors
+  - intArrayConstructors
+  - TypedArray
+  - testWithTypedArrayConstructors
+  - testWithAtomicsFriendlyTypedArrayConstructors
+  - testWithNonAtomicsFriendlyTypedArrayConstructors
+  - testTypedArrayConversions
+---*/
+
+/**
+ * Array containing every typed array constructor.
+ */
+var typedArrayConstructors = [
+  Float64Array,
+  Float32Array,
+  Int32Array,
+  Int16Array,
+  Int8Array,
+  Uint32Array,
+  Uint16Array,
+  Uint8Array,
+  Uint8ClampedArray
+];
+
+var floatArrayConstructors = typedArrayConstructors.slice(0, 2);
+var intArrayConstructors = typedArrayConstructors.slice(2, 7);
+
+/**
+ * The %TypedArray% intrinsic constructor function.
+ */
+var TypedArray = Object.getPrototypeOf(Int8Array);
+
+/**
+ * Callback for testing a typed array constructor.
+ *
+ * @callback typedArrayConstructorCallback
+ * @param {Function} Constructor the constructor object to test with.
+ */
+
+/**
+ * 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 testWithTypedArrayConstructors(f, selected) {
+  var constructors = selected || typedArrayConstructors;
+  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;
+    }
+  }
+}
+
+/**
+ * Calls the provided function for every non-"Atomics Friendly" 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 testWithNonAtomicsFriendlyTypedArrayConstructors(f) {
+  testWithTypedArrayConstructors(f, [
+    Float64Array,
+    Float32Array,
+    Uint8ClampedArray
+  ]);
+}
+
+/**
+ * Calls the provided function for every "Atomics Friendly" 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 testWithAtomicsFriendlyTypedArrayConstructors(f) {
+  testWithTypedArrayConstructors(f, [
+    Int32Array,
+    Int16Array,
+    Int8Array,
+    Uint32Array,
+    Uint16Array,
+    Uint8Array,
+  ]);
+}
+
+/**
+ * Helper for conversion operations on TypedArrays, the expected values
+ * properties are indexed in order to match the respective value for each
+ * TypedArray constructor
+ * @param  {Function} fn - the function to call for each constructor and value.
+ *                         will be called with the constructor, value, expected
+ *                         value, and a initial value that can be used to avoid
+ *                         a false positive with an equivalent expected value.
+ */
+function testTypedArrayConversions(byteConversionValues, fn) {
+  var values = byteConversionValues.values;
+  var expected = byteConversionValues.expected;
+
+  testWithTypedArrayConstructors(function(TA) {
+    var name = TA.name.slice(0, -5);
+
+    return values.forEach(function(value, index) {
+      var exp = expected[name][index];
+      var initial = 0;
+      if (exp === 0) {
+        initial = 1;
+      }
+      fn(TA, value, exp, initial);
+    });
+  });
+}