diff --git a/test/built-ins/BigInt/asIntN/bigint-tobigint.js b/test/built-ins/BigInt/asIntN/bigint-tobigint.js index 568f00c503a..a0611038a03 100644 --- a/test/built-ins/BigInt/asIntN/bigint-tobigint.js +++ b/test/built-ins/BigInt/asIntN/bigint-tobigint.js @@ -1,33 +1,697 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: pending description: BigInt.asIntN type coercion for bigint parameter -info: > +esid: pending +info: | BigInt.asIntN ( bits, bigint ) 2. Let bigint ? ToBigInt(bigint). - -features: [BigInt, Symbol, Symbol.toPrimitive] -includes: [typeCoercion.js] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToBigIntZero(function(zero) { - assert.sameValue(BigInt.asIntN(2, zero), 0n); -}); - -testCoercibleToBigIntOne(function(one) { - assert.sameValue(BigInt.asIntN(2, one), 1n); -}); - -testCoercibleToBigIntFromBigInt(10n, function(ten) { - assert.sameValue(BigInt.asIntN(3, ten), 2n); -}); - -testCoercibleToBigIntFromBigInt(12345678901234567890003n, function(value) { - assert.sameValue(BigInt.asIntN(4, value), 3n); -}); +function err() { + throw new Test262Error(); +} -testNotCoercibleToBigInt(function(error, value) { - assert.throws(error, function() { BigInt.asIntN(0, value); }); -}); +assert.sameValue(BigInt.asIntN(2, 0n), 0n); +assert.sameValue(BigInt.asIntN(2, Object(0n)), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return 0n; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return 0n; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, "0"), 0n); +assert.sameValue(BigInt.asIntN(2, Object("0")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, "0b0"), 0n); +assert.sameValue(BigInt.asIntN(2, Object("0b0")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0b0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0b0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, "0o"), 0n); +assert.sameValue(BigInt.asIntN(2, Object("0o")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0o"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0o"; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, "0x0"), 0n); +assert.sameValue(BigInt.asIntN(2, Object("0x0")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0x0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0x0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, " 0 "), 0n); +assert.sameValue(BigInt.asIntN(2, Object(" 0 ")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return " 0 "; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return " 0 "; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, [0n]), 0n); +assert.sameValue(BigInt.asIntN(2, ["0"]), 0n); +assert.sameValue(BigInt.asIntN(2, -0n), 0n); +assert.sameValue(BigInt.asIntN(2, Object(-0n)), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return -0n; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return -0n; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asIntN(2, "-0"), 0n); +assert.sameValue(BigInt.asIntN(2, Object("-0")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "-0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "-0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asIntN(2, false), 0n); +assert.sameValue(BigInt.asIntN(2, Object(false)), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return false; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asIntN(2, ""), 0n); +assert.sameValue(BigInt.asIntN(2, Object("")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return ""; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asIntN(2, " "), 0n); +assert.sameValue(BigInt.asIntN(2, Object(" ")), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return " "; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return " "; }, toString: err}), 0n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asIntN(2, []), 0n); +assert.sameValue(BigInt.asIntN(2, [0]), 0n); +assert.sameValue(BigInt.asIntN(2, 1n), 1n); +assert.sameValue(BigInt.asIntN(2, Object(1n)), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return 1n; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return 1n; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asIntN(2, "1"), 1n); +assert.sameValue(BigInt.asIntN(2, Object("1")), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, "0b1"), 1n); +assert.sameValue(BigInt.asIntN(2, Object("0b1")), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0b1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0b1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, "0o1"), 1n); +assert.sameValue(BigInt.asIntN(2, Object("0o1")), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0o1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0o1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, "0x1"), 1n); +assert.sameValue(BigInt.asIntN(2, Object("0x1")), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return "0x1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return "0x1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asIntN(2, " 1 "), 1n); +assert.sameValue(BigInt.asIntN(2, Object(" 1 ")), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return " 1 "; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return " 1 "; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asIntN(2, [1n]), 1n); +assert.sameValue(BigInt.asIntN(2, ["1"]), 1n); +assert.sameValue(BigInt.asIntN(2, true), 1n); +assert.sameValue(BigInt.asIntN(2, Object(true)), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return true; }, toString: err}), 1n); +assert.sameValue(BigInt.asIntN(2, {toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: null, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: 1, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: {}, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return {}; }, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, {valueOf: function() { return Object(1); }, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asIntN(2, [1]), 1n); +assert.sameValue(BigInt.asIntN(3, 10n), 2n); +assert.sameValue(BigInt.asIntN(3, Object(10n)), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return 10n; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return 10n; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asIntN(3, "10"), 2n); +assert.sameValue(BigInt.asIntN(3, Object("10")), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return "10"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return "10"; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, "0b1010"), 2n); +assert.sameValue(BigInt.asIntN(3, Object("0b1010")), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return "0b1010"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return "0b1010"; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, "0o12"), 2n); +assert.sameValue(BigInt.asIntN(3, Object("0o12")), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return "0o12"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return "0o12"; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, "0xa"), 2n); +assert.sameValue(BigInt.asIntN(3, Object("0xa")), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return "0xa"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return "0xa"; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asIntN(3, " 10 "), 2n); +assert.sameValue(BigInt.asIntN(3, Object(" 10 ")), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: function() { return " 10 "; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return " 10 "; }, toString: err}), 2n); +assert.sameValue(BigInt.asIntN(3, {toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: null, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: 1, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: {}, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return {}; }, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, {valueOf: function() { return Object(1); }, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asIntN(3, [10n]), 2n); +assert.sameValue(BigInt.asIntN(3, ["10"]), 2n); +assert.sameValue(BigInt.asIntN(4, 12345678901234567890003n), 3n); +assert.sameValue(BigInt.asIntN(4, Object(12345678901234567890003n)), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return 12345678901234567890003n; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return 12345678901234567890003n; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asIntN(4, "12345678901234567890003"), 3n); +assert.sameValue(BigInt.asIntN(4, Object("12345678901234567890003")), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return "12345678901234567890003"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return "12345678901234567890003"; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, "0b10100111010100001010110110010011100111011001110001010000100100010001010011"), 3n); +assert.sameValue(BigInt.asIntN(4, Object("0b10100111010100001010110110010011100111011001110001010000100100010001010011")), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, "0o2472412662347316120442123"), 3n); +assert.sameValue(BigInt.asIntN(4, Object("0o2472412662347316120442123")), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return "0o2472412662347316120442123"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return "0o2472412662347316120442123"; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, "0x29d42b64e7671424453"), 3n); +assert.sameValue(BigInt.asIntN(4, Object("0x29d42b64e7671424453")), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return "0x29d42b64e7671424453"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return "0x29d42b64e7671424453"; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asIntN(4, " 12345678901234567890003 "), 3n); +assert.sameValue(BigInt.asIntN(4, Object(" 12345678901234567890003 ")), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: function() { return " 12345678901234567890003 "; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return " 12345678901234567890003 "; }, toString: err}), 3n); +assert.sameValue(BigInt.asIntN(4, {toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: null, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: 1, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: {}, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return {}; }, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, {valueOf: function() { return Object(1); }, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asIntN(4, [12345678901234567890003n]), 3n); +assert.sameValue(BigInt.asIntN(4, ["12345678901234567890003"]), 3n); +assert.throws(TypeError, function() { BigInt.asIntN(0, undefined); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return undefined; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, null); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return null; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, 0); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Object(0)); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return 0; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, NaN); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Object(NaN)); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return NaN; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Infinity); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Object(Infinity)); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return Infinity; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Infinity; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Symbol("1")); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, Object(Symbol("1"))); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return Symbol("1"); }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Symbol("1"); }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return Symbol("1"); }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "a"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("a")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "a"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "a"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " a"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" a")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " a"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " a"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "a "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("a ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "a "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "a "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " a "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" a ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " a "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " a "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0b2"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0b2")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0b2"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0b2"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0b2"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0b2")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0b2"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0b2"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0b2 "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0b2 ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0b2 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0b2 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0b2 "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0b2 ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0b2 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0b2 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0o8"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0o8")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0o8"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0o8"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0o8"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0o8")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0o8"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0o8"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0o8 "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0o8 ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0o8 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0o8 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0o8 "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0o8 ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0o8 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0o8 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0xg"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0xg")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0xg"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0xg"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0xg"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0xg")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0xg"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0xg"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "0xg "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("0xg ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "0xg "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "0xg "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 0xg "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 0xg ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 0xg "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 0xg "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "1n"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("1n")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "1n"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "1n"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 1n"); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 1n")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 1n"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 1n"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, "1n "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object("1n ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return "1n "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return "1n "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, " 1n "); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, Object(" 1n ")); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: function() { return " 1n "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return " 1n "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: null, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: 1, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: {}, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return {}; }, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asIntN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 1n "; }}); }); diff --git a/test/built-ins/BigInt/asIntN/bits-toindex.js b/test/built-ins/BigInt/asIntN/bits-toindex.js index 137fc78806c..9a033ba7f44 100644 --- a/test/built-ins/BigInt/asIntN/bits-toindex.js +++ b/test/built-ins/BigInt/asIntN/bits-toindex.js @@ -1,29 +1,461 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: pending description: BigInt.asIntN type coercion for bits parameter -info: > +esid: pending +info: | BigInt.asIntN ( bits, bigint ) 1. Let bits be ? ToIndex(bits). - -features: [BigInt, Symbol, Symbol.toPrimitive] -includes: [typeCoercion.js] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToIndexZero(function(zero) { - assert.sameValue(BigInt.asIntN(zero, 1n), 0n); -}); - -testCoercibleToIndexOne(function(one) { - assert.sameValue(BigInt.asIntN(one, 1n), -1n); -}); - -testCoercibleToIndexFromIndex(3, function(three) { - assert.sameValue(BigInt.asIntN(three, 10n), 2n); -}); +function err() { + throw new Test262Error(); +} +function MyError() {} -testNotCoercibleToIndex(function(error, value) { - assert.throws(error, function() { BigInt.asIntN(value, 0n); }); -}); +assert.sameValue(BigInt.asIntN(0, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(0), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 0; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(null, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return null; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(false, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(false), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return false; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN("0", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("0"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "0"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(0, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(0), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 0; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN([0], 1n), 0n); +assert.sameValue(BigInt.asIntN("0", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("0"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "0"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(["0"], 1n), 0n); +assert.sameValue(BigInt.asIntN(0.9, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(0.9), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 0.9; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 0.9; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN([0.9], 1n), 0n); +assert.sameValue(BigInt.asIntN("0.9", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("0.9"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "0.9"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "0.9"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(["0.9"], 1n), 0n); +assert.sameValue(BigInt.asIntN(-0.9, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(-0.9), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return -0.9; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return -0.9; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN([-0.9], 1n), 0n); +assert.sameValue(BigInt.asIntN("-0.9", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("-0.9"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "-0.9"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "-0.9"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(["-0.9"], 1n), 0n); +assert.sameValue(BigInt.asIntN(NaN, 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(NaN), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return NaN; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN(undefined, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return undefined; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN("", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object(""), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return ""; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN("foo", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("foo"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "foo"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "foo"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN("true", 1n), 0n); +assert.sameValue(BigInt.asIntN(Object("true"), 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "true"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "true"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asIntN({toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asIntN({}, 1n), 0n); +assert.sameValue(BigInt.asIntN([], 1n), 0n); +assert.sameValue(BigInt.asIntN(1, 1n), -1n); +assert.sameValue(BigInt.asIntN(Object(1), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 1; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN([1], 1n), -1n); +assert.sameValue(BigInt.asIntN("1", 1n), -1n); +assert.sameValue(BigInt.asIntN(Object("1"), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "1"; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN(["1"], 1n), -1n); +assert.sameValue(BigInt.asIntN(1.9, 1n), -1n); +assert.sameValue(BigInt.asIntN(Object(1.9), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 1.9; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 1.9; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 1.9; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN([1.9], 1n), -1n); +assert.sameValue(BigInt.asIntN("1.9", 1n), -1n); +assert.sameValue(BigInt.asIntN(Object("1.9"), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "1.9"; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "1.9"; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "1.9"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN(["1.9"], 1n), -1n); +assert.sameValue(BigInt.asIntN(1, 1n), -1n); +assert.sameValue(BigInt.asIntN(Object(1), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 1; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 1; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN(true, 1n), -1n); +assert.sameValue(BigInt.asIntN(Object(true), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return true; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return true; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN("1", 1n), -1n); +assert.sameValue(BigInt.asIntN(Object("1"), 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "1"; }, toString: err}, 1n), -1n); +assert.sameValue(BigInt.asIntN({toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}, 1n), -1n); +assert.sameValue(BigInt.asIntN([1], 1n), -1n); +assert.sameValue(BigInt.asIntN(["1"], 1n), -1n); +assert.sameValue(BigInt.asIntN(3, 10n), 2n); +assert.sameValue(BigInt.asIntN(Object(3), 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 3; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 3; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN([3], 10n), 2n); +assert.sameValue(BigInt.asIntN("3", 10n), 2n); +assert.sameValue(BigInt.asIntN(Object("3"), 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "3"; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "3"; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN(["3"], 10n), 2n); +assert.sameValue(BigInt.asIntN(3.9, 10n), 2n); +assert.sameValue(BigInt.asIntN(Object(3.9), 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return 3.9; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return 3.9; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN([3.9], 10n), 2n); +assert.sameValue(BigInt.asIntN("3.9", 10n), 2n); +assert.sameValue(BigInt.asIntN(Object("3.9"), 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: function() { return "3.9"; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return "3.9"; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asIntN({toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: null, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: 1, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: {}, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asIntN(["3.9"], 10n), 2n); +assert.throws(TypeError, function() { BigInt.asIntN(Symbol("1"), 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN(Object(Symbol("1")), 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return Symbol("1"); }, valueOf: err, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return Symbol("1"); }, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN(0n, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN(Object(0n), 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return 0n; }, valueOf: err, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return 0n; }, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: 1}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: {}}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return Object(1); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return {}; }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { throw new MyError(); }, valueOf: err, toString: err}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: function() { throw new MyError(); }, toString: err}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: null, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: 1, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: {}, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf:null, toString:null}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf:1, toString:1}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf:{}, toString:{}}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf:function() { return Object(1); }, toString:function() { return Object(1); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asIntN({valueOf:function() { return {}; }, toString:function() { return {}; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(-1, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object(-1), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return -1; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return -1; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(-2.5, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object(-2.5), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return -2.5; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return -2.5; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN("-2.5", 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object("-2.5"), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return "-2.5"; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return "-2.5"; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(-Infinity, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object(-Infinity), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return -Infinity; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return -Infinity; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(9007199254740992, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object(9007199254740992), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return 9007199254740992; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return 9007199254740992; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Infinity, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN(Object(Infinity), 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: function() { return Infinity; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Infinity; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: undefined, valueOf: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({[Symbol.toPrimitive]: null, valueOf: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: null, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: 1, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: {}, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return {}; }, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asIntN({valueOf: function() { return Object(1); }, toString: function() { return Infinity; }}, 0n); }); diff --git a/test/built-ins/BigInt/asUintN/bigint-tobigint.js b/test/built-ins/BigInt/asUintN/bigint-tobigint.js index 2c6229dd108..89233d51b87 100644 --- a/test/built-ins/BigInt/asUintN/bigint-tobigint.js +++ b/test/built-ins/BigInt/asUintN/bigint-tobigint.js @@ -1,33 +1,697 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: pending description: BigInt.asUintN type coercion for bigint parameter -info: > +esid: pending +info: | BigInt.asUintN ( bits, bigint ) 2. Let bigint ? ToBigInt(bigint). - -features: [BigInt, Symbol, Symbol.toPrimitive] -includes: [typeCoercion.js] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToBigIntZero(function(zero) { - assert.sameValue(BigInt.asUintN(2, zero), 0n); -}); - -testCoercibleToBigIntOne(function(one) { - assert.sameValue(BigInt.asUintN(2, one), 1n); -}); - -testCoercibleToBigIntFromBigInt(10n, function(ten) { - assert.sameValue(BigInt.asUintN(3, ten), 2n); -}); - -testCoercibleToBigIntFromBigInt(12345678901234567890003n, function(value) { - assert.sameValue(BigInt.asUintN(4, value), 3n); -}); +function err() { + throw new Test262Error(); +} -testNotCoercibleToBigInt(function(error, value) { - assert.throws(error, function() { BigInt.asUintN(0, value); }); -}); +assert.sameValue(BigInt.asUintN(2, 0n), 0n); +assert.sameValue(BigInt.asUintN(2, Object(0n)), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return 0n; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return 0n; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return 0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, "0"), 0n); +assert.sameValue(BigInt.asUintN(2, Object("0")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, "0b0"), 0n); +assert.sameValue(BigInt.asUintN(2, Object("0b0")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0b0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0b0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0b0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, "0o"), 0n); +assert.sameValue(BigInt.asUintN(2, Object("0o")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0o"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0o"; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0o"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, "0x0"), 0n); +assert.sameValue(BigInt.asUintN(2, Object("0x0")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0x0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0x0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0x0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, " 0 "), 0n); +assert.sameValue(BigInt.asUintN(2, Object(" 0 ")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return " 0 "; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return " 0 "; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return " 0 "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, [0n]), 0n); +assert.sameValue(BigInt.asUintN(2, ["0"]), 0n); +assert.sameValue(BigInt.asUintN(2, -0n), 0n); +assert.sameValue(BigInt.asUintN(2, Object(-0n)), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return -0n; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return -0n; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return -0n; }}), 0n); +assert.sameValue(BigInt.asUintN(2, "-0"), 0n); +assert.sameValue(BigInt.asUintN(2, Object("-0")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "-0"; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "-0"; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "-0"; }}), 0n); +assert.sameValue(BigInt.asUintN(2, false), 0n); +assert.sameValue(BigInt.asUintN(2, Object(false)), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return false; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return false; }}), 0n); +assert.sameValue(BigInt.asUintN(2, ""), 0n); +assert.sameValue(BigInt.asUintN(2, Object("")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return ""; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return ""; }}), 0n); +assert.sameValue(BigInt.asUintN(2, " "), 0n); +assert.sameValue(BigInt.asUintN(2, Object(" ")), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return " "; }, valueOf: err, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return " "; }, toString: err}), 0n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return " "; }}), 0n); +assert.sameValue(BigInt.asUintN(2, []), 0n); +assert.sameValue(BigInt.asUintN(2, [0]), 0n); +assert.sameValue(BigInt.asUintN(2, 1n), 1n); +assert.sameValue(BigInt.asUintN(2, Object(1n)), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return 1n; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return 1n; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return 1n; }}), 1n); +assert.sameValue(BigInt.asUintN(2, "1"), 1n); +assert.sameValue(BigInt.asUintN(2, Object("1")), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, "0b1"), 1n); +assert.sameValue(BigInt.asUintN(2, Object("0b1")), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0b1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0b1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0b1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, "0o1"), 1n); +assert.sameValue(BigInt.asUintN(2, Object("0o1")), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0o1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0o1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0o1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, "0x1"), 1n); +assert.sameValue(BigInt.asUintN(2, Object("0x1")), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return "0x1"; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return "0x1"; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return "0x1"; }}), 1n); +assert.sameValue(BigInt.asUintN(2, " 1 "), 1n); +assert.sameValue(BigInt.asUintN(2, Object(" 1 ")), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return " 1 "; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return " 1 "; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return " 1 "; }}), 1n); +assert.sameValue(BigInt.asUintN(2, [1n]), 1n); +assert.sameValue(BigInt.asUintN(2, ["1"]), 1n); +assert.sameValue(BigInt.asUintN(2, true), 1n); +assert.sameValue(BigInt.asUintN(2, Object(true)), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return true; }, toString: err}), 1n); +assert.sameValue(BigInt.asUintN(2, {toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {[Symbol.toPrimitive]: null, valueOf: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: null, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: 1, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: {}, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return {}; }, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, {valueOf: function() { return Object(1); }, toString: function() { return true; }}), 1n); +assert.sameValue(BigInt.asUintN(2, [1]), 1n); +assert.sameValue(BigInt.asUintN(3, 10n), 2n); +assert.sameValue(BigInt.asUintN(3, Object(10n)), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return 10n; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return 10n; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return 10n; }}), 2n); +assert.sameValue(BigInt.asUintN(3, "10"), 2n); +assert.sameValue(BigInt.asUintN(3, Object("10")), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return "10"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return "10"; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return "10"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, "0b1010"), 2n); +assert.sameValue(BigInt.asUintN(3, Object("0b1010")), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return "0b1010"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return "0b1010"; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0b1010"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, "0o12"), 2n); +assert.sameValue(BigInt.asUintN(3, Object("0o12")), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return "0o12"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return "0o12"; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0o12"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, "0xa"), 2n); +assert.sameValue(BigInt.asUintN(3, Object("0xa")), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return "0xa"; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return "0xa"; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return "0xa"; }}), 2n); +assert.sameValue(BigInt.asUintN(3, " 10 "), 2n); +assert.sameValue(BigInt.asUintN(3, Object(" 10 ")), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: function() { return " 10 "; }, valueOf: err, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return " 10 "; }, toString: err}), 2n); +assert.sameValue(BigInt.asUintN(3, {toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {[Symbol.toPrimitive]: null, valueOf: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: null, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: 1, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: {}, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return {}; }, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, {valueOf: function() { return Object(1); }, toString: function() { return " 10 "; }}), 2n); +assert.sameValue(BigInt.asUintN(3, [10n]), 2n); +assert.sameValue(BigInt.asUintN(3, ["10"]), 2n); +assert.sameValue(BigInt.asUintN(4, 12345678901234567890003n), 3n); +assert.sameValue(BigInt.asUintN(4, Object(12345678901234567890003n)), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return 12345678901234567890003n; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return 12345678901234567890003n; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return 12345678901234567890003n; }}), 3n); +assert.sameValue(BigInt.asUintN(4, "12345678901234567890003"), 3n); +assert.sameValue(BigInt.asUintN(4, Object("12345678901234567890003")), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return "12345678901234567890003"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return "12345678901234567890003"; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return "12345678901234567890003"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, "0b10100111010100001010110110010011100111011001110001010000100100010001010011"), 3n); +assert.sameValue(BigInt.asUintN(4, Object("0b10100111010100001010110110010011100111011001110001010000100100010001010011")), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0b10100111010100001010110110010011100111011001110001010000100100010001010011"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, "0o2472412662347316120442123"), 3n); +assert.sameValue(BigInt.asUintN(4, Object("0o2472412662347316120442123")), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return "0o2472412662347316120442123"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return "0o2472412662347316120442123"; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0o2472412662347316120442123"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, "0x29d42b64e7671424453"), 3n); +assert.sameValue(BigInt.asUintN(4, Object("0x29d42b64e7671424453")), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return "0x29d42b64e7671424453"; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return "0x29d42b64e7671424453"; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return "0x29d42b64e7671424453"; }}), 3n); +assert.sameValue(BigInt.asUintN(4, " 12345678901234567890003 "), 3n); +assert.sameValue(BigInt.asUintN(4, Object(" 12345678901234567890003 ")), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: function() { return " 12345678901234567890003 "; }, valueOf: err, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return " 12345678901234567890003 "; }, toString: err}), 3n); +assert.sameValue(BigInt.asUintN(4, {toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {[Symbol.toPrimitive]: null, valueOf: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: null, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: 1, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: {}, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return {}; }, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, {valueOf: function() { return Object(1); }, toString: function() { return " 12345678901234567890003 "; }}), 3n); +assert.sameValue(BigInt.asUintN(4, [12345678901234567890003n]), 3n); +assert.sameValue(BigInt.asUintN(4, ["12345678901234567890003"]), 3n); +assert.throws(TypeError, function() { BigInt.asUintN(0, undefined); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return undefined; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return undefined; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, null); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return null; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return null; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, 0); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Object(0)); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return 0; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return 0; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, NaN); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Object(NaN)); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return NaN; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return NaN; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Infinity); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Object(Infinity)); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return Infinity; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Infinity; }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return Infinity; }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Symbol("1")); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, Object(Symbol("1"))); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return Symbol("1"); }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Symbol("1"); }, toString: err}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return Symbol("1"); }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "a"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("a")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "a"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "a"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " a"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" a")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " a"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " a"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " a"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "a "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("a ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "a "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "a "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " a "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" a ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " a "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " a "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " a "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0b2"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0b2")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0b2"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0b2"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0b2"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0b2")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0b2"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0b2"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0b2"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0b2 "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0b2 ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0b2 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0b2 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0b2 "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0b2 ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0b2 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0b2 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0b2 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0o8"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0o8")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0o8"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0o8"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0o8"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0o8")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0o8"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0o8"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0o8"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0o8 "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0o8 ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0o8 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0o8 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0o8 "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0o8 ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0o8 "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0o8 "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0o8 "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0xg"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0xg")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0xg"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0xg"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0xg"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0xg")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0xg"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0xg"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0xg"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "0xg "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("0xg ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "0xg "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "0xg "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 0xg "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 0xg ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 0xg "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 0xg "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 0xg "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "1n"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("1n")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "1n"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "1n"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 1n"); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 1n")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 1n"; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 1n"; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 1n"; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, "1n "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object("1n ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return "1n "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return "1n "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return "1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, " 1n "); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, Object(" 1n ")); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: function() { return " 1n "; }, valueOf: err, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return " 1n "; }, toString: err}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: undefined, valueOf: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {[Symbol.toPrimitive]: null, valueOf: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: null, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: 1, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: {}, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return {}; }, toString: function() { return " 1n "; }}); }); +assert.throws(SyntaxError, function() { BigInt.asUintN(0, {valueOf: function() { return Object(1); }, toString: function() { return " 1n "; }}); }); diff --git a/test/built-ins/BigInt/asUintN/bits-toindex.js b/test/built-ins/BigInt/asUintN/bits-toindex.js index 0d999c242e8..03384d9700b 100644 --- a/test/built-ins/BigInt/asUintN/bits-toindex.js +++ b/test/built-ins/BigInt/asUintN/bits-toindex.js @@ -1,29 +1,461 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: pending description: BigInt.asUintN type coercion for bits parameter -info: > +esid: pending +info: | BigInt.asUintN ( bits, bigint ) 1. Let bits be ? ToIndex(bits). - -features: [BigInt, Symbol, Symbol.toPrimitive] -includes: [typeCoercion.js] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToIndexZero(function(zero) { - assert.sameValue(BigInt.asUintN(zero, 1n), 0n); -}); - -testCoercibleToIndexOne(function(one) { - assert.sameValue(BigInt.asUintN(one, 1n), 1n); -}); - -testCoercibleToIndexFromIndex(3, function(three) { - assert.sameValue(BigInt.asUintN(three, 10n), 2n); -}); +function err() { + throw new Test262Error(); +} +function MyError() {} -testNotCoercibleToIndex(function(error, value) { - assert.throws(error, function() { BigInt.asUintN(value, 0n); }); -}); +assert.sameValue(BigInt.asUintN(0, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(0), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 0; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(null, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return null; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return null; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(false, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(false), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return false; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return false; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN("0", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("0"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "0"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(0, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(0), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 0; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 0; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN([0], 1n), 0n); +assert.sameValue(BigInt.asUintN("0", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("0"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "0"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(["0"], 1n), 0n); +assert.sameValue(BigInt.asUintN(0.9, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(0.9), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 0.9; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 0.9; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN([0.9], 1n), 0n); +assert.sameValue(BigInt.asUintN("0.9", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("0.9"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "0.9"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "0.9"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(["0.9"], 1n), 0n); +assert.sameValue(BigInt.asUintN(-0.9, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(-0.9), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return -0.9; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return -0.9; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return -0.9; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN([-0.9], 1n), 0n); +assert.sameValue(BigInt.asUintN("-0.9", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("-0.9"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "-0.9"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "-0.9"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "-0.9"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(["-0.9"], 1n), 0n); +assert.sameValue(BigInt.asUintN(NaN, 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(NaN), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return NaN; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return NaN; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN(undefined, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return undefined; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return undefined; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN("", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object(""), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return ""; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return ""; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN("foo", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("foo"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "foo"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "foo"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "foo"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN("true", 1n), 0n); +assert.sameValue(BigInt.asUintN(Object("true"), 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "true"; }, valueOf: err, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "true"; }, toString: err}, 1n), 0n); +assert.sameValue(BigInt.asUintN({toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "true"; }}, 1n), 0n); +assert.sameValue(BigInt.asUintN({}, 1n), 0n); +assert.sameValue(BigInt.asUintN([], 1n), 0n); +assert.sameValue(BigInt.asUintN(1, 1n), 1n); +assert.sameValue(BigInt.asUintN(Object(1), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 1; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN([1], 1n), 1n); +assert.sameValue(BigInt.asUintN("1", 1n), 1n); +assert.sameValue(BigInt.asUintN(Object("1"), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "1"; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN(["1"], 1n), 1n); +assert.sameValue(BigInt.asUintN(1.9, 1n), 1n); +assert.sameValue(BigInt.asUintN(Object(1.9), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 1.9; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 1.9; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 1.9; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN([1.9], 1n), 1n); +assert.sameValue(BigInt.asUintN("1.9", 1n), 1n); +assert.sameValue(BigInt.asUintN(Object("1.9"), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "1.9"; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "1.9"; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "1.9"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN(["1.9"], 1n), 1n); +assert.sameValue(BigInt.asUintN(1, 1n), 1n); +assert.sameValue(BigInt.asUintN(Object(1), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 1; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 1; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN(true, 1n), 1n); +assert.sameValue(BigInt.asUintN(Object(true), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return true; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return true; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN("1", 1n), 1n); +assert.sameValue(BigInt.asUintN(Object("1"), 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "1"; }, toString: err}, 1n), 1n); +assert.sameValue(BigInt.asUintN({toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}, 1n), 1n); +assert.sameValue(BigInt.asUintN([1], 1n), 1n); +assert.sameValue(BigInt.asUintN(["1"], 1n), 1n); +assert.sameValue(BigInt.asUintN(3, 10n), 2n); +assert.sameValue(BigInt.asUintN(Object(3), 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 3; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 3; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 3; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN([3], 10n), 2n); +assert.sameValue(BigInt.asUintN("3", 10n), 2n); +assert.sameValue(BigInt.asUintN(Object("3"), 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "3"; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "3"; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "3"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN(["3"], 10n), 2n); +assert.sameValue(BigInt.asUintN(3.9, 10n), 2n); +assert.sameValue(BigInt.asUintN(Object(3.9), 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return 3.9; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return 3.9; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 3.9; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN([3.9], 10n), 2n); +assert.sameValue(BigInt.asUintN("3.9", 10n), 2n); +assert.sameValue(BigInt.asUintN(Object("3.9"), 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: function() { return "3.9"; }, valueOf: err, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return "3.9"; }, toString: err}, 10n), 2n); +assert.sameValue(BigInt.asUintN({toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: null, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: 1, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: {}, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "3.9"; }}, 10n), 2n); +assert.sameValue(BigInt.asUintN(["3.9"], 10n), 2n); +assert.throws(TypeError, function() { BigInt.asUintN(Symbol("1"), 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN(Object(Symbol("1")), 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return Symbol("1"); }, valueOf: err, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return Symbol("1"); }, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return Symbol("1"); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN(0n, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN(Object(0n), 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return 0n; }, valueOf: err, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return 0n; }, toString: err}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 0n; }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: 1}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: {}}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return Object(1); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return {}; }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { throw new MyError(); }, valueOf: err, toString: err}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: function() { throw new MyError(); }, toString: err}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: null, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: 1, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: {}, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(MyError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { throw new MyError(); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf:null, toString:null}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf:1, toString:1}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf:{}, toString:{}}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf:function() { return Object(1); }, toString:function() { return Object(1); }}, 0n); }); +assert.throws(TypeError, function() { BigInt.asUintN({valueOf:function() { return {}; }, toString:function() { return {}; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(-1, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object(-1), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return -1; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return -1; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return -1; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(-2.5, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object(-2.5), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return -2.5; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return -2.5; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return -2.5; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN("-2.5", 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object("-2.5"), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return "-2.5"; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return "-2.5"; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return "-2.5"; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(-Infinity, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object(-Infinity), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return -Infinity; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return -Infinity; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return -Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(9007199254740992, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object(9007199254740992), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return 9007199254740992; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return 9007199254740992; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return 9007199254740992; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Infinity, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN(Object(Infinity), 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: function() { return Infinity; }, valueOf: err, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Infinity; }, toString: err}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: undefined, valueOf: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({[Symbol.toPrimitive]: null, valueOf: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: null, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: 1, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: {}, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return {}; }, toString: function() { return Infinity; }}, 0n); }); +assert.throws(RangeError, function() { BigInt.asUintN({valueOf: function() { return Object(1); }, toString: function() { return Infinity; }}, 0n); }); diff --git a/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js b/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js index a84e42e1c50..8711350ef4e 100644 --- a/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js +++ b/test/built-ins/DataView/prototype/getBigInt64/to-boolean-littleendian.js @@ -1,10 +1,7 @@ -// Copyright (C) 2017 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - +// This file was procedurally generated. /*--- +description: Boolean littleEndian argument coerced in ToBoolean esid: sec-dataview.prototype.getbigint64 -description: > - Boolean littleEndian argument coerced in ToBoolean info: | DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] ) @@ -32,22 +29,24 @@ info: | ... 2. If isLittleEndian is false, reverse the order of the elements of rawBytes. ... -includes: [typeCoercion.js] -features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt, Symbol, Symbol.toPrimitive] +flags: [generated] +features: [ArrayBuffer, BigInt, DataView, DataView.prototype.setUint8, Symbol] ---*/ var buffer = new ArrayBuffer(8); var sample = new DataView(buffer, 0); - sample.setUint8(7, 0xff); -// False assert.sameValue(sample.getBigInt64(0), 0xffn, "no argument"); -testCoercibleToBooleanFalse(function (x) { - assert.sameValue(sample.getBigInt64(0, x), 0xffn); -}); - -// True -testCoercibleToBooleanTrue(function (x) { - assert.sameValue(sample.getBigInt64(0, x), -0x100000000000000n); -}); +assert.sameValue(sample.getBigInt64(0, undefined), 0xffn); +assert.sameValue(sample.getBigInt64(0, null), 0xffn); +assert.sameValue(sample.getBigInt64(0, false), 0xffn); +assert.sameValue(sample.getBigInt64(0, 0), 0xffn); +assert.sameValue(sample.getBigInt64(0, -0), 0xffn); +assert.sameValue(sample.getBigInt64(0, NaN), 0xffn); +assert.sameValue(sample.getBigInt64(0, ""), 0xffn); +assert.sameValue(sample.getBigInt64(0, true), -0x100000000000000n); +assert.sameValue(sample.getBigInt64(0, 1), -0x100000000000000n); +assert.sameValue(sample.getBigInt64(0, "string"), -0x100000000000000n); +assert.sameValue(sample.getBigInt64(0, Symbol("1")), -0x100000000000000n); +assert.sameValue(sample.getBigInt64(0, {}), -0x100000000000000n); diff --git a/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js b/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js index 11b5cd93152..1de9535c2e3 100644 --- a/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js +++ b/test/built-ins/DataView/prototype/getBigInt64/toindex-byteoffset.js @@ -1,10 +1,7 @@ -// Copyright (C) 2017 Igalia, S.L. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. - +// This file was procedurally generated. /*--- +description: ToIndex conversions on byteOffset esid: sec-dataview.prototype.getbigint64 -description: > - ToIndex conversions on byteOffset info: | DataView.prototype.getBigInt64 ( byteOffset [ , littleEndian ] ) @@ -17,13 +14,12 @@ info: | ... 4. Let getIndex be ? ToIndex(requestIndex). ... -includes: [typeCoercion.js] -features: [DataView, ArrayBuffer, DataView.prototype.setUint8, BigInt, Symbol, Symbol.toPrimitive] +flags: [generated] +features: [ArrayBuffer, BigInt, DataView, DataView.prototype.setUint8, Symbol.toPrimitive, computed-property-names] ---*/ var buffer = new ArrayBuffer(12); var sample = new DataView(buffer, 0); - sample.setUint8(0, 0x27); sample.setUint8(1, 0x02); sample.setUint8(2, 0x06); @@ -36,19 +32,387 @@ sample.setUint8(8, 0x7f); sample.setUint8(9, 0x00); sample.setUint8(10, 0x01); sample.setUint8(11, 0x02); +function err() { + throw new Test262Error(); +} -testCoercibleToIndexZero(function (x) { - assert.sameValue(sample.getBigInt64(x), 0x2702060280008001n); -}); - -testCoercibleToIndexOne(function (x) { - assert.sameValue(sample.getBigInt64(x), 0x20602800080017fn); -}); - -testCoercibleToIndexFromIndex(2, function (x) { - assert.sameValue(sample.getBigInt64(x), 0x602800080017F00n); -}); - -testCoercibleToIndexFromIndex(3, function (x) { - assert.sameValue(sample.getBigInt64(x), 0x2800080017F0001n); -}); +assert.sameValue(sample.getBigInt64(0), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(0)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 0; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(null), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return null; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return null; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(false), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(false)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return false; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return false; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("0"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("0")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "0"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(0), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(0)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 0; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 0; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64([0]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("0"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("0")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "0"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(["0"]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(0.9), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(0.9)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 0.9; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 0.9; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64([0.9]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("0.9"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("0.9")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "0.9"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "0.9"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(["0.9"]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(-0.9), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(-0.9)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return -0.9; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return -0.9; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return -0.9; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64([-0.9]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("-0.9"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("-0.9")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "-0.9"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "-0.9"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "-0.9"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(["-0.9"]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(NaN), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object(NaN)), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return NaN; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return NaN; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(undefined), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return undefined; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return undefined; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(""), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return ""; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return ""; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("foo"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("foo")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "foo"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "foo"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "foo"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64("true"), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(Object("true")), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "true"; }, valueOf: err, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "true"; }, toString: err}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "true"; }}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64({}), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64([]), 0x2702060280008001n); +assert.sameValue(sample.getBigInt64(1), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object(1)), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 1; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64([1]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64("1"), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object("1")), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "1"; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(["1"]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(1.9), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object(1.9)), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 1.9; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 1.9; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 1.9; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64([1.9]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64("1.9"), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object("1.9")), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "1.9"; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "1.9"; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "1.9"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(["1.9"]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(1), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object(1)), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 1; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 1; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(true), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object(true)), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return true; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return true; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64("1"), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(Object("1")), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "1"; }, toString: err}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64([1]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(["1"]), 0x20602800080017fn); +assert.sameValue(sample.getBigInt64(2), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(Object(2)), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 2; }, valueOf: err, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 2; }, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 2; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64([2]), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64("2"), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(Object("2")), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "2"; }, valueOf: err, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "2"; }, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "2"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(["2"]), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(2.9), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(Object(2.9)), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 2.9; }, valueOf: err, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 2.9; }, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 2.9; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64([2.9]), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64("2.9"), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(Object("2.9")), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "2.9"; }, valueOf: err, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "2.9"; }, toString: err}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "2.9"; }}), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(["2.9"]), 0x602800080017F00n); +assert.sameValue(sample.getBigInt64(3), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(Object(3)), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 3; }, valueOf: err, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 3; }, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 3; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64([3]), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64("3"), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(Object("3")), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "3"; }, valueOf: err, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "3"; }, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "3"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(["3"]), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(3.9), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(Object(3.9)), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return 3.9; }, valueOf: err, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return 3.9; }, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return 3.9; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64([3.9]), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64("3.9"), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(Object("3.9")), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: function() { return "3.9"; }, valueOf: err, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return "3.9"; }, toString: err}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: undefined, valueOf: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({[Symbol.toPrimitive]: null, valueOf: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: null, toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: 1, toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: {}, toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return {}; }, toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64({valueOf: function() { return Object(1); }, toString: function() { return "3.9"; }}), 0x2800080017F0001n); +assert.sameValue(sample.getBigInt64(["3.9"]), 0x2800080017F0001n); diff --git a/test/built-ins/String/prototype/indexOf/position-tointeger.js b/test/built-ins/String/prototype/indexOf/position-tointeger.js index 0bd2f1352dd..04753511fb3 100644 --- a/test/built-ins/String/prototype/indexOf/position-tointeger.js +++ b/test/built-ins/String/prototype/indexOf/position-tointeger.js @@ -1,29 +1,389 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: sec-string.prototype.indexof description: String.prototype.indexOf type coercion for position parameter -info: > +esid: sec-string.prototype.indexof +info: | String.prototype.indexOf ( searchString [ , position ] ) 4. Let pos be ? ToInteger(position). - -includes: [typeCoercion.js] -features: [BigInt, Symbol.toPrimitive] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToIntegerZero(function(zero) { - assert.sameValue("aaaa".indexOf("aa", zero), 0); -}); - -testCoercibleToIntegerOne(function(one) { - assert.sameValue("aaaa".indexOf("aa", one), 1); -}); - -testCoercibleToIntegerFromInteger(2, function(two) { - assert.sameValue("aaaa".indexOf("aa", two), 2); -}); +function err() { + throw new Test262Error(); +} +function MyError() {} -testNotCoercibleToInteger(function(error, value) { - assert.throws(error, function() { "".indexOf("", value); }); -}); +assert.sameValue("aaaa".indexOf("aa", 0), 0); +assert.sameValue("aaaa".indexOf("aa", Object(0)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 0; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", null), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return null; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return null; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return null; }}), 0); +assert.sameValue("aaaa".indexOf("aa", false), 0); +assert.sameValue("aaaa".indexOf("aa", Object(false)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return false; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return false; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return false; }}), 0); +assert.sameValue("aaaa".indexOf("aa", "0"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("0")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "0"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", 0), 0); +assert.sameValue("aaaa".indexOf("aa", Object(0)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 0; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 0; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 0; }}), 0); +assert.sameValue("aaaa".indexOf("aa", [0]), 0); +assert.sameValue("aaaa".indexOf("aa", "0"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("0")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "0"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "0"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "0"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", ["0"]), 0); +assert.sameValue("aaaa".indexOf("aa", 0.9), 0); +assert.sameValue("aaaa".indexOf("aa", Object(0.9)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 0.9; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 0.9; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", [0.9]), 0); +assert.sameValue("aaaa".indexOf("aa", "0.9"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("0.9")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "0.9"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "0.9"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", ["0.9"]), 0); +assert.sameValue("aaaa".indexOf("aa", -0.9), 0); +assert.sameValue("aaaa".indexOf("aa", Object(-0.9)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return -0.9; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return -0.9; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return -0.9; }}), 0); +assert.sameValue("aaaa".indexOf("aa", [-0.9]), 0); +assert.sameValue("aaaa".indexOf("aa", "-0.9"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("-0.9")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "-0.9"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "-0.9"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "-0.9"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", ["-0.9"]), 0); +assert.sameValue("aaaa".indexOf("aa", NaN), 0); +assert.sameValue("aaaa".indexOf("aa", Object(NaN)), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return NaN; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return NaN; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return NaN; }}), 0); +assert.sameValue("aaaa".indexOf("aa", undefined), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return undefined; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return undefined; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return undefined; }}), 0); +assert.sameValue("aaaa".indexOf("aa", ""), 0); +assert.sameValue("aaaa".indexOf("aa", Object("")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return ""; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return ""; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return ""; }}), 0); +assert.sameValue("aaaa".indexOf("aa", "foo"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("foo")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "foo"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "foo"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "foo"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", "true"), 0); +assert.sameValue("aaaa".indexOf("aa", Object("true")), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "true"; }, valueOf: err, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "true"; }, toString: err}), 0); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "true"; }}), 0); +assert.sameValue("aaaa".indexOf("aa", {}), 0); +assert.sameValue("aaaa".indexOf("aa", []), 0); +assert.sameValue("aaaa".indexOf("aa", 1), 1); +assert.sameValue("aaaa".indexOf("aa", Object(1)), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 1; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", [1]), 1); +assert.sameValue("aaaa".indexOf("aa", "1"), 1); +assert.sameValue("aaaa".indexOf("aa", Object("1")), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "1"; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", ["1"]), 1); +assert.sameValue("aaaa".indexOf("aa", 1.9), 1); +assert.sameValue("aaaa".indexOf("aa", Object(1.9)), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 1.9; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 1.9; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 1.9; }}), 1); +assert.sameValue("aaaa".indexOf("aa", [1.9]), 1); +assert.sameValue("aaaa".indexOf("aa", "1.9"), 1); +assert.sameValue("aaaa".indexOf("aa", Object("1.9")), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "1.9"; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "1.9"; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "1.9"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", ["1.9"]), 1); +assert.sameValue("aaaa".indexOf("aa", 1), 1); +assert.sameValue("aaaa".indexOf("aa", Object(1)), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 1; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 1; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 1; }}), 1); +assert.sameValue("aaaa".indexOf("aa", true), 1); +assert.sameValue("aaaa".indexOf("aa", Object(true)), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return true; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return true; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return true; }}), 1); +assert.sameValue("aaaa".indexOf("aa", "1"), 1); +assert.sameValue("aaaa".indexOf("aa", Object("1")), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "1"; }, valueOf: err, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "1"; }, toString: err}), 1); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "1"; }}), 1); +assert.sameValue("aaaa".indexOf("aa", [1]), 1); +assert.sameValue("aaaa".indexOf("aa", ["1"]), 1); +assert.sameValue("aaaa".indexOf("aa", 2), 2); +assert.sameValue("aaaa".indexOf("aa", Object(2)), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 2; }, valueOf: err, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 2; }, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 2; }}), 2); +assert.sameValue("aaaa".indexOf("aa", [2]), 2); +assert.sameValue("aaaa".indexOf("aa", "2"), 2); +assert.sameValue("aaaa".indexOf("aa", Object("2")), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "2"; }, valueOf: err, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "2"; }, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "2"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", ["2"]), 2); +assert.sameValue("aaaa".indexOf("aa", 2.9), 2); +assert.sameValue("aaaa".indexOf("aa", Object(2.9)), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return 2.9; }, valueOf: err, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return 2.9; }, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return 2.9; }}), 2); +assert.sameValue("aaaa".indexOf("aa", [2.9]), 2); +assert.sameValue("aaaa".indexOf("aa", "2.9"), 2); +assert.sameValue("aaaa".indexOf("aa", Object("2.9")), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: function() { return "2.9"; }, valueOf: err, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return "2.9"; }, toString: err}), 2); +assert.sameValue("aaaa".indexOf("aa", {toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: undefined, valueOf: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {[Symbol.toPrimitive]: null, valueOf: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: null, toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: 1, toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: {}, toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return {}; }, toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", {valueOf: function() { return Object(1); }, toString: function() { return "2.9"; }}), 2); +assert.sameValue("aaaa".indexOf("aa", ["2.9"]), 2); +assert.throws(TypeError, function() { "".indexOf("", Symbol("1")); }); +assert.throws(TypeError, function() { "".indexOf("", Object(Symbol("1"))); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { return Symbol("1"); }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return Symbol("1"); }, toString: err}); }); +assert.throws(TypeError, function() { "".indexOf("", {toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: undefined, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: null, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: null, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: 1, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: {}, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return {}; }, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return Object(1); }, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf("", 0n); }); +assert.throws(TypeError, function() { "".indexOf("", Object(0n)); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { return 0n; }, valueOf: err, toString: err}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return 0n; }, toString: err}); }); +assert.throws(TypeError, function() { "".indexOf("", {toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: undefined, valueOf: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: null, valueOf: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: null, toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: 1, toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: {}, toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return {}; }, toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf: function() { return Object(1); }, toString: function() { return 0n; }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: 1}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: {}}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { return Object(1); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { return {}; }}); }); +assert.throws(MyError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {[Symbol.toPrimitive]: function() { throw new MyError(); }, valueOf: err, toString: err}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: function() { throw new MyError(); }, toString: err}); }); +assert.throws(MyError, function() { "".indexOf("", {toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {[Symbol.toPrimitive]: undefined, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {[Symbol.toPrimitive]: null, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: null, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: 1, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: {}, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: function() { return {}; }, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf("", {valueOf: function() { return Object(1); }, toString: function() { throw new MyError(); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf:null, toString:null}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf:1, toString:1}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf:{}, toString:{}}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf:function() { return Object(1); }, toString:function() { return Object(1); }}); }); +assert.throws(TypeError, function() { "".indexOf("", {valueOf:function() { return {}; }, toString:function() { return {}; }}); }); diff --git a/test/built-ins/String/prototype/indexOf/searchstring-tostring.js b/test/built-ins/String/prototype/indexOf/searchstring-tostring.js index 44d23a4d4bc..5b2454aae93 100644 --- a/test/built-ins/String/prototype/indexOf/searchstring-tostring.js +++ b/test/built-ins/String/prototype/indexOf/searchstring-tostring.js @@ -1,26 +1,191 @@ -// Copyright (C) 2017 Josh Wolfe. All rights reserved. -// This code is governed by the BSD license found in the LICENSE file. +// This file was procedurally generated. /*--- -esid: sec-string.prototype.indexof description: String.prototype.indexOf type coercion for searchString parameter -info: > +esid: sec-string.prototype.indexof +info: | String.prototype.indexOf ( searchString [ , position ] ) 3. Let searchStr be ? ToString(searchString). - -includes: [typeCoercion.js] -features: [Symbol.toPrimitive, BigInt] +flags: [generated] +features: [BigInt, Symbol, Symbol.toPrimitive, computed-property-names] ---*/ -testCoercibleToString(function(value, expectedString) { - if (expectedString.length === 0) { - assert.sameValue(("x_x_x").indexOf(value), 0); - } else { - assert.sameValue(expectedString.indexOf("\x00"), -1, "sanity check"); - assert.sameValue(("\x00\x00" + expectedString + "\x00\x00").indexOf(value), 2); - } -}); +function err() { + throw new Test262Error(); +} +function MyError() {} -testNotCoercibleToString(function(error, value) { - assert.throws(error, function() { "".indexOf(value); }); -}); +assert.sameValue("foo".indexOf(""), 0); +assert.sameValue("foo".indexOf(Object("")), 0); +assert.sameValue("foo".indexOf({[Symbol.toPrimitive]: function() { return ""; }, toString: err, valueOf: err}), 0); +assert.sameValue("foo".indexOf({toString: function() { return ""; }, valueOf: err}), 0); +assert.sameValue("foo".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({[Symbol.toPrimitive]: null, toString: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({toString: null, valueOf: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({toString: 1, valueOf: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({toString: {}, valueOf: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({toString: function() { return {}; }, valueOf: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf({toString: function() { return Object(1); }, valueOf: function() { return ""; }}), 0); +assert.sameValue("foo".indexOf([]), 0); +assert.sameValue("__undefined__".indexOf(undefined), 2); +assert.sameValue("__undefined__".indexOf({[Symbol.toPrimitive]: function() { return undefined; }, toString: err, valueOf: err}), 2); +assert.sameValue("__undefined__".indexOf({toString: function() { return undefined; }, valueOf: err}), 2); +assert.sameValue("__undefined__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({toString: null, valueOf: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({toString: 1, valueOf: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({toString: {}, valueOf: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({toString: function() { return {}; }, valueOf: function() { return undefined; }}), 2); +assert.sameValue("__undefined__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return undefined; }}), 2); +assert.sameValue("__null__".indexOf(null), 2); +assert.sameValue("__null__".indexOf({[Symbol.toPrimitive]: function() { return null; }, toString: err, valueOf: err}), 2); +assert.sameValue("__null__".indexOf({toString: function() { return null; }, valueOf: err}), 2); +assert.sameValue("__null__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({toString: null, valueOf: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({toString: 1, valueOf: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({toString: {}, valueOf: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({toString: function() { return {}; }, valueOf: function() { return null; }}), 2); +assert.sameValue("__null__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return null; }}), 2); +assert.sameValue("__true__".indexOf(true), 2); +assert.sameValue("__true__".indexOf(Object(true)), 2); +assert.sameValue("__true__".indexOf({[Symbol.toPrimitive]: function() { return true; }, toString: err, valueOf: err}), 2); +assert.sameValue("__true__".indexOf({toString: function() { return true; }, valueOf: err}), 2); +assert.sameValue("__true__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({toString: null, valueOf: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({toString: 1, valueOf: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({toString: {}, valueOf: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({toString: function() { return {}; }, valueOf: function() { return true; }}), 2); +assert.sameValue("__true__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return true; }}), 2); +assert.sameValue("__false__".indexOf(false), 2); +assert.sameValue("__false__".indexOf(Object(false)), 2); +assert.sameValue("__false__".indexOf({[Symbol.toPrimitive]: function() { return false; }, toString: err, valueOf: err}), 2); +assert.sameValue("__false__".indexOf({toString: function() { return false; }, valueOf: err}), 2); +assert.sameValue("__false__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({toString: null, valueOf: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({toString: 1, valueOf: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({toString: {}, valueOf: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({toString: function() { return {}; }, valueOf: function() { return false; }}), 2); +assert.sameValue("__false__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return false; }}), 2); +assert.sameValue("__0__".indexOf(0), 2); +assert.sameValue("__0__".indexOf(Object(0)), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: function() { return 0; }, toString: err, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return 0; }, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({toString: null, valueOf: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({toString: 1, valueOf: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({toString: {}, valueOf: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return {}; }, valueOf: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return 0; }}), 2); +assert.sameValue("__0__".indexOf(-0), 2); +assert.sameValue("__0__".indexOf(Object(-0)), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: function() { return -0; }, toString: err, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return -0; }, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({toString: null, valueOf: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({toString: 1, valueOf: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({toString: {}, valueOf: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return {}; }, valueOf: function() { return -0; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return -0; }}), 2); +assert.sameValue("__Infinity__".indexOf(Infinity), 2); +assert.sameValue("__Infinity__".indexOf(Object(Infinity)), 2); +assert.sameValue("__Infinity__".indexOf({[Symbol.toPrimitive]: function() { return Infinity; }, toString: err, valueOf: err}), 2); +assert.sameValue("__Infinity__".indexOf({toString: function() { return Infinity; }, valueOf: err}), 2); +assert.sameValue("__Infinity__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({toString: null, valueOf: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({toString: 1, valueOf: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({toString: {}, valueOf: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({toString: function() { return {}; }, valueOf: function() { return Infinity; }}), 2); +assert.sameValue("__Infinity__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf(-Infinity), 2); +assert.sameValue("__-Infinity__".indexOf(Object(-Infinity)), 2); +assert.sameValue("__-Infinity__".indexOf({[Symbol.toPrimitive]: function() { return -Infinity; }, toString: err, valueOf: err}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: function() { return -Infinity; }, valueOf: err}), 2); +assert.sameValue("__-Infinity__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: null, valueOf: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: 1, valueOf: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: {}, valueOf: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: function() { return {}; }, valueOf: function() { return -Infinity; }}), 2); +assert.sameValue("__-Infinity__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return -Infinity; }}), 2); +assert.sameValue("__123.456__".indexOf(123.456), 2); +assert.sameValue("__123.456__".indexOf(Object(123.456)), 2); +assert.sameValue("__123.456__".indexOf({[Symbol.toPrimitive]: function() { return 123.456; }, toString: err, valueOf: err}), 2); +assert.sameValue("__123.456__".indexOf({toString: function() { return 123.456; }, valueOf: err}), 2); +assert.sameValue("__123.456__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({toString: null, valueOf: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({toString: 1, valueOf: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({toString: {}, valueOf: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({toString: function() { return {}; }, valueOf: function() { return 123.456; }}), 2); +assert.sameValue("__123.456__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return 123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf(-123.456), 2); +assert.sameValue("__-123.456__".indexOf(Object(-123.456)), 2); +assert.sameValue("__-123.456__".indexOf({[Symbol.toPrimitive]: function() { return -123.456; }, toString: err, valueOf: err}), 2); +assert.sameValue("__-123.456__".indexOf({toString: function() { return -123.456; }, valueOf: err}), 2); +assert.sameValue("__-123.456__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({toString: null, valueOf: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({toString: 1, valueOf: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({toString: {}, valueOf: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({toString: function() { return {}; }, valueOf: function() { return -123.456; }}), 2); +assert.sameValue("__-123.456__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return -123.456; }}), 2); +assert.sameValue("__foo__".indexOf("foo"), 2); +assert.sameValue("__foo__".indexOf(Object("foo")), 2); +assert.sameValue("__foo__".indexOf({[Symbol.toPrimitive]: function() { return "foo"; }, toString: err, valueOf: err}), 2); +assert.sameValue("__foo__".indexOf({toString: function() { return "foo"; }, valueOf: err}), 2); +assert.sameValue("__foo__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({toString: null, valueOf: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({toString: 1, valueOf: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({toString: {}, valueOf: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({toString: function() { return {}; }, valueOf: function() { return "foo"; }}), 2); +assert.sameValue("__foo__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return "foo"; }}), 2); +assert.sameValue("__0__".indexOf(0n), 2); +assert.sameValue("__0__".indexOf(Object(0n)), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: function() { return 0n; }, toString: err, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return 0n; }, valueOf: err}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({[Symbol.toPrimitive]: null, toString: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({toString: null, valueOf: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({toString: 1, valueOf: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({toString: {}, valueOf: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return {}; }, valueOf: function() { return 0n; }}), 2); +assert.sameValue("__0__".indexOf({toString: function() { return Object(1); }, valueOf: function() { return 0n; }}), 2); +assert.sameValue("__foo,bar__".indexOf(["foo", "bar"]), 2); +assert.sameValue("__[object Object]__".indexOf({}), 2); +assert.throws(TypeError, function() { "".indexOf(Symbol("1")); }); +assert.throws(TypeError, function() { "".indexOf(Object(Symbol("1"))); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: function() { return Symbol("1"); }, toString: err, valueOf: err}); }); +assert.throws(TypeError, function() { "".indexOf({toString: function() { return Symbol("1"); }, valueOf: err}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: null, toString: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({toString: null, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({toString: 1, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({toString: {}, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({toString: function() { return {}; }, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({toString: function() { return Object(1); }, valueOf: function() { return Symbol("1"); }}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: 1}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: {}}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: function() { return Object(1); }}); }); +assert.throws(TypeError, function() { "".indexOf({[Symbol.toPrimitive]: function() { return {}; }}); }); +assert.throws(MyError, function() { "".indexOf({[Symbol.toPrimitive]: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({[Symbol.toPrimitive]: function() { throw new MyError(); }, toString: err, valueOf: err}); }); +assert.throws(MyError, function() { "".indexOf({toString: function() { throw new MyError(); }, valueOf: err}); }); +assert.throws(MyError, function() { "".indexOf({[Symbol.toPrimitive]: undefined, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({[Symbol.toPrimitive]: null, toString: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({toString: null, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({toString: 1, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({toString: {}, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({toString: function() { return {}; }, valueOf: function() { throw new MyError(); }}); }); +assert.throws(MyError, function() { "".indexOf({toString: function() { return Object(1); }, valueOf: function() { throw new MyError(); }}); }); +assert.throws(TypeError, function() { "".indexOf({valueOf:null, toString:null}); }); +assert.throws(TypeError, function() { "".indexOf({valueOf:1, toString:1}); }); +assert.throws(TypeError, function() { "".indexOf({valueOf:{}, toString:{}}); }); +assert.throws(TypeError, function() { "".indexOf({valueOf:function() { return Object(1); }, toString:function() { return Object(1); }}); }); +assert.throws(TypeError, function() { "".indexOf({valueOf:function() { return {}; }, toString:function() { return {}; }}); });