The Tor Browser: js/src/jit-test/tests/ion/divmodself.js@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 // |jit-test| ion-eager

     3 // bug 944963

     4 function bug944963(x, y) {

     5     (+(xy))(y % y)

6 }

     7 for (var i = 0; i < 10; i++) {

     8     try {

     9         (function() {

    10             bug944963(0, (~Math.fround(-8)))

    11         })()

    12     } catch (e) {}

    13 }

    15 // bug 900437

    16 function bug900437() {

    17     var x = 0.0;

    18     for (var i = 0; i < 10; i++)

    19         -("") >> (x / x);

    20 }

    21 bug900437();

    22 bug900437();

    24 // bug 715460

    25 function f(x) {

    26     var a = x;

    27     return a / 10;

    28 }

    29 function g(x) {

    30     var y = x + 1;

    31     return y / y;

    32 }

    33 for (var i=0; i<10; i++)

    34     assertEq(f(i * 10), i);

    35 for (var i=0; i<10; i++)

    36     assertEq(g(i), 1);

    38 // bug 939893

    39 function bug939893() {

    40     bug_g();

    41 }

    42 function bug_g() {

    43     bug_h(undefined >>> 0, +undefined);

    44 }

    45 function bug_h(x) {

    46     Math.max(x ? ((x / x) | 0) : 0);

    47 }

    48 for (var a = 0; a < 2; ++a) {

    49   bug939893();

    50 }

    52 // bug 945860

    53 function bug945860(x) {

    54     return (x % x);

    55 }

    56 for (var i = 0; i < 2; i++) {

    57     try {

    58         (function() {

    59             assertEq(bug945860(1), 0);

    60         })()

    61     } catch (e) {}

    62 }

    64 // Assorted tests.

    66 function sdiv_truncate(y) {

    67   return (y / y)|0;

    68 }

    69 assertEq(sdiv_truncate(5), 1);

    70 assertEq(sdiv_truncate(1), 1);

    71 assertEq(sdiv_truncate(-1), 1);

    72 assertEq(sdiv_truncate(0), 0);

    73 assertEq(sdiv_truncate(-0), 0);

    74 assertEq(sdiv_truncate(1.1), 1);

    75 assertEq(sdiv_truncate(-1.1), 1);

    76 assertEq(sdiv_truncate(Infinity), 0);

    77 assertEq(sdiv_truncate(NaN), 0);

    78 assertEq(sdiv_truncate(undefined), 0);

    79 assertEq(sdiv_truncate(null), 0);

    81 function sdiv(y) {

    82   return y / y;

    83 }

    84 assertEq(sdiv(5), 1);

    85 assertEq(sdiv(1), 1);

    86 assertEq(sdiv(-1), 1);

    87 assertEq(sdiv(0), NaN);

    88 assertEq(sdiv(-0), NaN);

    89 assertEq(sdiv(1.1), 1);

    90 assertEq(sdiv(-1.1), 1);

    91 assertEq(sdiv(Infinity), NaN);

    92 assertEq(sdiv(NaN), NaN);

    93 assertEq(sdiv(undefined), NaN);

    94 assertEq(sdiv(null), NaN);

    96 function udiv_truncate(y) {

    97   var yu = y>>>0;

    98   return (yu / yu)|0;

    99 }

   100 assertEq(udiv_truncate(5), 1);

   101 assertEq(udiv_truncate(1), 1);

   102 assertEq(udiv_truncate(-1), 1);

   103 assertEq(udiv_truncate(0), 0);

   104 assertEq(udiv_truncate(-0), 0);

   105 assertEq(udiv_truncate(1.1), 1);

   106 assertEq(udiv_truncate(-1.1), 1);

   107 assertEq(udiv_truncate(Infinity), 0);

   108 assertEq(udiv_truncate(NaN), 0);

   109 assertEq(udiv_truncate(undefined), 0);

   110 assertEq(udiv_truncate(null), 0);

   112 function shifted_udiv_truncate(y) {

   113   var yu = y>>>1;

   114   return (yu / yu)|0;

   115 }

   116 assertEq(shifted_udiv_truncate(5), 1);

   117 assertEq(shifted_udiv_truncate(2), 1);

   118 assertEq(shifted_udiv_truncate(1), 0);

   119 assertEq(shifted_udiv_truncate(-1), 1);

   120 assertEq(shifted_udiv_truncate(0), 0);

   121 assertEq(shifted_udiv_truncate(-0), 0);

   122 assertEq(shifted_udiv_truncate(1.1), 0);

   123 assertEq(shifted_udiv_truncate(-1.1), 1);

   124 assertEq(shifted_udiv_truncate(Infinity), 0);

   125 assertEq(shifted_udiv_truncate(NaN), 0);

   126 assertEq(shifted_udiv_truncate(undefined), 0);

   127 assertEq(shifted_udiv_truncate(null), 0);

   129 function udiv(y) {

   130   var yu = y>>>0;

   131   return yu / yu;

   132 }

   133 assertEq(udiv(5), 1);

   134 assertEq(udiv(1), 1);

   135 assertEq(udiv(-1), 1);

   136 assertEq(udiv(0), NaN);

   137 assertEq(udiv(-0), NaN);

   138 assertEq(udiv(1.1), 1);

   139 assertEq(udiv(-1.1), 1);

   140 assertEq(udiv(Infinity), NaN);

   141 assertEq(udiv(NaN), NaN);

   142 assertEq(udiv(undefined), NaN);

   143 assertEq(udiv(null), NaN);

   145 function shifted_udiv(y) {

   146   var yu = y>>>1;

   147   return yu / yu;

   148 }

   149 assertEq(shifted_udiv(5), 1);

   150 assertEq(shifted_udiv(2), 1);

   151 assertEq(shifted_udiv(1), NaN);

   152 assertEq(shifted_udiv(-1), 1);

   153 assertEq(shifted_udiv(0), NaN);

   154 assertEq(shifted_udiv(-0), NaN);

   155 assertEq(shifted_udiv(1.1), NaN);

   156 assertEq(shifted_udiv(-1.1), 1);

   157 assertEq(shifted_udiv(Infinity), NaN);

   158 assertEq(shifted_udiv(NaN), NaN);

   159 assertEq(shifted_udiv(undefined), NaN);

   160 assertEq(shifted_udiv(null), NaN);

   162 function smod_truncate(y) {

   163   return (y % y)|0;

   164 }

   165 assertEq(smod_truncate(5), 0);

   166 assertEq(smod_truncate(1), 0);

   167 assertEq(smod_truncate(-1), 0);

   168 assertEq(smod_truncate(0), 0);

   169 assertEq(smod_truncate(-0), 0);

   170 assertEq(smod_truncate(1.1), 0);

   171 assertEq(smod_truncate(-1.1), 0);

   172 assertEq(smod_truncate(Infinity), 0);

   173 assertEq(smod_truncate(NaN), 0);

   174 assertEq(smod_truncate(undefined), 0);

   175 assertEq(smod_truncate(null), 0);

   177 function smod(y) {

   178   return y % y;

   179 }

   180 assertEq(smod(5), 0);

   181 assertEq(smod(1), 0);

   182 assertEq(smod(-1), -0);

   183 assertEq(smod(0), NaN);

   184 assertEq(smod(-0), NaN);

   185 assertEq(smod(1.1), 0);

   186 assertEq(smod(-1.1), -0);

   187 assertEq(smod(Infinity), NaN);

   188 assertEq(smod(NaN), NaN);

   189 assertEq(smod(undefined), NaN);

   190 assertEq(smod(null), NaN);

   192 function umod_truncate(y) {

   193   var yu = y>>>0;

   194   return (yu % yu)|0;

   195 }

   196 assertEq(umod_truncate(5), 0);

   197 assertEq(umod_truncate(1), 0);

   198 assertEq(umod_truncate(-1), 0);

   199 assertEq(umod_truncate(0), 0);

   200 assertEq(umod_truncate(-0), 0);

   201 assertEq(umod_truncate(1.1), 0);

   202 assertEq(umod_truncate(-1.1), 0);

   203 assertEq(umod_truncate(Infinity), 0);

   204 assertEq(umod_truncate(NaN), 0);

   205 assertEq(umod_truncate(undefined), 0);

   206 assertEq(umod_truncate(null), 0);

   208 function shifted_umod_truncate(y) {

   209   var yu = y>>>1;

   210   return (yu % yu)|0;

   211 }

   212 assertEq(shifted_umod_truncate(5), 0);

   213 assertEq(shifted_umod_truncate(2), 0);

   214 assertEq(shifted_umod_truncate(1), 0);

   215 assertEq(shifted_umod_truncate(-1), 0);

   216 assertEq(shifted_umod_truncate(0), 0);

   217 assertEq(shifted_umod_truncate(-0), 0);

   218 assertEq(shifted_umod_truncate(1.1), 0);

   219 assertEq(shifted_umod_truncate(-1.1), 0);

   220 assertEq(shifted_umod_truncate(Infinity), 0);

   221 assertEq(shifted_umod_truncate(NaN), 0);

   222 assertEq(shifted_umod_truncate(undefined), 0);

   223 assertEq(shifted_umod_truncate(null), 0);

   225 function umod(y) {

   226   var yu = y>>>0;

   227   return yu % yu;

   228 }

   229 assertEq(umod(5), 0);

   230 assertEq(umod(1), 0);

   231 assertEq(umod(-1), 0);

   232 assertEq(umod(0), NaN);

   233 assertEq(umod(-0), NaN);

   234 assertEq(umod(1.1), 0);

   235 assertEq(umod(-1.1), 0);

   236 assertEq(umod(Infinity), NaN);

   237 assertEq(umod(NaN), NaN);

   238 assertEq(umod(undefined), NaN);

   239 assertEq(umod(null), NaN);

   241 function shifted_umod(y) {

   242   var yu = y>>>1;

   243   return yu % yu;

   244 }

   245 assertEq(shifted_umod(5), 0);

   246 assertEq(shifted_umod(2), 0);

   247 assertEq(shifted_umod(1), NaN);

   248 assertEq(shifted_umod(-1), 0);

   249 assertEq(shifted_umod(0), NaN);

   250 assertEq(shifted_umod(-0), NaN);

   251 assertEq(shifted_umod(1.1), NaN);

   252 assertEq(shifted_umod(-1.1), 0);

   253 assertEq(shifted_umod(Infinity), NaN);

   254 assertEq(shifted_umod(NaN), NaN);

   255 assertEq(shifted_umod(undefined), NaN);

   256 assertEq(shifted_umod(null), NaN);

   258 function sdiv_truncate_nonzero(y) {

   259   if (y == 0) return -202;

   260   return (y / y)|0;

   261 }

   262 assertEq(sdiv_truncate_nonzero(5), 1);

   263 assertEq(sdiv_truncate_nonzero(1), 1);

   264 assertEq(sdiv_truncate_nonzero(-1), 1);

   265 assertEq(sdiv_truncate_nonzero(0), -202);

   266 assertEq(sdiv_truncate_nonzero(-0), -202);

   267 assertEq(sdiv_truncate_nonzero(1.1), 1);

   268 assertEq(sdiv_truncate_nonzero(-1.1), 1);

   269 assertEq(sdiv_truncate_nonzero(Infinity), 0);

   270 assertEq(sdiv_truncate_nonzero(NaN), 0);

   271 assertEq(sdiv_truncate_nonzero(undefined), 0);

   272 assertEq(sdiv_truncate_nonzero(null), 0);

   274 function sdiv_nonzero(y) {

   275   if (y == 0) return -202;

   276   return y / y;

   277 }

   278 assertEq(sdiv_nonzero(5), 1);

   279 assertEq(sdiv_nonzero(1), 1);

   280 assertEq(sdiv_nonzero(-1), 1);

   281 assertEq(sdiv_nonzero(0), -202);

   282 assertEq(sdiv_nonzero(-0), -202);

   283 assertEq(sdiv_nonzero(1.1), 1);

   284 assertEq(sdiv_nonzero(-1.1), 1);

   285 assertEq(sdiv_nonzero(Infinity), NaN);

   286 assertEq(sdiv_nonzero(NaN), NaN);

   287 assertEq(sdiv_nonzero(undefined), NaN);

   288 assertEq(sdiv_nonzero(null), NaN);

   290 function udiv_truncate_nonzero(y) {

   291   var yu = y>>>0;

   292   if (yu == 0) return -202;

   293   return (yu / yu)|0;

   294 }

   295 assertEq(udiv_truncate_nonzero(5), 1);

   296 assertEq(udiv_truncate_nonzero(1), 1);

   297 assertEq(udiv_truncate_nonzero(-1), 1);

   298 assertEq(udiv_truncate_nonzero(0), -202);

   299 assertEq(udiv_truncate_nonzero(-0), -202);

   300 assertEq(udiv_truncate_nonzero(1.1), 1);

   301 assertEq(udiv_truncate_nonzero(-1.1), 1);

   302 assertEq(udiv_truncate_nonzero(Infinity), -202);

   303 assertEq(udiv_truncate_nonzero(NaN), -202);

   304 assertEq(udiv_truncate_nonzero(undefined), -202);

   305 assertEq(udiv_truncate_nonzero(null), -202);

   307 function shifted_udiv_truncate_nonzero(y) {

   308   var yu = y>>>1;

   309   if (yu == 0) return -202;

   310   return (yu / yu)|0;

   311 }

   312 assertEq(shifted_udiv_truncate_nonzero(5), 1);

   313 assertEq(shifted_udiv_truncate_nonzero(2), 1);

   314 assertEq(shifted_udiv_truncate_nonzero(1), -202);

   315 assertEq(shifted_udiv_truncate_nonzero(-1), 1);

   316 assertEq(shifted_udiv_truncate_nonzero(0), -202);

   317 assertEq(shifted_udiv_truncate_nonzero(-0), -202);

   318 assertEq(shifted_udiv_truncate_nonzero(1.1), -202);

   319 assertEq(shifted_udiv_truncate_nonzero(-1.1), 1);

   320 assertEq(shifted_udiv_truncate_nonzero(Infinity), -202);

   321 assertEq(shifted_udiv_truncate_nonzero(NaN), -202);

   322 assertEq(shifted_udiv_truncate_nonzero(undefined), -202);

   323 assertEq(shifted_udiv_truncate_nonzero(null), -202);

   325 function udiv_nonzero(y) {

   326   var yu = y>>>0;

   327   if (yu == 0) return -202;

   328   return yu / yu;

   329 }

   330 assertEq(udiv_nonzero(5), 1);

   331 assertEq(udiv_nonzero(1), 1);

   332 assertEq(udiv_nonzero(-1), 1);

   333 assertEq(udiv_nonzero(0), -202);

   334 assertEq(udiv_nonzero(-0), -202);

   335 assertEq(udiv_nonzero(1.1), 1);

   336 assertEq(udiv_nonzero(-1.1), 1);

   337 assertEq(udiv_nonzero(Infinity), -202);

   338 assertEq(udiv_nonzero(NaN), -202);

   339 assertEq(udiv_nonzero(undefined), -202);

   340 assertEq(udiv_nonzero(null), -202);

   342 function shifted_udiv_nonzero(y) {

   343   var yu = y>>>1;

   344   if (yu == 0) return -202;

   345   return yu / yu;

   346 }

   347 assertEq(shifted_udiv_nonzero(5), 1);

   348 assertEq(shifted_udiv_nonzero(2), 1);

   349 assertEq(shifted_udiv_nonzero(1), -202);

   350 assertEq(shifted_udiv_nonzero(-1), 1);

   351 assertEq(shifted_udiv_nonzero(0), -202);

   352 assertEq(shifted_udiv_nonzero(-0), -202);

   353 assertEq(shifted_udiv_nonzero(1.1), -202);

   354 assertEq(shifted_udiv_nonzero(-1.1), 1);

   355 assertEq(shifted_udiv_nonzero(Infinity), -202);

   356 assertEq(shifted_udiv_nonzero(NaN), -202);

   357 assertEq(shifted_udiv_nonzero(undefined), -202);

   358 assertEq(shifted_udiv_nonzero(null), -202);

   360 function smod_truncate_nonzero(y) {

   361   if (y == 0) return -202;

   362   return (y % y)|0;

   363 }

   364 assertEq(smod_truncate_nonzero(5), 0);

   365 assertEq(smod_truncate_nonzero(1), 0);

   366 assertEq(smod_truncate_nonzero(-1), 0);

   367 assertEq(smod_truncate_nonzero(0), -202);

   368 assertEq(smod_truncate_nonzero(-0), -202);

   369 assertEq(smod_truncate_nonzero(1.1), 0);

   370 assertEq(smod_truncate_nonzero(-1.1), 0);

   371 assertEq(smod_truncate_nonzero(Infinity), 0);

   372 assertEq(smod_truncate_nonzero(NaN), 0);

   373 assertEq(smod_truncate_nonzero(undefined), 0);

   374 assertEq(smod_truncate_nonzero(null), 0);

   376 function smod_nonzero(y) {

   377   if (y == 0) return -202;

   378   return y % y;

   379 }

   380 assertEq(smod_nonzero(5), 0);

   381 assertEq(smod_nonzero(1), 0);

   382 assertEq(smod_nonzero(-1), -0);

   383 assertEq(smod_nonzero(0), -202);

   384 assertEq(smod_nonzero(-0), -202);

   385 assertEq(smod_nonzero(1.1), 0);

   386 assertEq(smod_nonzero(-1.1), -0);

   387 assertEq(smod_nonzero(Infinity), NaN);

   388 assertEq(smod_nonzero(NaN), NaN);

   389 assertEq(smod_nonzero(undefined), NaN);

   390 assertEq(smod_nonzero(null), NaN);

   392 function umod_truncate_nonzero(y) {

   393   var yu = y>>>0;

   394   if (yu == 0) return -202;

   395   return (yu % yu)|0;

   396 }

   397 assertEq(umod_truncate_nonzero(5), 0);

   398 assertEq(umod_truncate_nonzero(1), 0);

   399 assertEq(umod_truncate_nonzero(-1), 0);

   400 assertEq(umod_truncate_nonzero(0), -202);

   401 assertEq(umod_truncate_nonzero(-0), -202);

   402 assertEq(umod_truncate_nonzero(1.1), 0);

   403 assertEq(umod_truncate_nonzero(-1.1), 0);

   404 assertEq(umod_truncate_nonzero(Infinity), -202);

   405 assertEq(umod_truncate_nonzero(NaN), -202);

   406 assertEq(umod_truncate_nonzero(undefined), -202);

   407 assertEq(umod_truncate_nonzero(null), -202);

   409 function shifted_umod_truncate_nonzero(y) {

   410   var yu = y>>>1;

   411   if (yu == 0) return -202;

   412   return (yu % yu)|0;

   413 }

   414 assertEq(shifted_umod_truncate_nonzero(5), 0);

   415 assertEq(shifted_umod_truncate_nonzero(2), 0);

   416 assertEq(shifted_umod_truncate_nonzero(1), -202);

   417 assertEq(shifted_umod_truncate_nonzero(-1), 0);

   418 assertEq(shifted_umod_truncate_nonzero(0), -202);

   419 assertEq(shifted_umod_truncate_nonzero(-0), -202);

   420 assertEq(shifted_umod_truncate_nonzero(1.1), -202);

   421 assertEq(shifted_umod_truncate_nonzero(-1.1), 0);

   422 assertEq(shifted_umod_truncate_nonzero(Infinity), -202);

   423 assertEq(shifted_umod_truncate_nonzero(NaN), -202);

   424 assertEq(shifted_umod_truncate_nonzero(undefined), -202);

   425 assertEq(shifted_umod_truncate_nonzero(null), -202);

   427 function umod_nonzero(y) {

   428   var yu = y>>>0;

   429   if (yu == 0) return -202;

   430   return yu % yu;

   431 }

   432 assertEq(umod_nonzero(5), 0);

   433 assertEq(umod_nonzero(1), 0);

   434 assertEq(umod_nonzero(-1), 0);

   435 assertEq(umod_nonzero(0), -202);

   436 assertEq(umod_nonzero(-0), -202);

   437 assertEq(umod_nonzero(1.1), 0);

   438 assertEq(umod_nonzero(-1.1), 0);

   439 assertEq(umod_nonzero(Infinity), -202);

   440 assertEq(umod_nonzero(NaN), -202);

   441 assertEq(umod_nonzero(undefined), -202);

   442 assertEq(umod_nonzero(null), -202);

   444 function shifted_umod_nonzero(y) {

   445   var yu = y>>>1;

   446   if (yu == 0) return -202;

   447   return yu % yu;

   448 }

   449 assertEq(shifted_umod_nonzero(5), 0);

   450 assertEq(shifted_umod_nonzero(2), 0);

   451 assertEq(shifted_umod_nonzero(1), -202);

   452 assertEq(shifted_umod_nonzero(-1), 0);

   453 assertEq(shifted_umod_nonzero(0), -202);

   454 assertEq(shifted_umod_nonzero(-0), -202);

   455 assertEq(shifted_umod_nonzero(1.1), -202);

   456 assertEq(shifted_umod_nonzero(-1.1), 0);

   457 assertEq(shifted_umod_nonzero(Infinity), -202);

   458 assertEq(shifted_umod_nonzero(NaN), -202);

   459 assertEq(shifted_umod_nonzero(undefined), -202);

   460 assertEq(shifted_umod_nonzero(null), -202);

   462 function sdiv_truncate_positive(y) {

   463   if (y <= 0) return -202;

   464   return (y / y)|0;

   465 }

   466 assertEq(sdiv_truncate_positive(5), 1);

   467 assertEq(sdiv_truncate_positive(1), 1);

   468 assertEq(sdiv_truncate_positive(-1), -202);

   469 assertEq(sdiv_truncate_positive(0), -202);

   470 assertEq(sdiv_truncate_positive(-0), -202);

   471 assertEq(sdiv_truncate_positive(1.1), 1);

   472 assertEq(sdiv_truncate_positive(-1.1), -202);

   473 assertEq(sdiv_truncate_positive(Infinity), 0);

   474 assertEq(sdiv_truncate_positive(NaN), 0);

   475 assertEq(sdiv_truncate_positive(undefined), 0);

   476 assertEq(sdiv_truncate_positive(null), -202);

   478 function sdiv_positive(y) {

   479   if (y <= 0) return -202;

   480   return y / y;

   481 }

   482 assertEq(sdiv_positive(5), 1);

   483 assertEq(sdiv_positive(1), 1);

   484 assertEq(sdiv_positive(-1), -202);

   485 assertEq(sdiv_positive(0), -202);

   486 assertEq(sdiv_positive(-0), -202);

   487 assertEq(sdiv_positive(1.1), 1);

   488 assertEq(sdiv_positive(-1.1), -202);

   489 assertEq(sdiv_positive(Infinity), NaN);

   490 assertEq(sdiv_positive(NaN), NaN);

   491 assertEq(sdiv_positive(undefined), NaN);

   492 assertEq(sdiv_positive(null), -202);

   494 function udiv_truncate_positive(y) {

   495   var yu = y>>>0;

   496   if (yu <= 0) return -202;

   497   return (yu / yu)|0;

   498 }

   499 assertEq(udiv_truncate_positive(5), 1);

   500 assertEq(udiv_truncate_positive(1), 1);

   501 assertEq(udiv_truncate_positive(-1), 1);

   502 assertEq(udiv_truncate_positive(0), -202);

   503 assertEq(udiv_truncate_positive(-0), -202);

   504 assertEq(udiv_truncate_positive(1.1), 1);

   505 assertEq(udiv_truncate_positive(-1.1), 1);

   506 assertEq(udiv_truncate_positive(Infinity), -202);

   507 assertEq(udiv_truncate_positive(NaN), -202);

   508 assertEq(udiv_truncate_positive(undefined), -202);

   509 assertEq(udiv_truncate_positive(null), -202);

   511 function shifted_udiv_truncate_positive(y) {

   512   var yu = y>>>1;

   513   if (yu <= 0) return -202;

   514   return (yu / yu)|0;

   515 }

   516 assertEq(shifted_udiv_truncate_positive(5), 1);

   517 assertEq(shifted_udiv_truncate_positive(2), 1);

   518 assertEq(shifted_udiv_truncate_positive(1), -202);

   519 assertEq(shifted_udiv_truncate_positive(-1), 1);

   520 assertEq(shifted_udiv_truncate_positive(0), -202);

   521 assertEq(shifted_udiv_truncate_positive(-0), -202);

   522 assertEq(shifted_udiv_truncate_positive(1.1), -202);

   523 assertEq(shifted_udiv_truncate_positive(-1.1), 1);

   524 assertEq(shifted_udiv_truncate_positive(Infinity), -202);

   525 assertEq(shifted_udiv_truncate_positive(NaN), -202);

   526 assertEq(shifted_udiv_truncate_positive(undefined), -202);

   527 assertEq(shifted_udiv_truncate_positive(null), -202);

   529 function udiv_positive(y) {

   530   var yu = y>>>0;

   531   if (yu <= 0) return -202;

   532   return yu / yu;

   533 }

   534 assertEq(udiv_positive(5), 1);

   535 assertEq(udiv_positive(1), 1);

   536 assertEq(udiv_positive(-1), 1);

   537 assertEq(udiv_positive(0), -202);

   538 assertEq(udiv_positive(-0), -202);

   539 assertEq(udiv_positive(1.1), 1);

   540 assertEq(udiv_positive(-1.1), 1);

   541 assertEq(udiv_positive(Infinity), -202);

   542 assertEq(udiv_positive(NaN), -202);

   543 assertEq(udiv_positive(undefined), -202);

   544 assertEq(udiv_positive(null), -202);

   546 function shifted_udiv_positive(y) {

   547   var yu = y>>>1;

   548   if (yu <= 0) return -202;

   549   return yu / yu;

   550 }

   551 assertEq(shifted_udiv_positive(5), 1);

   552 assertEq(shifted_udiv_positive(2), 1);

   553 assertEq(shifted_udiv_positive(1), -202);

   554 assertEq(shifted_udiv_positive(-1), 1);

   555 assertEq(shifted_udiv_positive(0), -202);

   556 assertEq(shifted_udiv_positive(-0), -202);

   557 assertEq(shifted_udiv_positive(1.1), -202);

   558 assertEq(shifted_udiv_positive(-1.1), 1);

   559 assertEq(shifted_udiv_positive(Infinity), -202);

   560 assertEq(shifted_udiv_positive(NaN), -202);

   561 assertEq(shifted_udiv_positive(undefined), -202);

   562 assertEq(shifted_udiv_positive(null), -202);

   564 function smod_truncate_positive(y) {

   565   if (y <= 0) return -202;

   566   return (y % y)|0;

   567 }

   568 assertEq(smod_truncate_positive(5), 0);

   569 assertEq(smod_truncate_positive(1), 0);

   570 assertEq(smod_truncate_positive(-1), -202);

   571 assertEq(smod_truncate_positive(0), -202);

   572 assertEq(smod_truncate_positive(-0), -202);

   573 assertEq(smod_truncate_positive(1.1), 0);

   574 assertEq(smod_truncate_positive(-1.1), -202);

   575 assertEq(smod_truncate_positive(Infinity), 0);

   576 assertEq(smod_truncate_positive(NaN), 0);

   577 assertEq(smod_truncate_positive(undefined), 0);

   578 assertEq(smod_truncate_positive(null), -202);

   580 function smod_positive(y) {

   581   if (y <= 0) return -202;

   582   return y % y;

   583 }

   584 assertEq(smod_positive(5), 0);

   585 assertEq(smod_positive(1), 0);

   586 assertEq(smod_positive(-1), -202);

   587 assertEq(smod_positive(0), -202);

   588 assertEq(smod_positive(-0), -202);

   589 assertEq(smod_positive(1.1), 0);

   590 assertEq(smod_positive(-1.1), -202);

   591 assertEq(smod_positive(Infinity), NaN);

   592 assertEq(smod_positive(NaN), NaN);

   593 assertEq(smod_positive(undefined), NaN);

   594 assertEq(smod_positive(null), -202);

   596 function umod_truncate_positive(y) {

   597   var yu = y>>>0;

   598   if (yu <= 0) return -202;

   599   return (yu % yu)|0;

   600 }

   601 assertEq(umod_truncate_positive(5), 0);

   602 assertEq(umod_truncate_positive(1), 0);

   603 assertEq(umod_truncate_positive(-1), 0);

   604 assertEq(umod_truncate_positive(0), -202);

   605 assertEq(umod_truncate_positive(-0), -202);

   606 assertEq(umod_truncate_positive(1.1), 0);

   607 assertEq(umod_truncate_positive(-1.1), 0);

   608 assertEq(umod_truncate_positive(Infinity), -202);

   609 assertEq(umod_truncate_positive(NaN), -202);

   610 assertEq(umod_truncate_positive(undefined), -202);

   611 assertEq(umod_truncate_positive(null), -202);

   613 function shifted_umod_truncate_positive(y) {

   614   var yu = y>>>1;

   615   if (yu <= 0) return -202;

   616   return (yu % yu)|0;

   617 }

   618 assertEq(shifted_umod_truncate_positive(5), 0);

   619 assertEq(shifted_umod_truncate_positive(2), 0);

   620 assertEq(shifted_umod_truncate_positive(1), -202);

   621 assertEq(shifted_umod_truncate_positive(-1), 0);

   622 assertEq(shifted_umod_truncate_positive(0), -202);

   623 assertEq(shifted_umod_truncate_positive(-0), -202);

   624 assertEq(shifted_umod_truncate_positive(1.1), -202);

   625 assertEq(shifted_umod_truncate_positive(-1.1), 0);

   626 assertEq(shifted_umod_truncate_positive(Infinity), -202);

   627 assertEq(shifted_umod_truncate_positive(NaN), -202);

   628 assertEq(shifted_umod_truncate_positive(undefined), -202);

   629 assertEq(shifted_umod_truncate_positive(null), -202);

   631 function umod_positive(y) {

   632   var yu = y>>>0;

   633   if (yu <= 0) return -202;

   634   return yu % yu;

   635 }

   636 assertEq(umod_positive(5), 0);

   637 assertEq(umod_positive(1), 0);

   638 assertEq(umod_positive(-1), 0);

   639 assertEq(umod_positive(0), -202);

   640 assertEq(umod_positive(-0), -202);

   641 assertEq(umod_positive(1.1), 0);

   642 assertEq(umod_positive(-1.1), 0);

   643 assertEq(umod_positive(Infinity), -202);

   644 assertEq(umod_positive(NaN), -202);

   645 assertEq(umod_positive(undefined), -202);

   646 assertEq(umod_positive(null), -202);

   648 function shifted_umod_positive(y) {

   649   var yu = y>>>1;

   650   if (yu <= 0) return -202;

   651   return yu % yu;

   652 }

   653 assertEq(shifted_umod_positive(5), 0);

   654 assertEq(shifted_umod_positive(2), 0);

   655 assertEq(shifted_umod_positive(1), -202);

   656 assertEq(shifted_umod_positive(-1), 0);

   657 assertEq(shifted_umod_positive(0), -202);

   658 assertEq(shifted_umod_positive(-0), -202);

   659 assertEq(shifted_umod_positive(1.1), -202);

   660 assertEq(shifted_umod_positive(-1.1), 0);

   661 assertEq(shifted_umod_positive(Infinity), -202);

   662 assertEq(shifted_umod_positive(NaN), -202);

   663 assertEq(shifted_umod_positive(undefined), -202);

   664 assertEq(shifted_umod_positive(null), -202);

The Tor Browser / file revision

js/src/jit-test/tests/ion/divmodself.js@6474c204b198

js/src/jit-test/tests/ion/divmodself.js