blob: 0368c69b52109c5e126a3369aec5b0b7969687dc [file] [log] [blame]
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
'use strict'
const minus_one = BigInt(-1);
const zero = BigInt(0);
const another_zero = BigInt(0);
const one = BigInt(1);
const another_one = BigInt(1);
const two = BigInt(2);
const three = BigInt(3);
const six = BigInt(6);
// BigInt
{
assertSame(BigInt, BigInt.prototype.constructor)
}{
assertThrows(() => new BigInt, TypeError);
assertThrows(() => new BigInt(), TypeError);
assertThrows(() => new BigInt(0), TypeError);
assertThrows(() => new BigInt(0n), TypeError);
assertThrows(() => new BigInt("0"), TypeError);
}{
class C extends BigInt { constructor() { throw 42 } };
assertThrowsEquals(() => new C, 42);
}
// ToBigInt, NumberToBigInt, BigInt
{
assertThrows(() => BigInt(undefined), TypeError);
assertThrows(() => BigInt(null), TypeError);
assertThrows(() => BigInt({}), SyntaxError);
assertThrows(() => BigInt("foo"), SyntaxError);
assertThrows(() => BigInt("1j"), SyntaxError);
assertThrows(() => BigInt("0b1ju"), SyntaxError);
assertThrows(() => BigInt("0o1jun"), SyntaxError);
assertThrows(() => BigInt("0x1junk"), SyntaxError);
}{
assertSame(BigInt(true), 1n);
assertSame(BigInt(false), 0n);
assertSame(BigInt(""), 0n);
assertSame(BigInt(" 42"), 42n);
assertSame(BigInt("0b101010"), 42n);
assertSame(BigInt(" 0b101011"), 43n);
assertSame(BigInt("0x2a "), 42n);
assertSame(BigInt(" 0x2b"), 43n);
assertSame(BigInt("0o52"), 42n);
assertSame(BigInt(" 0o53\n"), 43n);
assertSame(BigInt(-0), 0n);
assertSame(BigInt(42), 42n);
assertSame(BigInt(42n), 42n);
assertSame(BigInt(Object(42n)), 42n);
assertSame(BigInt(2**53 - 1), 9007199254740991n);
assertSame(BigInt(2**53), 9007199254740992n);
assertSame(BigInt(2**1000), 2n ** 1000n);
assertSame(BigInt(3.0755851989071915e29), 307558519890719151276406341632n);
assertSame(BigInt(-1e50), -0x446c3b15f992680000000000000000000000000000n);
assertSame(BigInt(Object(2**53 - 1)), 9007199254740991n);
assertSame(BigInt([]), 0n);
}{
assertThrows(() => BigInt(NaN), RangeError);
assertThrows(() => BigInt(-Infinity), RangeError);
assertThrows(() => BigInt(+Infinity), RangeError);
assertThrows(() => BigInt(4.00000001), RangeError);
assertThrows(() => BigInt(Object(4.00000001)), RangeError);
}
// BigInt.prototype[Symbol.toStringTag]
{
const toStringTag = Object.getOwnPropertyDescriptor(
BigInt.prototype, Symbol.toStringTag);
assertTrue(toStringTag.configurable);
assertFalse(toStringTag.enumerable);
assertFalse(toStringTag.writable);
assertEquals("BigInt", toStringTag.value);
}
// Object.prototype.toString
{
const toString = Object.prototype.toString;
assertEquals("[object BigInt]", toString.call(42n));
assertEquals("[object BigInt]", toString.call(Object(42n)));
delete BigInt.prototype[Symbol.toStringTag];
assertEquals("[object Object]", toString.call(42n));
assertEquals("[object Object]", toString.call(Object(42n)));
BigInt.prototype[Symbol.toStringTag] = "foo";
assertEquals("[object foo]", toString.call(42n));
assertEquals("[object foo]", toString.call(Object(42n)));
}
// typeof
{
assertEquals(typeof zero, "bigint");
assertEquals(typeof one, "bigint");
}{
assertEquals(%Typeof(zero), "bigint");
assertEquals(%Typeof(one), "bigint");
}{
assertTrue(typeof 1n === "bigint");
assertFalse(typeof 1n === "BigInt");
assertFalse(typeof 1 === "bigint");
}
// ToString
{
assertEquals(String(zero), "0");
assertEquals(String(one), "1");
}
// .toString(radix)
{
// Single-digit BigInts: random-generated inputs close to kMaxInt.
// Expectations computed with the following Python program:
// def Format(x, base):
// s = ""
// while x > 0:
// s = "0123456789abcdefghijklmnopqrstuvwxyz"[x % base] + s
// x = x / base
// return s
assertEquals("10100110000100101000011100101", BigInt(0x14c250e5).toString(2));
assertEquals("-110110100010011111001011111", BigInt(-0x6d13e5f).toString(2));
assertEquals("1001222020000100000", BigInt(0x18c72873).toString(3));
assertEquals("-1212101122110102020", BigInt(-0x2b19aebe).toString(3));
assertEquals("120303133110120", BigInt(0x18cdf518).toString(4));
assertEquals("-113203101020122", BigInt(-0x178d121a).toString(4));
assertEquals("1323302233400", BigInt(0x18de6256).toString(5));
assertEquals("-2301033210212", BigInt(-0x25f7f454).toString(5));
assertEquals("131050115130", BigInt(0x211f0d5e).toString(6));
assertEquals("-104353333321", BigInt(-0x186bbe91).toString(6));
assertEquals("25466260221", BigInt(0x2f69f47e).toString(7));
assertEquals("-31051540346", BigInt(-0x352c7efa).toString(7));
assertEquals("5004630525", BigInt(0x28133155).toString(8));
assertEquals("-7633240703", BigInt(-0x3e6d41c3).toString(8));
assertEquals("705082365", BigInt(0x121f4264).toString(9));
assertEquals("-780654431", BigInt(-0x1443b36e).toString(9));
assertEquals("297019028", BigInt(0x11b42694).toString(10));
assertEquals("-721151126", BigInt(-0x2afbe496).toString(10));
assertEquals("312914074", BigInt(0x27ca6879).toString(11));
assertEquals("-198025592", BigInt(-0x1813d3a7).toString(11));
assertEquals("191370997", BigInt(0x2d14f083).toString(12));
assertEquals("-1b8aab4a2", BigInt(-0x32b52efa).toString(12));
assertEquals("7818062c", BigInt(0x1c84a48c).toString(13));
assertEquals("-7529695b", BigInt(-0x1badffee).toString(13));
assertEquals("6bc929c4", BigInt(0x2b0a91d0).toString(14));
assertEquals("-63042008", BigInt(-0x270dff78).toString(14));
assertEquals("5e8b8dec", BigInt(0x3cd27d7f).toString(15));
assertEquals("-4005433d", BigInt(-0x28c0821a).toString(15));
assertEquals("10b35ca3", BigInt(0x10b35ca3).toString(16));
assertEquals("-23d4d9d6", BigInt(-0x23d4d9d6).toString(16));
assertEquals("28c3d5e3", BigInt(0x3d75d48c).toString(17));
assertEquals("-10c06328", BigInt(-0x1979b7f0).toString(17));
assertEquals("eb8d349", BigInt(0x1dacf0a5).toString(18));
assertEquals("-1217015h", BigInt(-0x28b3c23f).toString(18));
assertEquals("1018520b", BigInt(0x357da01a).toString(19));
assertEquals("-9c64e33", BigInt(-0x1b0e9571).toString(19));
assertEquals("d7bf9ab", BigInt(0x3309daa3).toString(20));
assertEquals("-58h0h9h", BigInt(-0x14c30c55).toString(20));
assertEquals("64igi9h", BigInt(0x1fdd329c).toString(21));
assertEquals("-45cbc4a", BigInt(-0x15cf9682).toString(21));
assertEquals("7bi7d1h", BigInt(0x32f0dfe3).toString(22));
assertEquals("-61j743l", BigInt(-0x291ff61f).toString(22));
assertEquals("5g5gg25", BigInt(0x325a10bd).toString(23));
assertEquals("-3359flb", BigInt(-0x1bb653c9).toString(23));
assertEquals("392f5ec", BigInt(0x267ed69c).toString(24));
assertEquals("-2ab3icb", BigInt(-0x1bbf7bab).toString(24));
assertEquals("3jb2afo", BigInt(0x36f93c24).toString(25));
assertEquals("-30bcheh", BigInt(-0x2bec76fa).toString(25));
assertEquals("3845agk", BigInt(0x3d04bf64).toString(26));
assertEquals("-1gpjl3g", BigInt(-0x1e720b1a).toString(26));
assertEquals("20bpaf0", BigInt(0x2e8ff627).toString(27));
assertEquals("-292i3c2", BigInt(-0x35f751fe).toString(27));
assertEquals("266113k", BigInt(0x3fd26738).toString(28));
assertEquals("-1eh16bo", BigInt(-0x2bb5726c).toString(28));
assertEquals("19gj7qa", BigInt(0x2f28e8d8).toString(29));
assertEquals("-13a0apf", BigInt(-0x278b4588).toString(29));
assertEquals("iasrb8", BigInt(0x1a99b3be).toString(30));
assertEquals("-frlhoc", BigInt(-0x17106f48).toString(30));
assertEquals("bfe4p2", BigInt(0x139f1ea3).toString(31));
assertEquals("-ioal1a", BigInt(-0x200e49fa).toString(31));
assertEquals("m0v0kf", BigInt(0x2c0f828f).toString(32));
assertEquals("-g4bab5", BigInt(-0x2045a965).toString(32));
assertEquals("9i1kit", BigInt(0x16450a9f).toString(33));
assertEquals("-fqb0e7", BigInt(-0x24d9e889).toString(33));
assertEquals("gb9r6m", BigInt(0x2c3acf46).toString(34));
assertEquals("-jcaemv", BigInt(-0x346f72b3).toString(34));
assertEquals("cw4mbk", BigInt(0x2870cdcb).toString(35));
assertEquals("-hw4eki", BigInt(-0x3817c29b).toString(35));
assertEquals("alzwgj", BigInt(0x263e2c13).toString(36));
assertEquals("-bo4ukz", BigInt(-0x2a0f97d3).toString(36));
// Multi-digit BigInts.
// Test parseInt/toString round trip on a list of randomly generated
// string representations of numbers in various bases.
// Userland polyfill while we wait for BigInt.fromString (see:
// https://mathiasbynens.github.io/proposal-number-fromstring/ ).
// This intentionally only implements what the tests below need.
function ParseBigInt(str, radix) {
const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
var result = 0n;
var base = BigInt(radix);
var index = 0;
var negative = false;
if (str[0] === "-") {
negative = true;
index++;
}
for (; index < str.length; index++) {
var digit = alphabet.indexOf(str[index]);
assertTrue(digit >= 0 && digit < radix);
result = result * base + BigInt(digit);
}
if (negative) result = -result;
return result;
}
var positive = [0, 0, // Skip base 0 and 1.
"1100110001100010110011110110010010001011100111100101111000111101100001000",
"1001200022210010220101120212021002011002201122200002211102120120021011020",
"1111113020012203332320220022231110130001001320122012131311333110012023232",
"4214313040222110434114402342013144321401424143322013320403411012033300312",
"5025302003542512450341430541203424555035430434034243510233043041501130015",
"6231052230016515343200525230300322104013130605414211331345043144525012021",
"1146340505617030644211355340006353546230356336306352536433054143503442135",
"7262360724624787621528668212168232276348417717770383567066203032200270570",
"7573792356581293501680046955899735043496925151216904903504319328753434194",
"4a627927557579898720a42647639128174a8689889766a219342133671449069a2235011",
"1a574a5848289924996342a32893380690322330393633b587ba5a15b7b82080222400464",
"5163304c74c387b7a443c92466688595b671a3329b42083b1499b0c10a74a9298a06c3a5a",
"4b63c834356a03c80946133284a709cbbc2a75022757207dc31c14abd4c160dc122327c17",
"d8d59cbb4ca2860de7c002eee4ab3c215b90069200d20dbdc0111cb1e1bab97e8c7609670",
"22d4b69398a7f848e6ae36798811cd1a63d90f340d8607f3ce5566c97c18468787eb2b9fd",
"1176gf69afd32cc105fa70c705927a384dbdb1g8d952f28028g31ebdc9e32a89f16e825ee",
"5d64b74f4d70632h4ee07h7c1e2da9125c42g2727f4b6d95e5cec6ga49566hh731ab5f544",
"7ff8cg7f05dd72916a09a4761ii7b0ibcg68ba39b10436f14efg76ge817317badcbi4gffc",
"6d7c4hci6cd72e4ja26j354i12i71gb0cbj12gi145j91h02hde3b72c65geb7ff9bi9d0c2b",
"c96997f50abe425d13a53kk4af631kg7db208ka5j5bfg8ca5f9c0bjf69j5kgg4jb5h7hi86",
"3g5fd800d9ib9j0i8all5jgb23dh9483ab6le5ad9g4kja8a0b3j5jbjfge7k5fffg2kbheee",
"9j1119d1cd61kmdm7kma105cki313f678fc3h25f4664281bbmg3fk97kfbh7d48j89j178ch",
"d2933cdc9jfe4hl3794kb3e13dg2lihad968ib9jg19dgf1fi482b27ji0d10c6kfkdge5764",
"bf6o0njkm1ij5in5nh7h94584bd80el02b07el5ojk9k9g0gn906do70gbbnckl048c0kdmao",
"8gb7jnge9p9cdgigo394oa33gfaenc3gnb53eceg4b8511gkkm88b0dod85e5bggpc861d7d5",
"qbbnqhkpleb4o8ndaddpc34h5b2iljn3jgnjdn5k57bi3n9i09hjle9hqgqdpgbnk499mak56",
"akg7e2976arn8i2m53gif0dp59bmfd7mk9erlg2qm3fc76da9glf397eh4ooij9il0nfl9gac",
"mehpbfrj5ah2ef3p2hl637gjp1pm5grqn4037pm1qfgfpr9cfljfc145hljehjjb48bb1n6en",
"rg6ik3agnb3p6t2rtja9h4il76i8fkqlt6gplap3fq6pfr7bbcfcp5ffncf3nm4kamap39hse",
"bk8rp9r9r8pltdqpb7euc6s9rcm33969pcq6uk3mtfoktt86di8589oacbam5tn29b9b6dq3j",
"npth8juld44rss3e57iigjg65po3d1h02heo4r103jmg3ocv89buqtgiov35k39rdf8j9t4ca",
"vrmqlwrrrd0uml1womae49jpa9tadh44fw7mucgk06l0uk4uqwuo37t6kwn7wwrm3a6oq081s",
"n5cft6gvufqd8iksquu2amghokk17gbtpguidc290af634p7k7rhmfu7bf1s62ej4megoa1j4",
"3v3gcrmlfc2tl0tefgkiogj41f6y2tmj9w5bxke8y03xqf49ox8gh9wbrhycrkluicqajtnur",
"z2m7b0sy2tzergtkqts5yj0dkrlfkxls81ijgxgfequizpntcwggv2d4rdzcncd0kj9mrmnrb",
];
var negative = [0, 0, // Skip base 0 and 1.
"-100010011110111010111111110001100100111010101000001011010010101100101000",
"-110012122000122102021210112200001000122011010120101201001122000002022102",
"-203210320111001002200122200001312300221100221321010300023323201113122333",
"-133042441230110320040323303341320302144241224443231311022240124413104131",
"-311325230504055004330150145105331121322231155401110315251422505233103112",
"-643153641664240231336166403516403454646560261062114326443664602606315326",
"-200057252627665476551635525303641543165622340301637556323453513664337277",
"-826688166214270516331644053744613530235020517172322840763172114078364165",
"-743042397390679269240157150971957535458122650450558451124173993544604852",
"-73528688500003573942a56a504a2996a1384129563098512a63196697975038692aaa63",
"-616576a2948a9029316290168b71137b027851639a0283150b125b664b74b767a3597805",
"-b875467540719b371b7a36047a7886872a5399c4c630c37149bc3182917a7a7c124475bb",
"-3860411b61d35977721bc81bd715c386c9b70a752940913d265505d8c7c5dd2624b591d7",
"-bad5dd79b083ee0da9a6296664e72c246d827762357116ae7076a22bb369acbc3a201d03",
"-f9b37352aff265124303942a463917a252ff1a2ff4a33777f490b4c103bdcd1a655dbe2c",
"-805fg8c74125214g383a8d8g573c49fa7c4035fbc6db61g5gb5g6beb8f90dae4a9a5g7cc",
"-70aae113459d3h5084b1gg209g3695d20e78d01gcbb71bh1bd4gdge31haf5hc02dghf14e",
"-c55a57haf47b7ih2gh6ea93098ig02b42icga6ead254e0aeeic7g53h5fd6637ge03b2e20",
"-e32f7204624ie596j731g72136cejc25ebbgb0140i4997fcdf477f021d86ci4e10db543a",
"-i7f32c817i3cac1c24c7786k6ig185f47cj1471ki6bb7agiae838027gjge9g59if9f88g6",
"-i30aha2030a9605c270h92e1ca3i02j996hl918gh52fbhb7i16ik1i919ieak3cj384kb61",
"-58jmem8e59li67aellid2083dabh4kh51ci1jg7c6a3k4l1hdgfkdha0fglfm4805kida5b9",
"-cl9iecjg9ak087cad4151lll44296heae2349g70fbjj37998m2ddn6427fgcl2aknhgn1a1",
"-alfjfhho4gf8bi4j2bi3743mhg2aache4c6jcinkmf5ddm7kf9gg350hlja16ealbdlk201j",
"-bhh1146ho3o2m3b839c565hbgjnhjh96oofbmdl7gn8h4f94kli94hkk180o79pc4d2l0721",
"-p00gknh7e05k6a3apg6i9lb46f4a9qeeiq1778ak8il5dcponk5gl2fiednb4pmo1agmoqph",
"-4j8lo4d4p508fnd2hkfb76e8ri81k6hq0op3pr14ca0cn96pccplk7rbahc9cdkdce1q16dn",
"-ednlo3ogf2i8annrel9rm323bpf00meed3oi47n0qrdgnd2n3il4bnsc9s2jd7loh44im8ra",
"-bjjg6fsbpcc2tc1o09m9r6fd6eoq5480har62a5offn9thcfahbno9kf9magl2akl0jgncj9",
"-sonuhat2h60glpbpej9jjado2s5l86122d26tudoc1d6aic2oitu793gk0mlac3dk1dufp1q",
"-i9pbvm53ubh8jqifuarauch8cbgk9cjsl6rlioka1phs1lskg1oosll23hjoli2subgr1rto",
"-w1ncn5t60b5dv669ekwnvk8n2g7djrsl8cdkwun8o3m5divc3jhnkp2381rhj70gc71a6wff",
"-buiq8v33p5ex44ps4s45enj6lrluivm19lcowkvntu72u0xguw13bxgxxe7mdlwt1a4qksae",
"-woiycfmea6i12r2yai49mf4lbd7w2jdoebiogfhnh1i4rwgox57obci8qbsfpb4w07nu19m5",
"-tbttuip1r6ioca6g6dw354o4m78qep9yh03nojx47yq29fqime6zstwllb74501qct8eskxn",
];
for (var base = 2; base <= 36; base++) {
var input = positive[base];
assertEquals(input, ParseBigInt(input, base).toString(base));
input = negative[base];
assertEquals(input, ParseBigInt(input, base).toString(base));
}
}
// .valueOf
{
assertEquals(Object(zero).valueOf(), another_zero);
assertThrows(() => { return BigInt.prototype.valueOf.call("string"); },
TypeError);
assertEquals(-42n, Object(-42n).valueOf());
}
// ToBoolean
{
assertTrue(!zero);
assertFalse(!!zero);
assertTrue(!!!zero);
assertFalse(!one);
assertTrue(!!one);
assertFalse(!!!one);
// This is a hack to test Object::BooleanValue.
assertTrue(%CreateIterResultObject(42, one).done);
assertFalse(%CreateIterResultObject(42, zero).done);
}
// ToNumber
{
assertThrows(() => isNaN(zero), TypeError);
assertThrows(() => isNaN(one), TypeError);
assertThrows(() => +zero, TypeError);
assertThrows(() => +one, TypeError);
}
{
let Zero = {valueOf() { return zero }};
let One = {valueOf() { return one }};
assertThrows(() => isNaN(Zero), TypeError);
assertThrows(() => isNaN(One), TypeError);
assertThrows(() => +Zero, TypeError);
assertThrows(() => +One, TypeError);
}{
let Zero = {valueOf() { return Object(NaN) }, toString() { return zero }};
let One = {valueOf() { return one }, toString() { return NaN }};
assertThrows(() => isNaN(Zero), TypeError);
assertThrows(() => isNaN(One), TypeError);
assertThrows(() => +Zero, TypeError);
assertThrows(() => +One, TypeError);
}
// ToObject
{
const ToObject = x => (new Function("", "return this")).call(x);
function test(x) {
const X = ToObject(x);
assertEquals(typeof x, "bigint");
assertEquals(typeof X, 'object');
assertEquals(X.constructor, BigInt);
assertTrue(X == x);
}
test(0n);
test(-1n);
test(1n);
test(2343423423423423423424234234234235234524353453452345324523452345234534n);
}{
function test(x) {
const X = Object(x);
assertEquals(typeof x, "bigint");
assertEquals(typeof X, 'object');
assertEquals(X.constructor, BigInt);
assertTrue(X == x);
}
test(0n);
test(-1n);
test(1n);
test(2343423423423423423424234234234235234524353453452345324523452345234534n);
}
// Literals
{
// Invalid literals.
assertThrows("00n", SyntaxError);
assertThrows("01n", SyntaxError);
assertThrows("0bn", SyntaxError);
assertThrows("0on", SyntaxError);
assertThrows("0xn", SyntaxError);
assertThrows("1.n", SyntaxError);
assertThrows("1.0n", SyntaxError);
assertThrows("1e25n", SyntaxError);
// Various radixes.
assertTrue(12345n === BigInt(12345));
assertTrue(0xabcden === BigInt(0xabcde));
assertTrue(0xAbCdEn === BigInt(0xabcde));
assertTrue(0o54321n === BigInt(0o54321));
assertTrue(0b1010101n === BigInt(0b1010101));
}
// Binary ops.
{
let One = {valueOf() { return one }};
assertTrue(one + two === three);
assertTrue(One + two === three);
assertTrue(two + One === three);
assertEquals("hello1", "hello" + one);
assertEquals("2hello", two + "hello");
assertThrows("one + 2", TypeError);
assertThrows("2 + one", TypeError);
assertThrows("one + 0.5", TypeError);
assertThrows("0.5 + one", TypeError);
assertThrows("one + null", TypeError);
assertThrows("null + one", TypeError);
assertTrue(three - two === one);
assertThrows("two - 1", TypeError);
assertThrows("2 - one", TypeError);
assertThrows("two - 0.5", TypeError);
assertThrows("2.5 - one", TypeError);
assertTrue(two * three === six);
assertTrue(two * One === two);
assertTrue(One * two === two);
assertThrows("two * 1", TypeError);
assertThrows("1 * two", TypeError);
assertThrows("two * 1.5", TypeError);
assertThrows("1.5 * two", TypeError);
assertTrue(six / three === two);
assertThrows("six / 3", TypeError);
assertThrows("3 / three", TypeError);
assertThrows("six / 0.5", TypeError);
assertThrows("0.5 / six", TypeError);
assertThrows("zero / zero", RangeError);
assertThrows("zero / 0", TypeError);
assertTrue(three % two === one);
assertThrows("three % 2", TypeError);
assertThrows("3 % two", TypeError);
assertThrows("three % 2.5", TypeError);
assertThrows("3.5 % two", TypeError);
assertThrows("three % zero", RangeError);
assertThrows("three % 0", TypeError);
}
// Bitwise binary ops.
{
let One = {valueOf() { return one }};
assertTrue((three & one) === one);
assertTrue((BigInt(-2) & zero) === zero);
assertTrue((three & One) === one);
assertTrue((One & three) === one);
assertThrows("three & 1", TypeError);
assertThrows("1 & three", TypeError);
assertThrows("three & true", TypeError);
assertThrows("true & three", TypeError);
assertThrows("three & {valueOf: function() { return 1; }}", TypeError);
assertThrows("({valueOf: function() { return 1; }}) & three", TypeError);
assertTrue((two | one) === three);
assertThrows("two | 0", TypeError);
assertThrows("0 | two", TypeError);
assertThrows("two | undefined", TypeError);
assertThrows("undefined | two", TypeError);
assertTrue((three ^ one) === two);
assertThrows("three ^ 1", TypeError);
assertThrows("1 ^ three", TypeError);
assertThrows("three ^ 2.5", TypeError);
assertThrows("2.5 ^ three", TypeError);
}
// Shift ops.
{
assertTrue(one << one === two);
assertThrows("one << 1", TypeError);
assertThrows("1 << one", TypeError);
assertThrows("one << true", TypeError);
assertThrows("true << one", TypeError);
assertTrue(three >> one === one);
assertThrows("three >> 1", TypeError);
assertThrows("0xbeef >> one", TypeError);
assertThrows("three >> 1.5", TypeError);
assertThrows("23.45 >> three", TypeError);
assertThrows("three >>> one", TypeError);
assertThrows("three >>> 1", TypeError);
assertThrows("0xbeef >>> one", TypeError);
assertThrows("three >>> {valueOf: function() { return 1; }}", TypeError);
assertThrows("({valueOf: function() { return 1; }}) >>> one", TypeError);
}
// Unary ops.
{
let One = {valueOf() { return one }};
assertTrue(~minus_one === zero);
assertTrue(-minus_one === one);
assertTrue(-One === minus_one);
assertTrue(~~two === two);
assertTrue(-(-two) === two);
assertTrue(~One === BigInt(-2));
let a = minus_one;
assertTrue(a++ === minus_one);
assertTrue(a === zero);
assertTrue(a++ === zero);
assertTrue(a === one);
assertTrue(++a === two);
assertTrue(a === two);
assertTrue(--a === one);
assertTrue(a === one);
assertTrue(a-- === one);
assertTrue(a === zero);
assertTrue(a-- === zero);
assertTrue(a === minus_one);
a = {valueOf() { return minus_one }};
assertTrue(a++ === minus_one);
assertTrue(a++ === zero);
assertTrue(a === one);
a = {valueOf() { return one }};
assertTrue(a-- === one);
assertTrue(a-- === zero);
assertTrue(a === minus_one);
}
// ToPropertyKey
{
let obj = {};
assertEquals(obj[0n], undefined);
assertEquals(obj[0n] = 42, 42);
assertEquals(obj[0n], 42);
assertEquals(obj[0], 42);
obj[0]++;
assertEquals(obj[1n - 1n], 43);
assertEquals(Reflect.get(obj, -0n), 43);
assertEquals(obj[{toString() {return 0n}}], 43);
assertEquals(Reflect.ownKeys(obj), ["0"]);
}{
let obj = {};
const unsafe = 9007199254740993n;
assertEquals(obj[unsafe] = 23, 23);
assertEquals(obj[unsafe], 23);
assertEquals(Reflect.ownKeys(obj), ["9007199254740993"]);
assertEquals(obj[9007199254740993], undefined);
delete obj[unsafe];
assertEquals(Reflect.ownKeys(obj), []);
}{
let arr = [];
assertFalse(4n in arr);
arr[4n] = 42;
assertTrue(4n in arr);
let enumkeys = 0;
for (const key in arr) {
enumkeys++;
assertSame(key, "4");
}
assertEquals(enumkeys, 1);
}{
let str = "blubb";
assertEquals(str[2n], "u");
assertThrows(() => str.slice(2n), TypeError);
}{
let obj = {};
let key = 0;
function set_key(x) { obj[key] = x }
set_key("aaa");
set_key("bbb");
key = 0n;
set_key("ccc");
assertEquals(obj[key], "ccc");
function get_key() { return obj[key] }
assertEquals(get_key(), "ccc");
assertEquals(get_key(), "ccc");
key = 0;
assertEquals(get_key(), "ccc");
}{
assertSame(%ToName(0n), "0");
assertSame(%ToName(-0n), "0");
const unsafe = 9007199254740993n;
assertSame(%ToName(unsafe), "9007199254740993");
}