bigint64-cmp.js (21799B)
1 const i64 = new BigInt64Array([ 2 -0x8000_0000_0000_0000n, 3 -0x7fff_ffff_ffff_ffffn, 4 5 -0x8000_0000n, 6 -0x7fff_ffffn, 7 8 -1n, 9 0n, 10 1n, 11 12 0x7fff_ffffn, 13 0x8000_0000n, 14 15 0x7fff_ffff_ffff_ffffn, 16 0x8000_0000_0000_0000n, 17 ]); 18 19 const u64 = new BigUint64Array([ 20 0n, 21 1n, 22 23 0x7fff_ffffn, 24 0x8000_0000n, 25 26 0xffff_ffffn, 27 0x1_0000_0000n, 28 29 0x7fff_ffff_ffff_ffffn, 30 0x8000_0000_0000_0000n, 31 0xffff_ffff_ffff_ffffn, 32 ]); 33 34 function gcd(a, b) { 35 a |= 0; 36 b |= 0; 37 while (b !== 0) { 38 [a, b] = [b, a % b]; 39 } 40 return Math.abs(a); 41 } 42 43 function assertAllCombinationsTested(xs, ys, n) { 44 // If the array lengths are relatively prime and their product is at least 45 // |n| long, all possible combinations are tested at least once. Make sure 46 // we test each combination at least three times. 47 var m = 3; 48 49 assertEq(gcd(xs.length, ys.length), 1); 50 assertEq(m * xs.length * ys.length <= n, true); 51 } 52 53 function fillWithZeros(ta) { 54 let length = ta.length; 55 let zeros = 1; 56 while (gcd(length, length + zeros) !== 1) { 57 zeros++; 58 } 59 60 let result = new ta.constructor(length + zeros); 61 result.set(ta); 62 return result; 63 } 64 65 function testI64() { 66 for (var i = 0; i < 200; ++i) { 67 var v = i64[i % i64.length]; 68 69 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 70 var eq_zero = v == BigInt.asIntN(128, 0n); 71 var lt_zero = v < BigInt.asIntN(128, 0n); 72 73 var eq_one = v == BigInt.asIntN(128, 1n); 74 var lt_one = v < BigInt.asIntN(128, 1n); 75 76 var eq_neg_one = v == BigInt.asIntN(128, -1n); 77 var lt_neg_one = v < BigInt.asIntN(128, -1n); 78 79 var eq_i31 = v == BigInt.asIntN(128, 0x8000_0000n); 80 var lt_i31 = v < BigInt.asIntN(128, 0x8000_0000n); 81 82 var eq_i32 = v == BigInt.asIntN(128, 0x1_0000_0000n); 83 var lt_i32 = v < BigInt.asIntN(128, 0x1_0000_0000n); 84 85 // BigInt constant 86 assertEq(v == 0n, eq_zero); 87 assertEq(v != 0n, !eq_zero); 88 assertEq(v < 0n, lt_zero && !eq_zero); 89 assertEq(v <= 0n, lt_zero || eq_zero); 90 assertEq(v > 0n, !lt_zero && !eq_zero); 91 assertEq(v >= 0n, !lt_zero || eq_zero); 92 93 assertEq(v == 1n, eq_one); 94 assertEq(v != 1n, !eq_one); 95 assertEq(v < 1n, lt_one && !eq_one); 96 assertEq(v <= 1n, lt_one || eq_one); 97 assertEq(v > 1n, !lt_one && !eq_one); 98 assertEq(v >= 1n, !lt_one || eq_one); 99 100 assertEq(v == -1n, eq_neg_one); 101 assertEq(v != -1n, !eq_neg_one); 102 assertEq(v < -1n, lt_neg_one && !eq_neg_one); 103 assertEq(v <= -1n, lt_neg_one || eq_neg_one); 104 assertEq(v > -1n, !lt_neg_one && !eq_neg_one); 105 assertEq(v >= -1n, !lt_neg_one || eq_neg_one); 106 107 assertEq(v == 0x8000_0000n, eq_i31); 108 assertEq(v != 0x8000_0000n, !eq_i31); 109 assertEq(v < 0x8000_0000n, lt_i31 && !eq_i31); 110 assertEq(v <= 0x8000_0000n, lt_i31 || eq_i31); 111 assertEq(v > 0x8000_0000n, !lt_i31 && !eq_i31); 112 assertEq(v >= 0x8000_0000n, !lt_i31 || eq_i31); 113 114 assertEq(v == 0x1_0000_0000n, eq_i32); 115 assertEq(v != 0x1_0000_0000n, !eq_i32); 116 assertEq(v < 0x1_0000_0000n, lt_i32 && !eq_i32); 117 assertEq(v <= 0x1_0000_0000n, lt_i32 || eq_i32); 118 assertEq(v > 0x1_0000_0000n, !lt_i32 && !eq_i32); 119 assertEq(v >= 0x1_0000_0000n, !lt_i32 || eq_i32); 120 } 121 } 122 testI64(); 123 124 function testI64_R() { 125 for (var i = 0; i < 200; ++i) { 126 var v = i64[i % i64.length]; 127 128 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 129 var eq_zero = v == BigInt.asIntN(128, 0n); 130 var lt_zero = v < BigInt.asIntN(128, 0n); 131 132 var eq_one = v == BigInt.asIntN(128, 1n); 133 var lt_one = v < BigInt.asIntN(128, 1n); 134 135 var eq_neg_one = v == BigInt.asIntN(128, -1n); 136 var lt_neg_one = v < BigInt.asIntN(128, -1n); 137 138 var eq_i31 = v == BigInt.asIntN(128, 0x8000_0000n); 139 var lt_i31 = v < BigInt.asIntN(128, 0x8000_0000n); 140 141 var eq_i32 = v == BigInt.asIntN(128, 0x1_0000_0000n); 142 var lt_i32 = v < BigInt.asIntN(128, 0x1_0000_0000n); 143 144 // BigInt constant. (Reserved operands) 145 assertEq(0n == v, eq_zero); 146 assertEq(0n != v, !eq_zero); 147 assertEq(0n > v, lt_zero && !eq_zero); 148 assertEq(0n >= v, lt_zero || eq_zero); 149 assertEq(0n < v, !lt_zero && !eq_zero); 150 assertEq(0n <= v, !lt_zero || eq_zero); 151 152 assertEq(1n == v, eq_one); 153 assertEq(1n != v, !eq_one); 154 assertEq(1n > v, lt_one && !eq_one); 155 assertEq(1n >= v, lt_one || eq_one); 156 assertEq(1n < v, !lt_one && !eq_one); 157 assertEq(1n <= v, !lt_one || eq_one); 158 159 assertEq(-1n == v, eq_neg_one); 160 assertEq(-1n != v, !eq_neg_one); 161 assertEq(-1n > v, lt_neg_one && !eq_neg_one); 162 assertEq(-1n >= v, lt_neg_one || eq_neg_one); 163 assertEq(-1n < v, !lt_neg_one && !eq_neg_one); 164 assertEq(-1n <= v, !lt_neg_one || eq_neg_one); 165 166 assertEq(0x8000_0000n == v, eq_i31); 167 assertEq(0x8000_0000n != v, !eq_i31); 168 assertEq(0x8000_0000n > v, lt_i31 && !eq_i31); 169 assertEq(0x8000_0000n >= v, lt_i31 || eq_i31); 170 assertEq(0x8000_0000n < v, !lt_i31 && !eq_i31); 171 assertEq(0x8000_0000n <= v, !lt_i31 || eq_i31); 172 173 assertEq(0x1_0000_0000n == v, eq_i32); 174 assertEq(0x1_0000_0000n != v, !eq_i32); 175 assertEq(0x1_0000_0000n > v, lt_i32 && !eq_i32); 176 assertEq(0x1_0000_0000n >= v, lt_i32 || eq_i32); 177 assertEq(0x1_0000_0000n < v, !lt_i32 && !eq_i32); 178 assertEq(0x1_0000_0000n <= v, !lt_i32 || eq_i32); 179 } 180 } 181 testI64_R(); 182 183 function testI64_I32Constant() { 184 for (var i = 0; i < 200; ++i) { 185 var v = i64[i % i64.length]; 186 187 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 188 var eq_zero = v == BigInt.asIntN(128, 0n); 189 var lt_zero = v < BigInt.asIntN(128, 0n); 190 191 var eq_one = v == BigInt.asIntN(128, 1n); 192 var lt_one = v < BigInt.asIntN(128, 1n); 193 194 var eq_neg_one = v == BigInt.asIntN(128, -1n); 195 var lt_neg_one = v < BigInt.asIntN(128, -1n); 196 197 var eq_i31 = v == BigInt.asIntN(128, 0x8000_0000n); 198 var lt_i31 = v < BigInt.asIntN(128, 0x8000_0000n); 199 200 var eq_i32 = v == BigInt.asIntN(128, 0x1_0000_0000n); 201 var lt_i32 = v < BigInt.asIntN(128, 0x1_0000_0000n); 202 203 // Int32 constant 204 assertEq(v == 0, eq_zero); 205 assertEq(v != 0, !eq_zero); 206 assertEq(v < 0, lt_zero && !eq_zero); 207 assertEq(v <= 0, lt_zero || eq_zero); 208 assertEq(v > 0, !lt_zero && !eq_zero); 209 assertEq(v >= 0, !lt_zero || eq_zero); 210 211 assertEq(v == 1, eq_one); 212 assertEq(v != 1, !eq_one); 213 assertEq(v < 1, lt_one && !eq_one); 214 assertEq(v <= 1, lt_one || eq_one); 215 assertEq(v > 1, !lt_one && !eq_one); 216 assertEq(v >= 1, !lt_one || eq_one); 217 218 assertEq(v == -1, eq_neg_one); 219 assertEq(v != -1, !eq_neg_one); 220 assertEq(v < -1, lt_neg_one && !eq_neg_one); 221 assertEq(v <= -1, lt_neg_one || eq_neg_one); 222 assertEq(v > -1, !lt_neg_one && !eq_neg_one); 223 assertEq(v >= -1, !lt_neg_one || eq_neg_one); 224 } 225 } 226 testI64_I32Constant(); 227 228 function testI64_I32Constant_R() { 229 for (var i = 0; i < 200; ++i) { 230 var v = i64[i % i64.length]; 231 232 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 233 var eq_zero = v == BigInt.asIntN(128, 0n); 234 var lt_zero = v < BigInt.asIntN(128, 0n); 235 236 var eq_one = v == BigInt.asIntN(128, 1n); 237 var lt_one = v < BigInt.asIntN(128, 1n); 238 239 var eq_neg_one = v == BigInt.asIntN(128, -1n); 240 var lt_neg_one = v < BigInt.asIntN(128, -1n); 241 242 var eq_i31 = v == BigInt.asIntN(128, 0x8000_0000n); 243 var lt_i31 = v < BigInt.asIntN(128, 0x8000_0000n); 244 245 var eq_i32 = v == BigInt.asIntN(128, 0x1_0000_0000n); 246 var lt_i32 = v < BigInt.asIntN(128, 0x1_0000_0000n); 247 248 // Int32 constant. (Reversed operands) 249 assertEq(0 == v, eq_zero); 250 assertEq(0 != v, !eq_zero); 251 assertEq(0 > v, lt_zero && !eq_zero); 252 assertEq(0 >= v, lt_zero || eq_zero); 253 assertEq(0 < v, !lt_zero && !eq_zero); 254 assertEq(0 <= v, !lt_zero || eq_zero); 255 256 assertEq(1 == v, eq_one); 257 assertEq(1 != v, !eq_one); 258 assertEq(1 > v, lt_one && !eq_one); 259 assertEq(1 >= v, lt_one || eq_one); 260 assertEq(1 < v, !lt_one && !eq_one); 261 assertEq(1 <= v, !lt_one || eq_one); 262 263 assertEq(-1 == v, eq_neg_one); 264 assertEq(-1 != v, !eq_neg_one); 265 assertEq(-1 > v, lt_neg_one && !eq_neg_one); 266 assertEq(-1 >= v, lt_neg_one || eq_neg_one); 267 assertEq(-1 < v, !lt_neg_one && !eq_neg_one); 268 assertEq(-1 <= v, !lt_neg_one || eq_neg_one); 269 } 270 } 271 testI64_I32Constant_R(); 272 273 function testI64_TooLargeConstant() { 274 for (var i = 0; i < 200; ++i) { 275 var v = i64[i % i64.length]; 276 277 // BigInt constant too large for I64. 278 assertEq(v == 0x8000_0000_0000_0000n, false); 279 assertEq(v != 0x8000_0000_0000_0000n, true); 280 assertEq(v < 0x8000_0000_0000_0000n, true); 281 assertEq(v <= 0x8000_0000_0000_0000n, true); 282 assertEq(v > 0x8000_0000_0000_0000n, false); 283 assertEq(v >= 0x8000_0000_0000_0000n, false); 284 285 assertEq(v == -0x8000_0000_0000_0001n, false); 286 assertEq(v != -0x8000_0000_0000_0001n, true); 287 assertEq(v < -0x8000_0000_0000_0001n, false); 288 assertEq(v <= -0x8000_0000_0000_0001n, false); 289 assertEq(v > -0x8000_0000_0000_0001n, true); 290 assertEq(v >= -0x8000_0000_0000_0001n, true); 291 292 assertEq(v == 0x1_0000_0000_0000_0000n, false); 293 assertEq(v != 0x1_0000_0000_0000_0000n, true); 294 assertEq(v < 0x1_0000_0000_0000_0000n, true); 295 assertEq(v <= 0x1_0000_0000_0000_0000n, true); 296 assertEq(v > 0x1_0000_0000_0000_0000n, false); 297 assertEq(v >= 0x1_0000_0000_0000_0000n, false); 298 } 299 } 300 testI64_TooLargeConstant(); 301 302 function testI64_TooLargeConstant_R() { 303 for (var i = 0; i < 200; ++i) { 304 var v = i64[i % i64.length]; 305 306 // BigInt constant too large for I64. (Reserved operands) 307 assertEq(0x8000_0000_0000_0000n == v, false); 308 assertEq(0x8000_0000_0000_0000n != v, true); 309 assertEq(0x8000_0000_0000_0000n > v, true); 310 assertEq(0x8000_0000_0000_0000n >= v, true); 311 assertEq(0x8000_0000_0000_0000n < v, false); 312 assertEq(0x8000_0000_0000_0000n <= v, false); 313 314 assertEq(-0x8000_0000_0000_0001n == v, false); 315 assertEq(-0x8000_0000_0000_0001n != v, true); 316 assertEq(-0x8000_0000_0000_0001n > v, false); 317 assertEq(-0x8000_0000_0000_0001n >= v, false); 318 assertEq(-0x8000_0000_0000_0001n < v, true); 319 assertEq(-0x8000_0000_0000_0001n <= v, true); 320 321 assertEq(0x1_0000_0000_0000_0000n == v, false); 322 assertEq(0x1_0000_0000_0000_0000n != v, true); 323 assertEq(0x1_0000_0000_0000_0000n > v, true); 324 assertEq(0x1_0000_0000_0000_0000n >= v, true); 325 assertEq(0x1_0000_0000_0000_0000n < v, false); 326 assertEq(0x1_0000_0000_0000_0000n <= v, false); 327 } 328 } 329 testI64_TooLargeConstant_R(); 330 331 function testU64() { 332 for (var i = 0; i < 200; ++i) { 333 var v = u64[i % u64.length]; 334 335 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 336 var eq_zero = v == BigInt.asUintN(128, 0n); 337 var lt_zero = v < BigInt.asUintN(128, 0n); 338 339 var eq_one = v == BigInt.asUintN(128, 1n); 340 var lt_one = v < BigInt.asUintN(128, 1n); 341 342 var eq_i31 = v == BigInt.asUintN(128, 0x8000_0000n); 343 var lt_i31 = v < BigInt.asUintN(128, 0x8000_0000n); 344 345 var eq_i32 = v == BigInt.asUintN(128, 0x1_0000_0000n); 346 var lt_i32 = v < BigInt.asUintN(128, 0x1_0000_0000n); 347 348 // BigInt constant 349 assertEq(v == 0n, eq_zero); 350 assertEq(v != 0n, !eq_zero); 351 assertEq(v < 0n, lt_zero && !eq_zero); 352 assertEq(v <= 0n, lt_zero || eq_zero); 353 assertEq(v > 0n, !lt_zero && !eq_zero); 354 assertEq(v >= 0n, !lt_zero || eq_zero); 355 356 assertEq(v == 1n, eq_one); 357 assertEq(v != 1n, !eq_one); 358 assertEq(v < 1n, lt_one && !eq_one); 359 assertEq(v <= 1n, lt_one || eq_one); 360 assertEq(v > 1n, !lt_one && !eq_one); 361 assertEq(v >= 1n, !lt_one || eq_one); 362 363 assertEq(v == 0x8000_0000n, eq_i31); 364 assertEq(v != 0x8000_0000n, !eq_i31); 365 assertEq(v < 0x8000_0000n, lt_i31 && !eq_i31); 366 assertEq(v <= 0x8000_0000n, lt_i31 || eq_i31); 367 assertEq(v > 0x8000_0000n, !lt_i31 && !eq_i31); 368 assertEq(v >= 0x8000_0000n, !lt_i31 || eq_i31); 369 370 assertEq(v == 0x1_0000_0000n, eq_i32); 371 assertEq(v != 0x1_0000_0000n, !eq_i32); 372 assertEq(v < 0x1_0000_0000n, lt_i32 && !eq_i32); 373 assertEq(v <= 0x1_0000_0000n, lt_i32 || eq_i32); 374 assertEq(v > 0x1_0000_0000n, !lt_i32 && !eq_i32); 375 assertEq(v >= 0x1_0000_0000n, !lt_i32 || eq_i32); 376 } 377 } 378 testU64(); 379 380 function testU64_R() { 381 for (var i = 0; i < 200; ++i) { 382 var v = u64[i % u64.length]; 383 384 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 385 var eq_zero = v == BigInt.asUintN(128, 0n); 386 var lt_zero = v < BigInt.asUintN(128, 0n); 387 388 var eq_one = v == BigInt.asUintN(128, 1n); 389 var lt_one = v < BigInt.asUintN(128, 1n); 390 391 var eq_i31 = v == BigInt.asUintN(128, 0x8000_0000n); 392 var lt_i31 = v < BigInt.asUintN(128, 0x8000_0000n); 393 394 var eq_i32 = v == BigInt.asUintN(128, 0x1_0000_0000n); 395 var lt_i32 = v < BigInt.asUintN(128, 0x1_0000_0000n); 396 397 // BigInt constant. (Reversed operands) 398 assertEq(0n == v, eq_zero); 399 assertEq(0n != v, !eq_zero); 400 assertEq(0n > v, lt_zero && !eq_zero); 401 assertEq(0n >= v, lt_zero || eq_zero); 402 assertEq(0n < v, !lt_zero && !eq_zero); 403 assertEq(0n <= v, !lt_zero || eq_zero); 404 405 assertEq(1n == v, eq_one); 406 assertEq(1n != v, !eq_one); 407 assertEq(1n > v, lt_one && !eq_one); 408 assertEq(1n >= v, lt_one || eq_one); 409 assertEq(1n < v, !lt_one && !eq_one); 410 assertEq(1n <= v, !lt_one || eq_one); 411 412 assertEq(0x8000_0000n == v, eq_i31); 413 assertEq(0x8000_0000n != v, !eq_i31); 414 assertEq(0x8000_0000n > v, lt_i31 && !eq_i31); 415 assertEq(0x8000_0000n >= v, lt_i31 || eq_i31); 416 assertEq(0x8000_0000n < v, !lt_i31 && !eq_i31); 417 assertEq(0x8000_0000n <= v, !lt_i31 || eq_i31); 418 419 assertEq(0x1_0000_0000n == v, eq_i32); 420 assertEq(0x1_0000_0000n != v, !eq_i32); 421 assertEq(0x1_0000_0000n > v, lt_i32 && !eq_i32); 422 assertEq(0x1_0000_0000n >= v, lt_i32 || eq_i32); 423 assertEq(0x1_0000_0000n < v, !lt_i32 && !eq_i32); 424 assertEq(0x1_0000_0000n <= v, !lt_i32 || eq_i32); 425 } 426 } 427 testU64_R(); 428 429 function testU64_I32Constant() { 430 for (var i = 0; i < 200; ++i) { 431 var v = u64[i % u64.length]; 432 433 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 434 var eq_zero = v == BigInt.asUintN(128, 0n); 435 var lt_zero = v < BigInt.asUintN(128, 0n); 436 437 var eq_one = v == BigInt.asUintN(128, 1n); 438 var lt_one = v < BigInt.asUintN(128, 1n); 439 440 var eq_i31 = v == BigInt.asUintN(128, 0x8000_0000n); 441 var lt_i31 = v < BigInt.asUintN(128, 0x8000_0000n); 442 443 var eq_i32 = v == BigInt.asUintN(128, 0x1_0000_0000n); 444 var lt_i32 = v < BigInt.asUintN(128, 0x1_0000_0000n); 445 446 // Int32 constant 447 assertEq(v == 0, eq_zero); 448 assertEq(v != 0, !eq_zero); 449 assertEq(v < 0, lt_zero && !eq_zero); 450 assertEq(v <= 0, lt_zero || eq_zero); 451 assertEq(v > 0, !lt_zero && !eq_zero); 452 assertEq(v >= 0, !lt_zero || eq_zero); 453 454 assertEq(v == 1, eq_one); 455 assertEq(v != 1, !eq_one); 456 assertEq(v < 1, lt_one && !eq_one); 457 assertEq(v <= 1, lt_one || eq_one); 458 assertEq(v > 1, !lt_one && !eq_one); 459 assertEq(v >= 1, !lt_one || eq_one); 460 } 461 } 462 testU64_I32Constant(); 463 464 function testU64_I32Constant_R() { 465 for (var i = 0; i < 200; ++i) { 466 var v = u64[i % u64.length]; 467 468 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 469 var eq_zero = v == BigInt.asUintN(128, 0n); 470 var lt_zero = v < BigInt.asUintN(128, 0n); 471 472 var eq_one = v == BigInt.asUintN(128, 1n); 473 var lt_one = v < BigInt.asUintN(128, 1n); 474 475 var eq_i31 = v == BigInt.asUintN(128, 0x8000_0000n); 476 var lt_i31 = v < BigInt.asUintN(128, 0x8000_0000n); 477 478 var eq_i32 = v == BigInt.asUintN(128, 0x1_0000_0000n); 479 var lt_i32 = v < BigInt.asUintN(128, 0x1_0000_0000n); 480 481 // Int32 constant. (Reversed operands) 482 assertEq(0 == v, eq_zero); 483 assertEq(0 != v, !eq_zero); 484 assertEq(0 > v, lt_zero && !eq_zero); 485 assertEq(0 >= v, lt_zero || eq_zero); 486 assertEq(0 < v, !lt_zero && !eq_zero); 487 assertEq(0 <= v, !lt_zero || eq_zero); 488 489 assertEq(1 == v, eq_one); 490 assertEq(1 != v, !eq_one); 491 assertEq(1 > v, lt_one && !eq_one); 492 assertEq(1 >= v, lt_one || eq_one); 493 assertEq(1 < v, !lt_one && !eq_one); 494 assertEq(1 <= v, !lt_one || eq_one); 495 } 496 } 497 testU64_I32Constant_R(); 498 499 function testU64_NegativeOrTooLargeConstant() { 500 for (var i = 0; i < 200; ++i) { 501 var v = u64[i % u64.length]; 502 503 // BigInt constant too large for U64. 504 assertEq(v == 0x1_0000_0000_0000_0000n, false); 505 assertEq(v != 0x1_0000_0000_0000_0000n, true); 506 assertEq(v < 0x1_0000_0000_0000_0000n, true); 507 assertEq(v <= 0x1_0000_0000_0000_0000n, true); 508 assertEq(v > 0x1_0000_0000_0000_0000n, false); 509 assertEq(v >= 0x1_0000_0000_0000_0000n, false); 510 511 // Negative BigInt constant 512 assertEq(v == -1n, false); 513 assertEq(v != -1n, true); 514 assertEq(v < -1n, false); 515 assertEq(v <= -1n, false); 516 assertEq(v > -1n, true); 517 assertEq(v >= -1n, true); 518 519 // Negative Int32 constant 520 assertEq(v == -1, false); 521 assertEq(v != -1, true); 522 assertEq(v < -1, false); 523 assertEq(v <= -1, false); 524 assertEq(v > -1, true); 525 assertEq(v >= -1, true); 526 } 527 } 528 testU64_NegativeOrTooLargeConstant(); 529 530 function testU64_NegativeOrTooLargeConstant_R() { 531 for (var i = 0; i < 200; ++i) { 532 var v = u64[i % u64.length]; 533 534 // BigInt constant too large for U64. (Reversed operands) 535 assertEq(0x1_0000_0000_0000_0000n == v, false); 536 assertEq(0x1_0000_0000_0000_0000n != v, true); 537 assertEq(0x1_0000_0000_0000_0000n > v, true); 538 assertEq(0x1_0000_0000_0000_0000n >= v, true); 539 assertEq(0x1_0000_0000_0000_0000n < v, false); 540 assertEq(0x1_0000_0000_0000_0000n <= v, false); 541 542 // Negative BigInt constant. (Reversed operands) 543 assertEq(-1n == v, false); 544 assertEq(-1n != v, true); 545 assertEq(-1n > v, false); 546 assertEq(-1n >= v, false); 547 assertEq(-1n < v, true); 548 assertEq(-1n <= v, true); 549 550 // Negative Int32 constant. (Reversed operands) 551 assertEq(-1 == v, false); 552 assertEq(-1 != v, true); 553 assertEq(-1 > v, false); 554 assertEq(-1 >= v, false); 555 assertEq(-1 < v, true); 556 assertEq(-1 <= v, true); 557 } 558 } 559 testU64_NegativeOrTooLargeConstant_R(); 560 561 // Compare Int64 against Int64. 562 function testII64() { 563 var r64 = fillWithZeros(i64); 564 assertAllCombinationsTested(i64, r64, 500); 565 566 for (var i = 0; i < 500; ++i) { 567 var v = i64[i % i64.length]; 568 var w = r64[i % r64.length]; 569 570 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 571 var eq = v == BigInt.asIntN(128, w); 572 var lt = v < BigInt.asIntN(128, w); 573 574 assertEq(v == w, eq); 575 assertEq(v != w, !eq); 576 assertEq(v < w, lt && !eq); 577 assertEq(v <= w, lt || eq); 578 assertEq(v > w, !lt && !eq); 579 assertEq(v >= w, !lt || eq); 580 } 581 } 582 testII64(); 583 584 // Compare Uint64 against Uint64. 585 function testUU64() { 586 var r64 = fillWithZeros(u64); 587 assertAllCombinationsTested(u64, r64, 500); 588 589 for (var i = 0; i < 500; ++i) { 590 var v = u64[i % u64.length]; 591 var w = r64[i % r64.length]; 592 593 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 594 var eq = v == BigInt.asUintN(128, w); 595 var lt = v < BigInt.asUintN(128, w); 596 597 assertEq(v == w, eq); 598 assertEq(v != w, !eq); 599 assertEq(v < w, lt && !eq); 600 assertEq(v <= w, lt || eq); 601 assertEq(v > w, !lt && !eq); 602 assertEq(v >= w, !lt || eq); 603 } 604 } 605 testUU64(); 606 607 // Compare Int64 against Uint64. 608 function testIU64() { 609 var r64 = new BigUint64Array(i64.buffer); 610 for (var i = 0; i < 200; ++i) { 611 var v = i64[i % i64.length]; 612 var w = r64[i % r64.length]; 613 614 // Cast to Uint128 to ensure non-optimized BigInt comparison is used. 615 var eq = v == BigInt.asUintN(128, v); 616 var lt = v < BigInt.asUintN(128, v); 617 618 assertEq(v == w, eq); 619 assertEq(v != w, !eq); 620 assertEq(v < w, lt && !eq); 621 assertEq(v <= w, lt || eq); 622 assertEq(v > w, !lt && !eq); 623 assertEq(v >= w, !lt || eq); 624 } 625 } 626 testIU64(); 627 628 // Compare Uint64 against Int64. 629 function testUI64() { 630 var r64 = new BigUint64Array(u64.buffer); 631 for (var i = 0; i < 200; ++i) { 632 var v = u64[i % u64.length]; 633 var w = r64[i % r64.length]; 634 635 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 636 var eq = v == BigInt.asIntN(128, v); 637 var lt = v < BigInt.asIntN(128, v); 638 639 assertEq(v == w, eq); 640 assertEq(v != w, !eq); 641 assertEq(v < w, lt && !eq); 642 assertEq(v <= w, lt || eq); 643 assertEq(v > w, !lt && !eq); 644 assertEq(v >= w, !lt || eq); 645 } 646 } 647 testUI64(); 648 649 // Compare Int64 against IntPtr. 650 function testI64IPtr() { 651 var r64 = fillWithZeros(i64); 652 assertAllCombinationsTested(i64, r64, 500); 653 654 for (var i = 0; i < 500; ++i) { 655 var v = i64[i % i64.length]; 656 var w = r64[i % r64.length]; 657 658 // Apply an operation to execute BigInt as IntPtr codepaths. 659 w = BigInt.asIntN(32, w); 660 var x = w < 0 ? 1n : w > 0 ? -1n : 0n; 661 w += x; 662 663 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 664 var eq = v == BigInt.asIntN(128, w); 665 var lt = v < BigInt.asIntN(128, w); 666 667 assertEq(v == w, eq); 668 assertEq(v != w, !eq); 669 assertEq(v < w, lt && !eq); 670 assertEq(v <= w, lt || eq); 671 assertEq(v > w, !lt && !eq); 672 assertEq(v >= w, !lt || eq); 673 } 674 } 675 testI64IPtr(); 676 677 // Compare IntPtr against Int64. 678 function testIPtrI64() { 679 var r64 = fillWithZeros(i64); 680 assertAllCombinationsTested(i64, r64, 500); 681 682 for (var i = 0; i < 500; ++i) { 683 var v = i64[i % i64.length]; 684 var w = r64[i % r64.length]; 685 686 // Apply an operation to execute BigInt as IntPtr codepaths. 687 v = BigInt.asIntN(32, v); 688 var x = v < 0 ? 1n : v > 0 ? -1n : 0n; 689 v += x; 690 691 // Cast to Int128 to ensure non-optimized BigInt comparison is used. 692 var eq = v == BigInt.asIntN(128, w); 693 var lt = v < BigInt.asIntN(128, w); 694 695 assertEq(v == w, eq); 696 assertEq(v != w, !eq); 697 assertEq(v < w, lt && !eq); 698 assertEq(v <= w, lt || eq); 699 assertEq(v > w, !lt && !eq); 700 assertEq(v >= w, !lt || eq); 701 } 702 } 703 testIPtrI64();