tor-browser

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

bigint-toprimitive.js (8801B)

      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: modulus operator ToNumeric with BigInt operands
      5 esid: sec-multiplicative-operators-runtime-semantics-evaluation
      6 features: [BigInt, Symbol.toPrimitive, computed-property-names]
      7 ---*/
      8 function err() {
      9  throw new Test262Error();
     10 }
     11 
     12 function MyError() {}
     13 
     14 assert.sameValue({
     15  [Symbol.toPrimitive]: function() {
     16    return 2n;
     17  },
     18 
     19  valueOf: err,
     20  toString: err
     21 } % 2n, 0n, 'The result of (({[Symbol.toPrimitive]: function() {return 2n;}, valueOf: err, toString: err}) % 2n) is 0n');
     22 
     23 assert.sameValue(2n % {
     24  [Symbol.toPrimitive]: function() {
     25    return 2n;
     26  },
     27 
     28  valueOf: err,
     29  toString: err
     30 }, 0n, 'The result of (2n % {[Symbol.toPrimitive]: function() {return 2n;}, valueOf: err, toString: err}) is 0n');
     31 
     32 assert.sameValue({
     33  valueOf: function() {
     34    return 2n;
     35  },
     36 
     37  toString: err
     38 } % 2n, 0n, 'The result of (({valueOf: function() {return 2n;}, toString: err}) % 2n) is 0n');
     39 
     40 assert.sameValue(2n % {
     41  valueOf: function() {
     42    return 2n;
     43  },
     44 
     45  toString: err
     46 }, 0n, 'The result of (2n % {valueOf: function() {return 2n;}, toString: err}) is 0n');
     47 
     48 assert.sameValue({
     49  toString: function() {
     50    return 2n;
     51  }
     52 } % 2n, 0n, 'The result of (({toString: function() {return 2n;}}) % 2n) is 0n');
     53 
     54 assert.sameValue(2n % {
     55  toString: function() {
     56    return 2n;
     57  }
     58 }, 0n, 'The result of (2n % {toString: function() {return 2n;}}) is 0n');
     59 
     60 assert.sameValue({
     61  [Symbol.toPrimitive]: undefined,
     62 
     63  valueOf: function() {
     64    return 2n;
     65  }
     66 } % 2n, 0n, 'The result of (({[Symbol.toPrimitive]: undefined, valueOf: function() {return 2n;}}) % 2n) is 0n');
     67 
     68 assert.sameValue(2n % {
     69  [Symbol.toPrimitive]: undefined,
     70 
     71  valueOf: function() {
     72    return 2n;
     73  }
     74 }, 0n, 'The result of (2n % {[Symbol.toPrimitive]: undefined, valueOf: function() {return 2n;}}) is 0n');
     75 
     76 assert.sameValue({
     77  [Symbol.toPrimitive]: null,
     78 
     79  valueOf: function() {
     80    return 2n;
     81  }
     82 } % 2n, 0n, 'The result of (({[Symbol.toPrimitive]: null, valueOf: function() {return 2n;}}) % 2n) is 0n');
     83 
     84 assert.sameValue(2n % {
     85  [Symbol.toPrimitive]: null,
     86 
     87  valueOf: function() {
     88    return 2n;
     89  }
     90 }, 0n, 'The result of (2n % {[Symbol.toPrimitive]: null, valueOf: function() {return 2n;}}) is 0n');
     91 
     92 assert.sameValue({
     93  valueOf: null,
     94 
     95  toString: function() {
     96    return 2n;
     97  }
     98 } % 2n, 0n, 'The result of (({valueOf: null, toString: function() {return 2n;}}) % 2n) is 0n');
     99 
    100 assert.sameValue(2n % {
    101  valueOf: null,
    102 
    103  toString: function() {
    104    return 2n;
    105  }
    106 }, 0n, 'The result of (2n % {valueOf: null, toString: function() {return 2n;}}) is 0n');
    107 
    108 assert.sameValue({
    109  valueOf: 1,
    110 
    111  toString: function() {
    112    return 2n;
    113  }
    114 } % 2n, 0n, 'The result of (({valueOf: 1, toString: function() {return 2n;}}) % 2n) is 0n');
    115 
    116 assert.sameValue(2n % {
    117  valueOf: 1,
    118 
    119  toString: function() {
    120    return 2n;
    121  }
    122 }, 0n, 'The result of (2n % {valueOf: 1, toString: function() {return 2n;}}) is 0n');
    123 
    124 assert.sameValue({
    125  valueOf: {},
    126 
    127  toString: function() {
    128    return 2n;
    129  }
    130 } % 2n, 0n, 'The result of (({valueOf: {}, toString: function() {return 2n;}}) % 2n) is 0n');
    131 
    132 assert.sameValue(2n % {
    133  valueOf: {},
    134 
    135  toString: function() {
    136    return 2n;
    137  }
    138 }, 0n, 'The result of (2n % {valueOf: {}, toString: function() {return 2n;}}) is 0n');
    139 
    140 assert.sameValue({
    141  valueOf: function() {
    142    return {};
    143  },
    144 
    145  toString: function() {
    146    return 2n;
    147  }
    148 } % 2n, 0n, 'The result of (({valueOf: function() {return {};}, toString: function() {return 2n;}}) % 2n) is 0n');
    149 
    150 assert.sameValue(2n % {
    151  valueOf: function() {
    152    return {};
    153  },
    154 
    155  toString: function() {
    156    return 2n;
    157  }
    158 }, 0n, 'The result of (2n % {valueOf: function() {return {};}, toString: function() {return 2n;}}) is 0n');
    159 
    160 assert.sameValue({
    161  valueOf: function() {
    162    return Object(12345);
    163  },
    164 
    165  toString: function() {
    166    return 2n;
    167  }
    168 } % 2n, 0n, 'The result of (({valueOf: function() {return Object(12345);}, toString: function() {return 2n;}}) % 2n) is 0n');
    169 
    170 assert.sameValue(2n % {
    171  valueOf: function() {
    172    return Object(12345);
    173  },
    174 
    175  toString: function() {
    176    return 2n;
    177  }
    178 }, 0n, 'The result of (2n % {valueOf: function() {return Object(12345);}, toString: function() {return 2n;}}) is 0n');
    179 
    180 assert.throws(TypeError, function() {
    181  ({
    182    [Symbol.toPrimitive]: 1
    183  }) % 1n;
    184 }, '({[Symbol.toPrimitive]: 1}) % 1n throws TypeError');
    185 
    186 assert.throws(TypeError, function() {
    187  0n % {
    188    [Symbol.toPrimitive]: 1
    189  };
    190 }, '0n % {[Symbol.toPrimitive]: 1} throws TypeError');
    191 
    192 assert.throws(TypeError, function() {
    193  ({
    194    [Symbol.toPrimitive]: {}
    195  }) % 1n;
    196 }, '({[Symbol.toPrimitive]: {}}) % 1n throws TypeError');
    197 
    198 assert.throws(TypeError, function() {
    199  0n % {
    200    [Symbol.toPrimitive]: {}
    201  };
    202 }, '0n % {[Symbol.toPrimitive]: {}} throws TypeError');
    203 
    204 assert.throws(TypeError, function() {
    205  ({
    206    [Symbol.toPrimitive]: function() {
    207      return Object(1);
    208    }
    209  }) % 1n;
    210 }, '({[Symbol.toPrimitive]: function() {return Object(1);}}) % 1n throws TypeError');
    211 
    212 assert.throws(TypeError, function() {
    213  0n % {
    214    [Symbol.toPrimitive]: function() {
    215      return Object(1);
    216    }
    217  };
    218 }, '0n % {[Symbol.toPrimitive]: function() {return Object(1);}} throws TypeError');
    219 
    220 assert.throws(TypeError, function() {
    221  ({
    222    [Symbol.toPrimitive]: function() {
    223      return {};
    224    }
    225  }) % 1n;
    226 }, '({[Symbol.toPrimitive]: function() {return {};}}) % 1n throws TypeError');
    227 
    228 assert.throws(TypeError, function() {
    229  0n % {
    230    [Symbol.toPrimitive]: function() {
    231      return {};
    232    }
    233  };
    234 }, '0n % {[Symbol.toPrimitive]: function() {return {};}} throws TypeError');
    235 
    236 assert.throws(MyError, function() {
    237  ({
    238    [Symbol.toPrimitive]: function() {
    239      throw new MyError();
    240    }
    241  }) % 1n;
    242 }, '({[Symbol.toPrimitive]: function() {throw new MyError();}}) % 1n throws MyError');
    243 
    244 assert.throws(MyError, function() {
    245  0n % {
    246    [Symbol.toPrimitive]: function() {
    247      throw new MyError();
    248    }
    249  };
    250 }, '0n % {[Symbol.toPrimitive]: function() {throw new MyError();}} throws MyError');
    251 
    252 assert.throws(MyError, function() {
    253  ({
    254    valueOf: function() {
    255      throw new MyError();
    256    }
    257  }) % 1n;
    258 }, '({valueOf: function() {throw new MyError();}}) % 1n throws MyError');
    259 
    260 assert.throws(MyError, function() {
    261  0n % {
    262    valueOf: function() {
    263      throw new MyError();
    264    }
    265  };
    266 }, '0n % {valueOf: function() {throw new MyError();}} throws MyError');
    267 
    268 assert.throws(MyError, function() {
    269  ({
    270    toString: function() {
    271      throw new MyError();
    272    }
    273  }) % 1n;
    274 }, '({toString: function() {throw new MyError();}}) % 1n throws MyError');
    275 
    276 assert.throws(MyError, function() {
    277  0n % {
    278    toString: function() {
    279      throw new MyError();
    280    }
    281  };
    282 }, '0n % {toString: function() {throw new MyError();}} throws MyError');
    283 
    284 assert.throws(TypeError, function() {
    285  ({
    286    valueOf: null,
    287    toString: null
    288  }) % 1n;
    289 }, '({valueOf: null, toString: null}) % 1n throws TypeError');
    290 
    291 assert.throws(TypeError, function() {
    292  0n % {
    293    valueOf: null,
    294    toString: null
    295  };
    296 }, '0n % {valueOf: null, toString: null} throws TypeError');
    297 
    298 assert.throws(TypeError, function() {
    299  ({
    300    valueOf: 1,
    301    toString: 1
    302  }) % 1n;
    303 }, '({valueOf: 1, toString: 1}) % 1n throws TypeError');
    304 
    305 assert.throws(TypeError, function() {
    306  0n % {
    307    valueOf: 1,
    308    toString: 1
    309  };
    310 }, '0n % {valueOf: 1, toString: 1} throws TypeError');
    311 
    312 assert.throws(TypeError, function() {
    313  ({
    314    valueOf: {},
    315    toString: {}
    316  }) % 1n;
    317 }, '({valueOf: {}, toString: {}}) % 1n throws TypeError');
    318 
    319 assert.throws(TypeError, function() {
    320  0n % {
    321    valueOf: {},
    322    toString: {}
    323  };
    324 }, '0n % {valueOf: {}, toString: {}} throws TypeError');
    325 
    326 assert.throws(TypeError, function() {
    327  ({
    328    valueOf: function() {
    329      return Object(1);
    330    },
    331 
    332    toString: function() {
    333      return Object(1);
    334    }
    335  }) % 1n;
    336 }, '({valueOf: function() {return Object(1);}, toString: function() {return Object(1);}}) % 1n throws TypeError');
    337 
    338 assert.throws(TypeError, function() {
    339  0n % {
    340    valueOf: function() {
    341      return Object(1);
    342    },
    343 
    344    toString: function() {
    345      return Object(1);
    346    }
    347  };
    348 }, '0n % {valueOf: function() {return Object(1);}, toString: function() {return Object(1);}} throws TypeError');
    349 
    350 assert.throws(TypeError, function() {
    351  ({
    352    valueOf: function() {
    353      return {};
    354    },
    355 
    356    toString: function() {
    357      return {};
    358    }
    359  }) % 1n;
    360 }, '({valueOf: function() {return {};}, toString: function() {return {};}}) % 1n throws TypeError');
    361 
    362 assert.throws(TypeError, function() {
    363  0n % {
    364    valueOf: function() {
    365      return {};
    366    },
    367 
    368    toString: function() {
    369      return {};
    370    }
    371  };
    372 }, '0n % {valueOf: function() {return {};}, toString: function() {return {};}} throws TypeError');
    373 
    374 reportCompare(0, 0);