tor-browser

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

bigint-tobigint-toprimitive.js (4480B)

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