Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

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

16 files changed, 1062 insertions, 0 deletions

diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/arithmetic.js b/js/src/tests/test262/built-ins/BigInt/asUintN/arithmetic.js
new file mode 100644
index 0000000000..443f13c60c
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/arithmetic.js
@@ -0,0 +1,71 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-bigint.asuintn
+description: BigInt.asUintN arithmetic test cases
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  3. Return a BigInt representing bigint modulo 2**bits.
+
+features: [BigInt]
+---*/
+
+assert.sameValue(BigInt.asUintN(0, -2n), 0n);
+assert.sameValue(BigInt.asUintN(0, -1n), 0n);
+assert.sameValue(BigInt.asUintN(0, 0n), 0n);
+assert.sameValue(BigInt.asUintN(0, 1n), 0n);
+assert.sameValue(BigInt.asUintN(0, 2n), 0n);
+
+assert.sameValue(BigInt.asUintN(1, -3n), 1n);
+assert.sameValue(BigInt.asUintN(1, -2n), 0n);
+assert.sameValue(BigInt.asUintN(1, -1n), 1n);
+assert.sameValue(BigInt.asUintN(1, 0n), 0n);
+assert.sameValue(BigInt.asUintN(1, 1n), 1n);
+assert.sameValue(BigInt.asUintN(1, 2n), 0n);
+assert.sameValue(BigInt.asUintN(1, 3n), 1n);
+assert.sameValue(BigInt.asUintN(1, -123456789012345678901n), 1n);
+assert.sameValue(BigInt.asUintN(1, -123456789012345678900n), 0n);
+assert.sameValue(BigInt.asUintN(1, 123456789012345678900n), 0n);
+assert.sameValue(BigInt.asUintN(1, 123456789012345678901n), 1n);
+
+assert.sameValue(BigInt.asUintN(2, -3n), 1n);
+assert.sameValue(BigInt.asUintN(2, -2n), 2n);
+assert.sameValue(BigInt.asUintN(2, -1n), 3n);
+assert.sameValue(BigInt.asUintN(2, 0n), 0n);
+assert.sameValue(BigInt.asUintN(2, 1n), 1n);
+assert.sameValue(BigInt.asUintN(2, 2n), 2n);
+assert.sameValue(BigInt.asUintN(2, 3n), 3n);
+assert.sameValue(BigInt.asUintN(2, -123456789012345678901n), 3n);
+assert.sameValue(BigInt.asUintN(2, -123456789012345678900n), 0n);
+assert.sameValue(BigInt.asUintN(2, 123456789012345678900n), 0n);
+assert.sameValue(BigInt.asUintN(2, 123456789012345678901n), 1n);
+
+assert.sameValue(BigInt.asUintN(8, 0xabn), 0xabn);
+assert.sameValue(BigInt.asUintN(8, 0xabcdn), 0xcdn);
+assert.sameValue(BigInt.asUintN(8, 0xabcdef01n), 0x01n);
+assert.sameValue(BigInt.asUintN(8, 0xabcdef0123456789abcdef0123n), 0x23n);
+assert.sameValue(BigInt.asUintN(8, 0xabcdef0123456789abcdef0183n), 0x83n);
+
+assert.sameValue(BigInt.asUintN(64, 0xabcdef0123456789abcdefn), 0x0123456789abcdefn);
+assert.sameValue(BigInt.asUintN(65, 0xabcdef0123456789abcdefn), 0x10123456789abcdefn);
+
+assert.sameValue(BigInt.asUintN(200,
+    0xbffffffffffffffffffffffffffffffffffffffffffffffffffn),
+  0x0ffffffffffffffffffffffffffffffffffffffffffffffffffn
+);
+assert.sameValue(BigInt.asUintN(201,
+    0xbffffffffffffffffffffffffffffffffffffffffffffffffffn),
+  0x1ffffffffffffffffffffffffffffffffffffffffffffffffffn
+);
+
+assert.sameValue(BigInt.asUintN(200,
+    0xb89e081df68b65fedb32cffea660e55df9605650a603ad5fc54n),
+  0x089e081df68b65fedb32cffea660e55df9605650a603ad5fc54n
+);
+assert.sameValue(BigInt.asUintN(201,
+    0xb89e081df68b65fedb32cffea660e55df9605650a603ad5fc54n),
+  0x189e081df68b65fedb32cffea660e55df9605650a603ad5fc54n
+);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/asUintN.js b/js/src/tests/test262/built-ins/BigInt/asUintN/asUintN.js
new file mode 100644
index 0000000000..195b536eaf
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/asUintN.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-bigint.asuintn
+description: BigInt.asUintN property descriptor
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+features: [BigInt]
+---*/
+
+assert.sameValue(typeof BigInt.asUintN, 'function');
+
+verifyProperty(BigInt, "asUintN", {
+  enumerable: false,
+  writable: true,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-errors.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-errors.js
new file mode 100644
index 0000000000..031b946704
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-errors.js
@@ -0,0 +1,173 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bigint parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  2. Let bigint ? ToBigInt(bigint).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+assert.sameValue(typeof BigInt, 'function');
+assert.sameValue(typeof BigInt.asUintN, 'function');
+
+assert.throws(TypeError, function () {
+  BigInt.asUintN();
+}, "ToBigInt: no argument => undefined => TypeError");
+assert.throws(TypeError, function () {
+  BigInt.asUintN(0);
+}, "ToBigInt: no argument => undefined => TypeError");
+
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, undefined);
+}, "ToBigInt: undefined => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return undefined;
+    }
+  });
+}, "ToBigInt: @@toPrimitive => undefined => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return undefined;
+    }
+  });
+}, "ToBigInt: valueOf => undefined => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      return undefined;
+    }
+  });
+}, "ToBigInt: toString => undefined => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, null);
+}, "ToBigInt: null => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return null;
+    }
+  });
+}, "ToBigInt: @@toPrimitive => null => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return null;
+    }
+  });
+}, "ToBigInt: valueOf => null => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      return null;
+    }
+  });
+}, "ToBigInt: toString => null => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, 0);
+}, "ToBigInt: Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, Object(0));
+}, "ToBigInt: unbox object with internal slot => Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return 0;
+    }
+  });
+}, "ToBigInt: @@toPrimitive => Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return 0;
+    }
+  });
+}, "ToBigInt: valueOf => Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      return 0;
+    }
+  });
+}, "ToBigInt: toString => Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, NaN);
+}, "ToBigInt: Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, Infinity);
+}, "ToBigInt: Number => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, Symbol("1"));
+}, "ToBigInt: Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, Object(Symbol("1")));
+}, "ToBigInt: unbox object with internal slot => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return Symbol("1");
+    }
+  });
+}, "ToBigInt: @@toPrimitive => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return Symbol("1");
+    }
+  });
+}, "ToBigInt: valueOf => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      return Symbol("1");
+    }
+  });
+}, "ToBigInt: toString => Symbol => TypeError");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "a");
+}, "ToBigInt: unparseable BigInt");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "0b2");
+}, "ToBigInt: unparseable BigInt binary");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, Object("0b2"));
+}, "ToBigInt: unbox object with internal slot => unparseable BigInt binary");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return "0b2";
+    }
+  });
+}, "ToBigInt: @@toPrimitive => unparseable BigInt binary");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return "0b2";
+    }
+  });
+}, "ToBigInt: valueOf => unparseable BigInt binary");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      return "0b2";
+    }
+  });
+}, "ToBigInt: toString => unparseable BigInt binary");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "   0b2   ");
+}, "ToBigInt: unparseable BigInt with leading/trailing whitespace");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "0o8");
+}, "ToBigInt: unparseable BigInt octal");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "0xg");
+}, "ToBigInt: unparseable BigInt hex");
+assert.throws(SyntaxError, function() {
+  BigInt.asUintN(0, "1n");
+}, "ToBigInt: unparseable BigInt due to literal suffix");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-toprimitive.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-toprimitive.js
new file mode 100644
index 0000000000..bda1fca2d8
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-toprimitive.js
@@ -0,0 +1,169 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bigint parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  2. Let bigint ? ToBigInt(bigint).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+assert.sameValue(typeof BigInt, 'function');
+assert.sameValue(typeof BigInt.asUintN, 'function');
+
+function err() {
+  throw new Test262Error();
+}
+
+function MyError() {}
+
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: function() {
+    return "1";
+  },
+  valueOf: err,
+  toString: err
+}), 1n, "ToPrimitive: @@toPrimitive takes precedence");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return "1";
+  },
+  toString: err
+}), 1n, "ToPrimitive: valueOf takes precedence over toString");
+assert.sameValue(BigInt.asUintN(2, {
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: toString with no valueOf");
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: undefined,
+  valueOf: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip @@toPrimitive when it's undefined");
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: null,
+  valueOf: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip @@toPrimitive when it's null");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: null,
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: 1,
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: {},
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return {};
+  },
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip valueOf when it returns an object");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return Object(12345);
+  },
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToPrimitive: skip valueOf when it returns an object");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: 1
+  });
+}, "ToPrimitive: throw when @@toPrimitive is not callable");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: {}
+  });
+}, "ToPrimitive: throw when @@toPrimitive is not callable");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return Object(1);
+    }
+  });
+}, "ToPrimitive: throw when @@toPrimitive returns an object");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      return {};
+    }
+  });
+}, "ToPrimitive: throw when @@toPrimitive returns an object");
+assert.throws(MyError, function() {
+  BigInt.asUintN(0, {
+    [Symbol.toPrimitive]: function() {
+      throw new MyError();
+    }
+  });
+}, "ToPrimitive: propagate errors from @@toPrimitive");
+assert.throws(MyError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      throw new MyError();
+    }
+  });
+}, "ToPrimitive: propagate errors from valueOf");
+assert.throws(MyError, function() {
+  BigInt.asUintN(0, {
+    toString: function() {
+      throw new MyError();
+    }
+  });
+}, "ToPrimitive: propagate errors from toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: null,
+    toString: null
+  });
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: 1,
+    toString: 1
+  });
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: {},
+    toString: {}
+  });
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return Object(1);
+    },
+    toString: function() {
+      return Object(1);
+    }
+  });
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0, {
+    valueOf: function() {
+      return {};
+    },
+    toString: function() {
+      return {};
+    }
+  });
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-wrapped-values.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-wrapped-values.js
new file mode 100644
index 0000000000..1c4105114a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint-wrapped-values.js
@@ -0,0 +1,64 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bigint parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  2. Let bigint ? ToBigInt(bigint).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+
+assert.sameValue(BigInt.asUintN(2, Object(0n)), 0n, "ToPrimitive: unbox object with internal slot");
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: function() {
+    return 0n;
+  }
+}), 0n, "ToPrimitive: @@toPrimitive");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return 0n;
+  }
+}), 0n, "ToPrimitive: valueOf");
+assert.sameValue(BigInt.asUintN(2, {
+  toString: function() {
+    return 0n;
+  }
+}), 0n, "ToPrimitive: toString");
+assert.sameValue(BigInt.asUintN(2, Object(true)), 1n,
+  "ToBigInt: unbox object with internal slot => true => 1n");
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: function() {
+    return true;
+  }
+}), 1n, "ToBigInt: @@toPrimitive => true => 1n");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return true;
+  }
+}), 1n, "ToBigInt: valueOf => true => 1n");
+assert.sameValue(BigInt.asUintN(2, {
+  toString: function() {
+    return true;
+  }
+}), 1n, "ToBigInt: toString => true => 1n");
+assert.sameValue(BigInt.asUintN(2, Object("1")), 1n,
+  "ToBigInt: unbox object with internal slot => parse BigInt");
+assert.sameValue(BigInt.asUintN(2, {
+  [Symbol.toPrimitive]: function() {
+    return "1";
+  }
+}), 1n, "ToBigInt: @@toPrimitive => parse BigInt");
+assert.sameValue(BigInt.asUintN(2, {
+  valueOf: function() {
+    return "1";
+  }
+}), 1n, "ToBigInt: valueOf => parse BigInt");
+assert.sameValue(BigInt.asUintN(2, {
+  toString: function() {
+    return "1";
+  }
+}), 1n, "ToBigInt: toString => parse BigInt");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint.js
new file mode 100644
index 0000000000..37e2da165a
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bigint-tobigint.js
@@ -0,0 +1,51 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bigint parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  2. Let bigint ? ToBigInt(bigint).
+features: [BigInt]
+---*/
+
+assert.sameValue(BigInt.asUintN(2, 0n), 0n);
+assert.sameValue(BigInt.asUintN(2, -0n), 0n);
+assert.sameValue(BigInt.asUintN(2, false), 0n, "ToBigInt: false => 0n");
+assert.sameValue(BigInt.asUintN(2, true), 1n, "ToBigInt: true => 1n");
+assert.sameValue(BigInt.asUintN(2, "1"), 1n, "ToBigInt: parse BigInt");
+assert.sameValue(BigInt.asUintN(2, "-0"), 0n, "ToBigInt: parse BigInt");
+assert.sameValue(BigInt.asUintN(2, ""), 0n, "ToBigInt: empty String => 0n");
+assert.sameValue(BigInt.asUintN(2, "     "), 0n, "ToBigInt: String with only whitespace => 0n");
+assert.sameValue(BigInt.asUintN(2, []), 0n, "ToBigInt: .toString() => empty String => 0n");
+assert.sameValue(BigInt.asUintN(2, [1]), 1n, "ToBigInt: .toString() => parse BigInt");
+assert.sameValue(BigInt.asUintN(3, 10n), 2n);
+assert.sameValue(BigInt.asUintN(3, "10"), 2n, "ToBigInt: parse BigInt");
+assert.sameValue(BigInt.asUintN(3, "0b1010"), 2n, "ToBigInt: parse BigInt binary");
+assert.sameValue(BigInt.asUintN(3, "0o12"), 2n, "ToBigInt: parse BigInt octal");
+assert.sameValue(BigInt.asUintN(3, "0xa"), 2n, "ToBigInt: parse BigInt hex");
+assert.sameValue(BigInt.asUintN(3, "    0xa    "), 2n,
+  "ToBigInt: parse BigInt ignore leading/trailing whitespace");
+assert.sameValue(BigInt.asUintN(3, "     10     "), 2n,
+  "ToBigInt: parse BigInt ignore leading/trailing whitespace");
+assert.sameValue(BigInt.asUintN(3, [10n]), 2n, "ToBigInt: .toString() => parse BigInt");
+assert.sameValue(BigInt.asUintN(3, ["10"]), 2n, "ToBigInt: .toString() => parse BigInt");
+assert.sameValue(BigInt.asUintN(4, 12345678901234567890003n), 3n);
+assert.sameValue(BigInt.asUintN(4, "12345678901234567890003"), 3n, "ToBigInt: parse BigInt");
+assert.sameValue(BigInt.asUintN(4,
+    "0b10100111010100001010110110010011100111011001110001010000100100010001010011"), 3n,
+  "ToBigInt: parse BigInt binary");
+assert.sameValue(BigInt.asUintN(4, "0o2472412662347316120442123"), 3n,
+  "ToBigInt: parse BigInt octal");
+assert.sameValue(BigInt.asUintN(4, "0x29d42b64e7671424453"), 3n, "ToBigInt: parse BigInt hex");
+assert.sameValue(BigInt.asUintN(4, "    0x29d42b64e7671424453    "), 3n,
+  "ToBigInt: parse BigInt ignore leading/trailing whitespace");
+assert.sameValue(BigInt.asUintN(4, "     12345678901234567890003     "), 3n,
+  "ToBigInt: parse BigInt ignore leading/trailing whitespace");
+assert.sameValue(BigInt.asUintN(4, [12345678901234567890003n]), 3n,
+  "ToBigInt: .toString() => parse BigInt");
+assert.sameValue(BigInt.asUintN(4, ["12345678901234567890003"]), 3n,
+  "ToBigInt: .toString() => parse BigInt");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-errors.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-errors.js
new file mode 100644
index 0000000000..59280fbdc2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-errors.js
@@ -0,0 +1,88 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bits parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  1. Let bits be ? ToIndex(bits).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+assert.sameValue(typeof BigInt, 'function');
+assert.sameValue(typeof BigInt.asUintN, 'function');
+
+assert.throws(RangeError, function() {
+  BigInt.asUintN(-1, 0n);
+}, "ToIndex: throw when integerIndex < 0");
+assert.throws(RangeError, function() {
+  BigInt.asUintN(-2.5, 0n);
+}, "ToIndex: throw when integerIndex < 0");
+assert.throws(RangeError, function() {
+  BigInt.asUintN("-2.5", 0n);
+}, "ToIndex: parse Number => throw when integerIndex < 0");
+assert.throws(RangeError, function() {
+  BigInt.asUintN(-Infinity, 0n);
+}, "ToIndex: throw when integerIndex < 0");
+assert.throws(RangeError, function() {
+  BigInt.asUintN(9007199254740992, 0n);
+}, "ToIndex: throw when integerIndex > 2**53-1");
+assert.throws(RangeError, function() {
+  BigInt.asUintN(Infinity, 0n);
+}, "ToIndex: throw when integerIndex > 2**53-1");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(0n, 0n);
+}, "ToIndex: BigInt => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(Object(0n), 0n);
+}, "ToIndex: unbox object with internal slot => BigInt => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: function() {
+      return 0n;
+    }
+  }, 0n);
+}, "ToIndex: @@toPrimitive => BigInt => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: function() {
+      return 0n;
+    }
+  }, 0n);
+}, "ToIndex: valueOf => BigInt => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    toString: function() {
+      return 0n;
+    }
+  }, 0n);
+}, "ToIndex: toString => BigInt => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(Symbol("1"), 0n);
+}, "ToIndex: Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN(Object(Symbol("1")), 0n);
+}, "ToIndex: unbox object with internal slot => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: function() {
+      return Symbol("1");
+    }
+  }, 0n);
+}, "ToIndex: @@toPrimitive => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: function() {
+      return Symbol("1");
+    }
+  }, 0n);
+}, "ToIndex: valueOf => Symbol => TypeError");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    toString: function() {
+      return Symbol("1");
+    }
+  }, 0n);
+}, "ToIndex: toString => Symbol => TypeError");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-toprimitive.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-toprimitive.js
new file mode 100644
index 0000000000..30008284c3
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-toprimitive.js
@@ -0,0 +1,169 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bits parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  1. Let bits be ? ToIndex(bits).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+assert.sameValue(typeof BigInt, 'function');
+assert.sameValue(typeof BigInt.asUintN, 'function');
+
+function err() {
+  throw new Test262Error();
+}
+
+function MyError() {}
+
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return 1;
+  },
+  valueOf: err,
+  toString: err
+}, 1n), 1n, "ToPrimitive: @@toPrimitive takes precedence");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return 1;
+  },
+  toString: err
+}, 1n), 1n, "ToPrimitive: valueOf takes precedence over toString");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: toString with no valueOf");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: undefined,
+  valueOf: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip @@toPrimitive when it's undefined");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: null,
+  valueOf: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip @@toPrimitive when it's null");
+assert.sameValue(BigInt.asUintN({
+  valueOf: null,
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN({
+  valueOf: 1,
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN({
+  valueOf: {},
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip valueOf when it's not callable");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return {};
+  },
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip valueOf when it returns an object");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return Object(12345);
+  },
+  toString: function() {
+    return 1;
+  }
+}, 1n), 1n, "ToPrimitive: skip valueOf when it returns an object");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: 1
+  }, 0n);
+}, "ToPrimitive: throw when @@toPrimitive is not callable");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: {}
+  }, 0n);
+}, "ToPrimitive: throw when @@toPrimitive is not callable");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: function() {
+      return Object(1);
+    }
+  }, 0n);
+}, "ToPrimitive: throw when @@toPrimitive returns an object");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: function() {
+      return {};
+    }
+  }, 0n);
+}, "ToPrimitive: throw when @@toPrimitive returns an object");
+assert.throws(MyError, function() {
+  BigInt.asUintN({
+    [Symbol.toPrimitive]: function() {
+      throw new MyError();
+    }
+  }, 0n);
+}, "ToPrimitive: propagate errors from @@toPrimitive");
+assert.throws(MyError, function() {
+  BigInt.asUintN({
+    valueOf: function() {
+      throw new MyError();
+    }
+  }, 0n);
+}, "ToPrimitive: propagate errors from valueOf");
+assert.throws(MyError, function() {
+  BigInt.asUintN({
+    toString: function() {
+      throw new MyError();
+    }
+  }, 0n);
+}, "ToPrimitive: propagate errors from toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: null,
+    toString: null
+  }, 0n);
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: 1,
+    toString: 1
+  }, 0n);
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: {},
+    toString: {}
+  }, 0n);
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: function() {
+      return Object(1);
+    },
+    toString: function() {
+      return Object(1);
+    }
+  }, 0n);
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+assert.throws(TypeError, function() {
+  BigInt.asUintN({
+    valueOf: function() {
+      return {};
+    },
+    toString: function() {
+      return {};
+    }
+  }, 0n);
+}, "ToPrimitive: throw when skipping both valueOf and toString");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-wrapped-values.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-wrapped-values.js
new file mode 100644
index 0000000000..ab18dcaf06
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex-wrapped-values.js
@@ -0,0 +1,111 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bits parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  1. Let bits be ? ToIndex(bits).
+features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
+---*/
+
+assert.sameValue(BigInt.asUintN(Object(0), 1n), 0n, "ToPrimitive: unbox object with internal slot");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return 0;
+  }
+}, 1n), 0n, "ToPrimitive: @@toPrimitive");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return 0;
+  }
+}, 1n), 0n, "ToPrimitive: valueOf");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return 0;
+  }
+}, 1n), 0n, "ToPrimitive: toString");
+assert.sameValue(BigInt.asUintN(Object(NaN), 1n), 0n,
+  "ToIndex: unbox object with internal slot => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return NaN;
+  }
+}, 1n), 0n, "ToIndex: @@toPrimitive => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return NaN;
+  }
+}, 1n), 0n, "ToIndex: valueOf => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return NaN;
+  }
+}, 1n), 0n, "ToIndex: toString => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return undefined;
+  }
+}, 1n), 0n, "ToIndex: @@toPrimitive => undefined => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return undefined;
+  }
+}, 1n), 0n, "ToIndex: valueOf => undefined => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return undefined;
+  }
+}, 1n), 0n, "ToIndex: toString => undefined => NaN => 0");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return null;
+  }
+}, 1n), 0n, "ToIndex: @@toPrimitive => null => 0");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return null;
+  }
+}, 1n), 0n, "ToIndex: valueOf => null => 0");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return null;
+  }
+}, 1n), 0n, "ToIndex: toString => null => 0");
+assert.sameValue(BigInt.asUintN(Object(true), 1n), 1n,
+  "ToIndex: unbox object with internal slot => true => 1");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return true;
+  }
+}, 1n), 1n, "ToIndex: @@toPrimitive => true => 1");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return true;
+  }
+}, 1n), 1n, "ToIndex: valueOf => true => 1");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return true;
+  }
+}, 1n), 1n, "ToIndex: toString => true => 1");
+assert.sameValue(BigInt.asUintN(Object("1"), 1n), 1n,
+  "ToIndex: unbox object with internal slot => parse Number");
+assert.sameValue(BigInt.asUintN({
+  [Symbol.toPrimitive]: function() {
+    return "1";
+  }
+}, 1n), 1n, "ToIndex: @@toPrimitive => parse Number");
+assert.sameValue(BigInt.asUintN({
+  valueOf: function() {
+    return "1";
+  }
+}, 1n), 1n, "ToIndex: valueOf => parse Number");
+assert.sameValue(BigInt.asUintN({
+  toString: function() {
+    return "1";
+  }
+}, 1n), 1n, "ToIndex: toString => parse Number");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex.js b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex.js
new file mode 100644
index 0000000000..f04dfa070e
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/bits-toindex.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+description: BigInt.asUintN type coercion for bits parameter
+esid: sec-bigint.asuintn
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  1. Let bits be ? ToIndex(bits).
+features: [BigInt]
+---*/
+
+assert.sameValue(BigInt.asUintN(0, 1n), 0n);
+assert.sameValue(BigInt.asUintN(1, 1n), 1n);
+assert.sameValue(BigInt.asUintN(-0.9, 1n), 0n, "ToIndex: truncate towards 0");
+assert.sameValue(BigInt.asUintN(0.9, 1n), 0n, "ToIndex: truncate towards 0");
+assert.sameValue(BigInt.asUintN(NaN, 1n), 0n, "ToIndex: NaN => 0");
+assert.sameValue(BigInt.asUintN(undefined, 1n), 0n, "ToIndex: undefined => NaN => 0");
+assert.sameValue(BigInt.asUintN(null, 1n), 0n, "ToIndex: null => 0");
+assert.sameValue(BigInt.asUintN(false, 1n), 0n, "ToIndex: false => 0");
+assert.sameValue(BigInt.asUintN(true, 1n), 1n, "ToIndex: true => 1");
+assert.sameValue(BigInt.asUintN("0", 1n), 0n, "ToIndex: parse Number");
+assert.sameValue(BigInt.asUintN("1", 1n), 1n, "ToIndex: parse Number");
+assert.sameValue(BigInt.asUintN("", 1n), 0n, "ToIndex: parse Number => NaN => 0");
+assert.sameValue(BigInt.asUintN("foo", 1n), 0n, "ToIndex: parse Number => NaN => 0");
+assert.sameValue(BigInt.asUintN("true", 1n), 0n, "ToIndex: parse Number => NaN => 0");
+assert.sameValue(BigInt.asUintN(3, 10n), 2n);
+assert.sameValue(BigInt.asUintN("3", 10n), 2n, "toIndex: parse Number");
+assert.sameValue(BigInt.asUintN(3.9, 10n), 2n, "toIndex: truncate towards 0");
+assert.sameValue(BigInt.asUintN("3.9", 10n), 2n, "toIndex: parse Number => truncate towards 0");
+assert.sameValue(BigInt.asUintN([0], 1n), 0n, 'ToIndex: [0].toString() => "0" => 0');
+assert.sameValue(BigInt.asUintN(["1"], 1n), 1n, 'ToIndex: ["1"].toString() => "1" => 1');
+assert.sameValue(BigInt.asUintN({}, 1n), 0n,
+  'ToIndex: ({}).toString() => "[object Object]" => NaN => 0');
+assert.sameValue(BigInt.asUintN([], 1n), 0n, 'ToIndex: [].toString() => "" => NaN => 0');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/browser.js b/js/src/tests/test262/built-ins/BigInt/asUintN/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/browser.js
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/length.js b/js/src/tests/test262/built-ins/BigInt/asUintN/length.js
new file mode 100644
index 0000000000..8155411171
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-bigint.asuintn
+description: BigInt.asUintN.length descriptor
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+features: [BigInt]
+---*/
+
+verifyProperty(BigInt.asUintN, "length", {
+  value: 2,
+  enumerable: false,
+  writable: false,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/name.js b/js/src/tests/test262/built-ins/BigInt/asUintN/name.js
new file mode 100644
index 0000000000..b3520892a2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-bigint.asuintn
+description: BigInt.asUintN.name descriptor
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+features: [BigInt]
+---*/
+
+verifyProperty(BigInt.asUintN, "name", {
+  value: "asUintN",
+  enumerable: false,
+  writable: false,
+  configurable: true
+});
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/not-a-constructor.js b/js/src/tests/test262/built-ins/BigInt/asUintN/not-a-constructor.js
new file mode 100644
index 0000000000..e1208f5886
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/not-a-constructor.js
@@ -0,0 +1,28 @@
+// 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: >
+  BigInt.asUintN 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]
+features: [Reflect.construct, BigInt, arrow-function]
+---*/
+assert.sameValue(isConstructor(BigInt.asUintN), false, 'isConstructor(BigInt.asUintN) must return false');
+
+assert.throws(TypeError, () => {
+  new BigInt.asUintN(64, 1n);
+}, '`new BigInt.asUintN(64, 1n)` throws TypeError');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/order-of-steps.js b/js/src/tests/test262/built-ins/BigInt/asUintN/order-of-steps.js
new file mode 100644
index 0000000000..d957e66859
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/order-of-steps.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2017 Josh Wolfe. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-bigint.asuintn
+description: BigInt.asUintN order of parameter type coercion
+info: |
+  BigInt.asUintN ( bits, bigint )
+
+  1. Let bits be ? ToIndex(bits).
+  2. Let bigint ? ToBigInt(bigint).
+
+features: [BigInt]
+---*/
+
+var i = 0;
+var bits = {
+  valueOf() {
+    assert.sameValue(i, 0);
+    i++;
+    return 0;
+  }
+};
+var bigint = {
+  valueOf() {
+    assert.sameValue(i, 1);
+    i++;
+    return 0n;
+  }
+};
+
+BigInt.asUintN(bits, bigint);
+assert.sameValue(i, 2);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/test262/built-ins/BigInt/asUintN/shell.js b/js/src/tests/test262/built-ins/BigInt/asUintN/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/test262/built-ins/BigInt/asUintN/shell.js