text: // 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");
  }
  