tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

bigint-tobigint-toprimitive.js (4453B)

      1 // Copyright (C) 2017 Josh Wolfe. All rights reserved.
      2 // This code is governed by the BSD license found in the LICENSE file.
      3 /*---
      4 description: BigInt.asIntN type coercion for bigint parameter
      5 esid: sec-bigint.asintn
      6 info: |
      7  BigInt.asIntN ( bits, bigint )
      8 
      9  2. Let bigint ? ToBigInt(bigint).
     10 features: [BigInt, computed-property-names, Symbol, Symbol.toPrimitive]
     11 ---*/
     12 assert.sameValue(typeof BigInt, 'function');
     13 assert.sameValue(typeof BigInt.asIntN, 'function');
     14 function err() {
     15  throw new Test262Error();
     16 }
     17 
     18 function MyError() {}
     19 
     20 assert.sameValue(BigInt.asIntN(2, {
     21  [Symbol.toPrimitive]: function() {
     22    return "1";
     23  },
     24  valueOf: err,
     25  toString: err
     26 }), 1n, "ToPrimitive: @@toPrimitive takes precedence");
     27 assert.sameValue(BigInt.asIntN(2, {
     28  valueOf: function() {
     29    return "1";
     30  },
     31  toString: err
     32 }), 1n, "ToPrimitive: valueOf takes precedence over toString");
     33 assert.sameValue(BigInt.asIntN(2, {
     34  toString: function() {
     35    return "1";
     36  }
     37 }), 1n, "ToPrimitive: toString with no valueOf");
     38 assert.sameValue(BigInt.asIntN(2, {
     39  [Symbol.toPrimitive]: undefined,
     40  valueOf: function() {
     41    return "1";
     42  }
     43 }), 1n, "ToPrimitive: skip @@toPrimitive when it's undefined");
     44 assert.sameValue(BigInt.asIntN(2, {
     45  [Symbol.toPrimitive]: null,
     46  valueOf: function() {
     47    return "1";
     48  }
     49 }), 1n, "ToPrimitive: skip @@toPrimitive when it's null");
     50 assert.sameValue(BigInt.asIntN(2, {
     51  valueOf: null,
     52  toString: function() {
     53    return "1";
     54  }
     55 }), 1n, "ToPrimitive: skip valueOf when it's not callable");
     56 assert.sameValue(BigInt.asIntN(2, {
     57  valueOf: 1,
     58  toString: function() {
     59    return "1";
     60  }
     61 }), 1n, "ToPrimitive: skip valueOf when it's not callable");
     62 assert.sameValue(BigInt.asIntN(2, {
     63  valueOf: {},
     64  toString: function() {
     65    return "1";
     66  }
     67 }), 1n, "ToPrimitive: skip valueOf when it's not callable");
     68 assert.sameValue(BigInt.asIntN(2, {
     69  valueOf: function() {
     70    return {};
     71  },
     72  toString: function() {
     73    return "1";
     74  }
     75 }), 1n, "ToPrimitive: skip valueOf when it returns an object");
     76 assert.sameValue(BigInt.asIntN(2, {
     77  valueOf: function() {
     78    return Object(12345);
     79  },
     80  toString: function() {
     81    return "1";
     82  }
     83 }), 1n, "ToPrimitive: skip valueOf when it returns an object");
     84 assert.throws(TypeError, function() {
     85  BigInt.asIntN(0, {
     86    [Symbol.toPrimitive]: 1
     87  });
     88 }, "ToPrimitive: throw when @@toPrimitive is not callable");
     89 assert.throws(TypeError, function() {
     90  BigInt.asIntN(0, {
     91    [Symbol.toPrimitive]: {}
     92  });
     93 }, "ToPrimitive: throw when @@toPrimitive is not callable");
     94 assert.throws(TypeError, function() {
     95  BigInt.asIntN(0, {
     96    [Symbol.toPrimitive]: function() {
     97      return Object(1);
     98    }
     99  });
    100 }, "ToPrimitive: throw when @@toPrimitive returns an object");
    101 assert.throws(TypeError, function() {
    102  BigInt.asIntN(0, {
    103    [Symbol.toPrimitive]: function() {
    104      return {};
    105    }
    106  });
    107 }, "ToPrimitive: throw when @@toPrimitive returns an object");
    108 assert.throws(MyError, function() {
    109  BigInt.asIntN(0, {
    110    [Symbol.toPrimitive]: function() {
    111      throw new MyError();
    112    }
    113  });
    114 }, "ToPrimitive: propagate errors from @@toPrimitive");
    115 assert.throws(MyError, function() {
    116  BigInt.asIntN(0, {
    117    valueOf: function() {
    118      throw new MyError();
    119    }
    120  });
    121 }, "ToPrimitive: propagate errors from valueOf");
    122 assert.throws(MyError, function() {
    123  BigInt.asIntN(0, {
    124    toString: function() {
    125      throw new MyError();
    126    }
    127  });
    128 }, "ToPrimitive: propagate errors from toString");
    129 assert.throws(TypeError, function() {
    130  BigInt.asIntN(0, {
    131    valueOf: null,
    132    toString: null
    133  });
    134 }, "ToPrimitive: throw when skipping both valueOf and toString");
    135 assert.throws(TypeError, function() {
    136  BigInt.asIntN(0, {
    137    valueOf: 1,
    138    toString: 1
    139  });
    140 }, "ToPrimitive: throw when skipping both valueOf and toString");
    141 assert.throws(TypeError, function() {
    142  BigInt.asIntN(0, {
    143    valueOf: {},
    144    toString: {}
    145  });
    146 }, "ToPrimitive: throw when skipping both valueOf and toString");
    147 assert.throws(TypeError, function() {
    148  BigInt.asIntN(0, {
    149    valueOf: function() {
    150      return Object(1);
    151    },
    152    toString: function() {
    153      return Object(1);
    154    }
    155  });
    156 }, "ToPrimitive: throw when skipping both valueOf and toString");
    157 assert.throws(TypeError, function() {
    158  BigInt.asIntN(0, {
    159    valueOf: function() {
    160      return {};
    161    },
    162    toString: function() {
    163      return {};
    164    }
    165  });
    166 }, "ToPrimitive: throw when skipping both valueOf and toString");
    167 
    168 reportCompare(0, 0);