The Tor Browser / file comparison
comparison: js/src/jit-test/tests/ion/divmodself.js
js/src/jit-test/tests/ion/divmodself.js
- branch
- TOR_BUG_9701
- changeset 15
- b8a032363ba2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:6dad4ceb5621 |
|---|---|
| 1 // |jit-test| ion-eager | |
| 2 | |
| 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 } | |
| 14 | |
| 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(); | |
| 23 | |
| 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); | |
| 37 | |
| 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 } | |
| 51 | |
| 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 } | |
| 63 | |
| 64 // Assorted tests. | |
| 65 | |
| 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); | |
| 80 | |
| 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); | |
| 95 | |
| 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); | |
| 111 | |
| 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); | |
| 128 | |
| 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); | |
| 144 | |
| 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); | |
| 161 | |
| 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); | |
| 176 | |
| 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); | |
| 191 | |
| 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); | |
| 207 | |
| 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); | |
| 224 | |
| 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); | |
| 240 | |
| 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); | |
| 257 | |
| 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); | |
| 273 | |
| 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); | |
| 289 | |
| 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); | |
| 306 | |
| 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); | |
| 324 | |
| 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); | |
| 341 | |
| 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); | |
| 359 | |
| 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); | |
| 375 | |
| 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); | |
| 391 | |
| 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); | |
| 408 | |
| 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); | |
| 426 | |
| 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); | |
| 443 | |
| 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); | |
| 461 | |
| 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); | |
| 477 | |
| 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); | |
| 493 | |
| 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); | |
| 510 | |
| 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); | |
| 528 | |
| 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); | |
| 545 | |
| 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); | |
| 563 | |
| 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); | |
| 579 | |
| 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); | |
| 595 | |
| 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); | |
| 612 | |
| 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); | |
| 630 | |
| 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); | |
| 647 | |
| 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); |
