js/src/tests/test262/built-ins/BigInt/asIntN/bigint-tobigint-toprimitive.js

   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);