Dante/Kmake
1
0
Fork 0
forked from LeenkxTeam/Kmake
Code Pull Requests Activity

Upload Kmake

Browse Source
This commit is contained in:
Gorochu
2026-05-26 23:36:42 -07:00
parent ba051b2f74
commit 555ec72358
41615 changed files with 13344630 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
deps/v8/test/mjsunit/harmony/bigint/add.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: -0xc4043e2c4cc49e4d6870103ce7c2ff2d512bf4b1b67553ba410db514ee0af8888ad6cfn,
b: 0x2aae86de73ff479133a657a40d26e8dcf192019c7421836615ec34978bad93n,
r: -0xc4043e2c2216176ef470c8abb41ca78944050bd4c4e3521dccec31aed81ec3f0ff293cn
}, {
a: -0xee0933b25c8c0ef09fa385ffa1d3ca76855b560e186d27fa9f6ce105cb8517a4aecd5n,
b: -0x2ffc3a7babad313ede574774cb55cd40ab3b2n,
r: -0xee0933b25c8c0ef09fa385ffa1d3ca76b5579089c41a59397dc4287a96dae4e55a087n
}, {
a: -0xdbb3e8fac212affdeda8959829838af77e43172n,
b: 0x2315999da3ac2ab89d2076cbe6e2e03082352e92c274680117ce7012dn,
r: 0x2315999da3ac2ab89c44c2e2ec20cd80844785fd2a4ae47620502cfbbn
}, {
a: -0x5ad9780b309c24919defb1b331ebba4en,
b: 0xbe8dd806b3da0f79e7f6ad2fb566536cc78c1471c236891ce0n,
r: 0xbe8dd806b3da0f79e79bd3b7aa35b74835ee24c00f049d6292n
}, {
a: -0xade45eac6aaaf2c8097d7a3efecba4e80dd7aac4f692cfe841d113e68096c0218d521an,
b: -0x73c4119b366e22edd0797b5883a13e3bfc4124a559903ce785e0c833a8306b41cfn,
r: -0xade4d2707c4629362c6b4ab87a2428894c13a7061b3829787eb899c748ca6851f893e9n
}, {
a: -0x6e9ab93d5cff3b3f31a55aa2f43fc321bff6978189e00fa4e64cn,
b: 0xec1caec29eb55312a313e50e20178873a350f1f89cbc971n,
r: -0x6e9aaa7b92131153dc743071b5eee120476f5d4c7ac085d91cdbn
}, {
a: -0x9a61c05bd53b74b731b8f8687e64d1ed1340404b5137ce39n,
b: -0x1e6793ea0fa51b2354b48n,
r: -0x9a61c05bd53b74b731b8f8687e66b86651e13a9d036d1981n
}, {
a: -0x7c5a08517038f7dn,
b: 0x1d89f2n,
r: -0x7c5a08516e6058bn
}, {
a: -0xc4fd1b5aae2cfdc7b3ea6a74b7926a9a1ca3513bd08341e0c770080ban,
b: 0x76c79770202f9d9c6d2e244n,
r: -0xc4fd1b5aae2cfdc7b3ea6a74b7926a9a1c2c89a4606312432b02d9e76n
}, {
a: 0xda114ddab6bfed910cc05c64f72961107beb98c3271n,
b: 0x98c52c393c6660663248fcbaa300b8n,
r: 0xda114ddab6bff71d5f83f02b5d2fc4350bb742f3329n
}, {
a: -0x46311d926dfd26f0850ea3497fcd0d95a5dabab0361f219a601dc3dbe35d0n,
b: -0xf340af7b84e4eced2ca613e1ef4bb6aec4b8f01bc3n,
r: -0x46311d926dfd26f0851dd75477855be474ad8511743e1655cb0a0f6ae5193n
}, {
a: 0xb2b4d9c0c73258a8092n,
b: 0xf4d1c3d2861cc0bfaea456c03b0f548a32effc1c3e1593935a6b0n,
r: 0xf4d1c3d2861cc0bfaea456c03b0f548a33a2b0f5fedcc5ec02742n
}, {
a: -0x56604879bdaaff7409cd59cfbafe73a74c284bfaeb991b6e11171bc08cf68bean,
b: 0xf4016a6e94c0f256af54fca00d6c909a620c6ea950c73cade3724174c12888n,
r: -0x556c470f4f163e81b31e04d31af10716b1c63f8c424854316333a97f18356362n
}, {
a: -0x7a238c856c50aee41d1a2a1446a77f1567n,
b: 0x58n,
r: -0x7a238c856c50aee41d1a2a1446a77f150fn
}, {
a: 0xcdaf8c242e5da7265cc715871c3n,
b: -0x63604dd2b8df176c627ce3b018b2e74448746123d5578e66e9c0n,
r: -0x63604dd2b8df176c627ce3b00bd7ee82058e86b16f8b1d0e77fdn
}, {
a: 0xfa254e9c8d182d2bd90d8ff2b25d4e9819900b62b9ef60f3744ddc55cd362den,
b: -0x1fef80ff5d53dd0adaa75e8f0d16429851de115822n,
r: 0xfa254e9c8d182d2bd90d8df3ba4d58c2dbbf5db84406702210245737ec20abcn
}, {
a: 0x3e85cn,
b: 0x687c558b2c1308c1a133d647ff7en,
r: 0x687c558b2c1308c1a133d64be7dan
}, {
a: 0x9011db3dd56dbf2ef06154cbd48a67f6038483cff59f49011e57n,
b: 0xc033be10adcb6a7a5a697a7ef95ac3680611ff7ef690231314d338an,
r: 0xc03cbf2e61a8c1564d58809446180c0e857237c7338f7d07a4e51e1n
}, {
a: -0xefac02ab40df0f00a1b97a4n,
b: 0xc3b5e53656cd891e179ec3fb8a8d192f9bab5cfd76c014400n,
r: 0xc3b5e53656cd891e179ec3fb899d6d2cf06a7dee761e5ac5cn
}, {
a: -0x7f9d48b408a5bb3827bc0149ecd538a2b2a7d4e1e0a4e9c36ee05f8be3a5b3n,
b: 0xd83d8cb2fb784703498cf0d61ff097ca42635664058cb85ea39f5931c37a1n,
r: -0x72196fe8d8ee36c7f323323c8ad62f260e819f7ba04c1e3d84a669f8c76e12n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a + d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: +");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

105
deps/v8/test/mjsunit/harmony/bigint/and.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x9252b94f220ded0c18706998886397699c5a25527575dn,
b: -0x286817ba2e8fd8n,
r: 0x9252b94f220ded0c1870699888639769185a045015008n
}, {
a: 0x15a28152354fe421bbe4649d4d22d536ac34f9ba962n,
b: 0x8n,
r: 0n
}, {
a: 0xd09791bf7ae6703fae8d654104f54fcd957bbf028540b8e7c0f859fdcc1b7abd617en,
b: 0x24b473d03n,
r: 0x24a052102n
}, {
a: 0x2f73fbd05e9f7f70beba3dc7cd883732149a3d02a422f90f336n,
b: 0x4490583f8n,
r: 0x9008330n
}, {
a: 0xd6ea27844b3d356774e73de10d393ab9cadb81848e3b4a34d1f7440d3n,
b: 0x1639eeee731f3ba09234b5e15ec92f8bfb5cea28a0e89c59ed1c45b5f04n,
r: 0x10ea26000b39200234a5214009290ab948ca008088184824104504000n
}, {
a: -0x131f5e2c196269fd140c8727a9a02170e0dddb6aec109a89bcn,
b: 0x401ec4eae8b756f2b222f6f565fb6acecce3c524e9b453n,
r: 0x12c488800242f230005655448b0a0204810124613440n
}, {
a: -0x5bcba128bf7b949780a4bd02782a63ae79f646a33b8672f3f692ab98n,
b: -0xa81dd8ff624072fce3a00eb0bd5700e5666c3beb7d59701c42489n,
r: -0x5bcba1fdbfffb497afeebf02fb2bf7fe7ff666e3bfb7f7f7f7d6afa0n
}, {
a: 0xc997546528786548270061bcn,
b: 0x75023f046c04f9095f64d3b8c75ab21950an,
r: 0x499014640838044023000108n
}, {
a: 0x5ad0abd6e43ef787248af2607fb29b9c3f7a1e7b106269ff3bn,
b: -0xd483c8630392db4b620e0f6n,
r: 0x5ad0abd6e43ef787248af2607fb29380394a06520040491f0an
}, {
a: -0x9ed448bdb4794e4c0485db9ebe6cad0b0n,
b: -0x549a70753c9afn,
r: -0x9ed448bdb4794e4c0485df9efe7dbd9b0n
}, {
a: -0x3a3fe42647633612082372714484767efc9673ce964b76f9f53a63d5n,
b: 0x99615e5edd0506cbb5512fb56ee2dd1238bn,
r: 0x986116189800068881100b0000608c1000bn
}, {
a: -0xac1b8238c08f5n,
b: -0xb9439dfbbc70e12b3a1fc7ccbfebeacd9bb321d83d3an,
r: -0xb9439dfbbc70e12b3a1fc7ccbfebeacfdbbb23dc3dfen
}, {
a: 0x120580503n,
b: 0x90e13d34618496af407fabefabdd23892f488n,
r: 0x20100400n
}, {
a: 0xaa51cn,
b: 0x2122a9c43b2531d5n,
r: 0x2114n
}, {
a: 0xaf43eb353c1547dc6ad79768e9a6n,
b: 0x55c80f89d8fe82dbf69eca557dd0479b6a449db77e38b2241ec81aa7d4042766dd3e63n,
r: 0x28022014081007d4000706482822n
}, {
a: 0xbd38b2d88212ceea6fbe3890769e46236n,
b: 0xeb22e568873e9bfdb5d2ddbc03n,
r: 0x88202468863a83890540c42002n
}, {
a: 0x24cd8c9634eddf319c57b54dffb49ce4974528f03b2c732d052ad496n,
b: -0x4079cfn,
r: 0x24cd8c9634eddf319c57b54dffb49ce4974528f03b2c732d052a8410n
}, {
a: -0x61f263476a1212fce55cf7d437f4364b73a1815a641n,
b: -0x19226cb79772cca166043a29d1f0fe1df5n,
r: -0x61f263476b9236fffd7fffde37f477ebffbf8ffbff5n
}, {
a: -0x44309b08a65bc7dc1e53d598d82ccdaa852941d7c851d907a6acn,
b: 0xdd93dc17d38658ee30453d5f27en,
r: 0x5d1304178102408230402d05054n
}, {
a: 0x1e3eea4668e7a6c3bfa87d3f7a419bd18an,
b: -0x592d83940f884f9n,
r: 0x1e3eea4668e7a6c3bfa86d274201035102n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a & d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: &");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

304
deps/v8/test/mjsunit/harmony/bigint/as-int-n.js vendored Normal file
View File

@ -0,0 +1,304 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// BigInt.asIntN
{
assertEquals(2, BigInt.asIntN.length);
}{
assertEquals(-1n, BigInt.asIntN(3, 15n));
assertEquals(-2n, BigInt.asIntN(3, 14n));
assertEquals(-3n, BigInt.asIntN(3, 13n));
assertEquals(-4n, BigInt.asIntN(3, 12n));
assertEquals(3n, BigInt.asIntN(3, 11n));
assertEquals(2n, BigInt.asIntN(3, 10n));
assertEquals(1n, BigInt.asIntN(3, 9n));
assertEquals(0n, BigInt.asIntN(3, 8n));
assertEquals(-1n, BigInt.asIntN(3, 7n));
assertEquals(-2n, BigInt.asIntN(3, 6n));
assertEquals(-3n, BigInt.asIntN(3, 5n));
assertEquals(-4n, BigInt.asIntN(3, 4n));
assertEquals(3n, BigInt.asIntN(3, 3n));
assertEquals(2n, BigInt.asIntN(3, 2n));
assertEquals(1n, BigInt.asIntN(3, 1n));
assertEquals(0n, BigInt.asIntN(3, 0n));
assertEquals(-1n, BigInt.asIntN(3, -1n));
assertEquals(-2n, BigInt.asIntN(3, -2n));
assertEquals(-3n, BigInt.asIntN(3, -3n));
assertEquals(-4n, BigInt.asIntN(3, -4n));
assertEquals(3n, BigInt.asIntN(3, -5n));
assertEquals(2n, BigInt.asIntN(3, -6n));
assertEquals(1n, BigInt.asIntN(3, -7n));
assertEquals(0n, BigInt.asIntN(3, -8n));
assertEquals(-1n, BigInt.asIntN(3, -9n));
assertEquals(-2n, BigInt.asIntN(3, -10n));
assertEquals(-3n, BigInt.asIntN(3, -11n));
assertEquals(-4n, BigInt.asIntN(3, -12n));
assertEquals(3n, BigInt.asIntN(3, -13n));
assertEquals(2n, BigInt.asIntN(3, -14n));
assertEquals(1n, BigInt.asIntN(3, -15n));
}{
assertEquals(254n, BigInt.asIntN(10, 254n));
assertEquals(255n, BigInt.asIntN(10, 255n));
assertEquals(256n, BigInt.asIntN(10, 256n));
assertEquals(257n, BigInt.asIntN(10, 257n));
assertEquals(510n, BigInt.asIntN(10, 510n));
assertEquals(511n, BigInt.asIntN(10, 511n));
assertEquals(-512n, BigInt.asIntN(10, 512n));
assertEquals(-511n, BigInt.asIntN(10, 513n));
assertEquals(-2n, BigInt.asIntN(10, 1022n));
assertEquals(-1n, BigInt.asIntN(10, 1023n));
assertEquals(0n, BigInt.asIntN(10, 1024n));
assertEquals(1n, BigInt.asIntN(10, 1025n));
}{
assertEquals(-254n, BigInt.asIntN(10, -254n));
assertEquals(-255n, BigInt.asIntN(10, -255n));
assertEquals(-256n, BigInt.asIntN(10, -256n));
assertEquals(-257n, BigInt.asIntN(10, -257n));
assertEquals(-510n, BigInt.asIntN(10, -510n));
assertEquals(-511n, BigInt.asIntN(10, -511n));
assertEquals(-512n, BigInt.asIntN(10, -512n));
assertEquals(511n, BigInt.asIntN(10, -513n));
assertEquals(2n, BigInt.asIntN(10, -1022n));
assertEquals(1n, BigInt.asIntN(10, -1023n));
assertEquals(0n, BigInt.asIntN(10, -1024n));
assertEquals(-1n, BigInt.asIntN(10, -1025n));
}{
assertEquals(0n, BigInt.asIntN(0, 0n));
assertEquals(0n, BigInt.asIntN(1, 0n));
assertEquals(0n, BigInt.asIntN(16, 0n));
assertEquals(0n, BigInt.asIntN(31, 0n));
assertEquals(0n, BigInt.asIntN(32, 0n));
assertEquals(0n, BigInt.asIntN(33, 0n));
assertEquals(0n, BigInt.asIntN(63, 0n));
assertEquals(0n, BigInt.asIntN(64, 0n));
assertEquals(0n, BigInt.asIntN(65, 0n));
assertEquals(0n, BigInt.asIntN(127, 0n));
assertEquals(0n, BigInt.asIntN(128, 0n));
assertEquals(0n, BigInt.asIntN(129, 0n));
}{
assertEquals(0n, BigInt.asIntN(0, 42n));
assertEquals(0n, BigInt.asIntN(1, 42n));
assertEquals(42n, BigInt.asIntN(16, 42n));
assertEquals(42n, BigInt.asIntN(31, 42n));
assertEquals(42n, BigInt.asIntN(32, 42n));
assertEquals(42n, BigInt.asIntN(33, 42n));
assertEquals(42n, BigInt.asIntN(63, 42n));
assertEquals(42n, BigInt.asIntN(64, 42n));
assertEquals(42n, BigInt.asIntN(65, 42n));
assertEquals(42n, BigInt.asIntN(127, 42n));
assertEquals(42n, BigInt.asIntN(128, 42n));
assertEquals(42n, BigInt.asIntN(129, 42n));
}{
assertEquals(0n, BigInt.asIntN(0, -42n));
assertEquals(0n, BigInt.asIntN(1, -42n));
assertEquals(-42n, BigInt.asIntN(16, -42n));
assertEquals(-42n, BigInt.asIntN(31, -42n));
assertEquals(-42n, BigInt.asIntN(32, -42n));
assertEquals(-42n, BigInt.asIntN(33, -42n));
assertEquals(-42n, BigInt.asIntN(63, -42n));
assertEquals(-42n, BigInt.asIntN(64, -42n));
assertEquals(-42n, BigInt.asIntN(65, -42n));
assertEquals(-42n, BigInt.asIntN(127, -42n));
assertEquals(-42n, BigInt.asIntN(128, -42n));
assertEquals(-42n, BigInt.asIntN(129, -42n));
}{
assertEquals(0n, BigInt.asIntN(0, 4294967295n));
assertEquals(-1n, BigInt.asIntN(1, 4294967295n));
assertEquals(-1n, BigInt.asIntN(16, 4294967295n));
assertEquals(-1n, BigInt.asIntN(31, 4294967295n));
assertEquals(-1n, BigInt.asIntN(32, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(33, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(63, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(64, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(65, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(127, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(128, 4294967295n));
assertEquals(4294967295n, BigInt.asIntN(129, 4294967295n));
}{
assertEquals(0n, BigInt.asIntN(0, -4294967295n));
assertEquals(-1n, BigInt.asIntN(1, -4294967295n));
assertEquals(1n, BigInt.asIntN(16, -4294967295n));
assertEquals(1n, BigInt.asIntN(31, -4294967295n));
assertEquals(1n, BigInt.asIntN(32, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(33, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(63, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(64,-4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(65, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(127, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(128, -4294967295n));
assertEquals(-4294967295n, BigInt.asIntN(129, -4294967295n));
}{
assertEquals(42n, BigInt.asIntN(2**32, 42n));
assertEquals(4294967295n, BigInt.asIntN(2**32, 4294967295n));
assertEquals(4294967296n, BigInt.asIntN(2**32, 4294967296n));
assertEquals(4294967297n, BigInt.asIntN(2**32, 4294967297n));
}{
assertThrows(() => BigInt.asIntN(2n, 12n), TypeError);
assertThrows(() => BigInt.asIntN(-1, 0n), RangeError);
assertThrows(() => BigInt.asIntN(2**53, 0n), RangeError);
assertEquals(0n, BigInt.asIntN({}, 12n));
assertEquals(0n, BigInt.asIntN(2.9999, 12n));
assertEquals(-4n, BigInt.asIntN(3.1234, 12n));
}{
assertThrows(() => BigInt.asIntN(3, 12), TypeError);
assertEquals(-4n, BigInt.asIntN(3, "12"));
assertEquals(0x123456789abcdefn,
BigInt.asIntN(64, 0xabcdef0123456789abcdefn));
}{
// Regression test for crbug.com/v8/8426.
assertEquals(-0x8000000000000000n,
BigInt.asIntN(64, -0x8000000000000000n));
}
// BigInt.asUintN
{
assertEquals(2, BigInt.asUintN.length);
}{
assertEquals(7n, BigInt.asUintN(3, 15n));
assertEquals(6n, BigInt.asUintN(3, 14n));
assertEquals(5n, BigInt.asUintN(3, 13n));
assertEquals(4n, BigInt.asUintN(3, 12n));
assertEquals(3n, BigInt.asUintN(3, 11n));
assertEquals(2n, BigInt.asUintN(3, 10n));
assertEquals(1n, BigInt.asUintN(3, 9n));
assertEquals(0n, BigInt.asUintN(3, 8n));
assertEquals(7n, BigInt.asUintN(3, 7n));
assertEquals(6n, BigInt.asUintN(3, 6n));
assertEquals(5n, BigInt.asUintN(3, 5n));
assertEquals(4n, BigInt.asUintN(3, 4n));
assertEquals(3n, BigInt.asUintN(3, 3n));
assertEquals(2n, BigInt.asUintN(3, 2n));
assertEquals(1n, BigInt.asUintN(3, 1n));
assertEquals(0n, BigInt.asUintN(3, 0n));
assertEquals(7n, BigInt.asUintN(3, -1n));
assertEquals(6n, BigInt.asUintN(3, -2n));
assertEquals(5n, BigInt.asUintN(3, -3n));
assertEquals(4n, BigInt.asUintN(3, -4n));
assertEquals(3n, BigInt.asUintN(3, -5n));
assertEquals(2n, BigInt.asUintN(3, -6n));
assertEquals(1n, BigInt.asUintN(3, -7n));
assertEquals(0n, BigInt.asUintN(3, -8n));
assertEquals(7n, BigInt.asUintN(3, -9n));
assertEquals(6n, BigInt.asUintN(3, -10n));
assertEquals(5n, BigInt.asUintN(3, -11n));
assertEquals(4n, BigInt.asUintN(3, -12n));
assertEquals(3n, BigInt.asUintN(3, -13n));
assertEquals(2n, BigInt.asUintN(3, -14n));
assertEquals(1n, BigInt.asUintN(3, -15n));
}{
assertEquals(254n, BigInt.asUintN(10, 254n));
assertEquals(255n, BigInt.asUintN(10, 255n));
assertEquals(256n, BigInt.asUintN(10, 256n));
assertEquals(257n, BigInt.asUintN(10, 257n));
assertEquals(510n, BigInt.asUintN(10, 510n));
assertEquals(511n, BigInt.asUintN(10, 511n));
assertEquals(512n, BigInt.asUintN(10, 512n));
assertEquals(513n, BigInt.asUintN(10, 513n));
assertEquals(1022n, BigInt.asUintN(10, 1022n));
assertEquals(1023n, BigInt.asUintN(10, 1023n));
assertEquals(0n, BigInt.asUintN(10, 1024n));
assertEquals(1n, BigInt.asUintN(10, 1025n));
}{
assertEquals(1024n - 254n, BigInt.asUintN(10, -254n));
assertEquals(1024n - 255n, BigInt.asUintN(10, -255n));
assertEquals(1024n - 256n, BigInt.asUintN(10, -256n));
assertEquals(1024n - 257n, BigInt.asUintN(10, -257n));
assertEquals(1024n - 510n, BigInt.asUintN(10, -510n));
assertEquals(1024n - 511n, BigInt.asUintN(10, -511n));
assertEquals(1024n - 512n, BigInt.asUintN(10, -512n));
assertEquals(1024n - 513n, BigInt.asUintN(10, -513n));
assertEquals(1024n - 1022n, BigInt.asUintN(10, -1022n));
assertEquals(1024n - 1023n, BigInt.asUintN(10, -1023n));
assertEquals(0n, BigInt.asUintN(10, -1024n));
assertEquals(1023n, BigInt.asUintN(10, -1025n));
}{
assertEquals(0n, BigInt.asUintN(0, 0n));
assertEquals(0n, BigInt.asUintN(1, 0n));
assertEquals(0n, BigInt.asUintN(16, 0n));
assertEquals(0n, BigInt.asUintN(31, 0n));
assertEquals(0n, BigInt.asUintN(32, 0n));
assertEquals(0n, BigInt.asUintN(33, 0n));
assertEquals(0n, BigInt.asUintN(63, 0n));
assertEquals(0n, BigInt.asUintN(64, 0n));
assertEquals(0n, BigInt.asUintN(65, 0n));
assertEquals(0n, BigInt.asUintN(127, 0n));
assertEquals(0n, BigInt.asUintN(128, 0n));
assertEquals(0n, BigInt.asUintN(129, 0n));
}{
assertEquals(0n, BigInt.asUintN(0, 42n));
assertEquals(0n, BigInt.asUintN(1, 42n));
assertEquals(42n, BigInt.asUintN(16, 42n));
assertEquals(42n, BigInt.asUintN(31, 42n));
assertEquals(42n, BigInt.asUintN(32, 42n));
assertEquals(42n, BigInt.asUintN(33, 42n));
assertEquals(42n, BigInt.asUintN(63, 42n));
assertEquals(42n, BigInt.asUintN(64, 42n));
assertEquals(42n, BigInt.asUintN(65, 42n));
assertEquals(42n, BigInt.asUintN(127, 42n));
assertEquals(42n, BigInt.asUintN(128, 42n));
assertEquals(42n, BigInt.asUintN(129, 42n));
}{
assertEquals(0n, BigInt.asUintN(0, -42n));
assertEquals(0n, BigInt.asUintN(1, -42n));
assertEquals(65536n - 42n, BigInt.asUintN(16, -42n));
assertEquals(2147483648n - 42n, BigInt.asUintN(31, -42n));
assertEquals(4294967296n - 42n, BigInt.asUintN(32, -42n));
assertEquals(8589934592n - 42n, BigInt.asUintN(33, -42n));
assertEquals(9223372036854775808n - 42n, BigInt.asUintN(63, -42n));
assertEquals(18446744073709551616n - 42n, BigInt.asUintN(64, -42n));
assertEquals(36893488147419103232n - 42n, BigInt.asUintN(65, -42n));
assertEquals(2n**127n - 42n, BigInt.asUintN(127, -42n));
assertEquals(2n**128n - 42n, BigInt.asUintN(128, -42n));
assertEquals(2n**129n - 42n, BigInt.asUintN(129, -42n));
}{
assertEquals(0n, BigInt.asUintN(0, 4294967295n));
assertEquals(1n, BigInt.asUintN(1, 4294967295n));
assertEquals(65535n, BigInt.asUintN(16, 4294967295n));
assertEquals(2147483647n, BigInt.asUintN(31, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(32, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(33, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(63, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(64, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(65, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(127, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(128, 4294967295n));
assertEquals(4294967295n, BigInt.asUintN(129, 4294967295n));
}{
assertEquals(0n, BigInt.asUintN(0, -4294967295n));
assertEquals(1n, BigInt.asUintN(1, -4294967295n));
assertEquals(1n, BigInt.asUintN(16, -4294967295n));
assertEquals(1n, BigInt.asUintN(31, -4294967295n));
assertEquals(1n, BigInt.asUintN(32, -4294967295n));
assertEquals(8589934592n - 4294967295n, BigInt.asUintN(33, -4294967295n));
assertEquals(9223372036854775808n - 4294967295n,
BigInt.asUintN(63, -4294967295n));
assertEquals(18446744073709551616n - 4294967295n,
BigInt.asUintN(64,-4294967295n));
assertEquals(36893488147419103232n - 4294967295n,
BigInt.asUintN(65, -4294967295n));
assertEquals(2n**127n - 4294967295n, BigInt.asUintN(127, -4294967295n));
assertEquals(2n**128n - 4294967295n, BigInt.asUintN(128, -4294967295n));
assertEquals(2n**129n - 4294967295n, BigInt.asUintN(129, -4294967295n));
}{
assertEquals(42n, BigInt.asUintN(2**32, 42n));
assertEquals(4294967295n, BigInt.asUintN(2**32, 4294967295n));
assertEquals(4294967296n, BigInt.asUintN(2**32, 4294967296n));
assertEquals(4294967297n, BigInt.asUintN(2**32, 4294967297n));
}{
assertEquals(0x7234567812345678n, BigInt.asUintN(63, 0xf234567812345678n));
}{
assertThrows(() => BigInt.asUintN(2n, 12n), TypeError);
assertThrows(() => BigInt.asUintN(-1, 0n), RangeError);
assertThrows(() => BigInt.asUintN(2**53, 0n), RangeError);
assertEquals(0n, BigInt.asUintN({}, 12n));
assertEquals(0n, BigInt.asUintN(2.9999, 12n));
assertEquals(4n, BigInt.asUintN(3.1234, 12n));
}{
assertThrows(() => BigInt.asUintN(3, 12), TypeError);
assertEquals(4n, BigInt.asUintN(3, "12"));
}{
// crbug.com/936506
assertEquals(1n, BigInt.asUintN(15, 0x100000001n));
assertEquals(1n, BigInt.asUintN(15, 0x10000000000000001n));
}

595
deps/v8/test/mjsunit/harmony/bigint/basics.js vendored Normal file
View File

@ -0,0 +1,595 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
'use strict'
const minus_one = BigInt(-1);
const zero = BigInt(0);
const another_zero = BigInt(0);
const one = BigInt(1);
const another_one = BigInt(1);
const two = BigInt(2);
const three = BigInt(3);
const six = BigInt(6);
// BigInt
{
assertSame(BigInt, BigInt.prototype.constructor)
}{
assertThrows(() => new BigInt, TypeError);
assertThrows(() => new BigInt(), TypeError);
assertThrows(() => new BigInt(0), TypeError);
assertThrows(() => new BigInt(0n), TypeError);
assertThrows(() => new BigInt("0"), TypeError);
}{
class C extends BigInt { constructor() { throw 42 } };
assertThrowsEquals(() => new C, 42);
}
// ToBigInt, NumberToBigInt, BigInt
{
assertThrows(() => BigInt(undefined), TypeError);
assertThrows(() => BigInt(null), TypeError);
assertThrows(() => BigInt({}), SyntaxError);
assertThrows(() => BigInt("foo"), SyntaxError);
assertThrows(() => BigInt("1j"), SyntaxError);
assertThrows(() => BigInt("0b1ju"), SyntaxError);
assertThrows(() => BigInt("0o1jun"), SyntaxError);
assertThrows(() => BigInt("0x1junk"), SyntaxError);
}{
assertSame(BigInt(true), 1n);
assertSame(BigInt(false), 0n);
assertSame(BigInt(""), 0n);
assertSame(BigInt(" 42"), 42n);
assertSame(BigInt("0b101010"), 42n);
assertSame(BigInt(" 0b101011"), 43n);
assertSame(BigInt("0x2a "), 42n);
assertSame(BigInt(" 0x2b"), 43n);
assertSame(BigInt("0o52"), 42n);
assertSame(BigInt(" 0o53\n"), 43n);
assertSame(BigInt(-0), 0n);
assertSame(BigInt(42), 42n);
assertSame(BigInt(42n), 42n);
assertSame(BigInt(Object(42n)), 42n);
assertSame(BigInt(2**53 - 1), 9007199254740991n);
assertSame(BigInt(2**53), 9007199254740992n);
assertSame(BigInt(2**1000), 2n ** 1000n);
assertSame(BigInt(3.0755851989071915e29), 307558519890719151276406341632n);
assertSame(BigInt(-1e50), -0x446c3b15f992680000000000000000000000000000n);
assertSame(BigInt(Object(2**53 - 1)), 9007199254740991n);
assertSame(BigInt([]), 0n);
}{
assertThrows(() => BigInt(NaN), RangeError);
assertThrows(() => BigInt(-Infinity), RangeError);
assertThrows(() => BigInt(+Infinity), RangeError);
assertThrows(() => BigInt(4.00000001), RangeError);
assertThrows(() => BigInt(Object(4.00000001)), RangeError);
}
// BigInt.prototype[Symbol.toStringTag]
{
const toStringTag = Object.getOwnPropertyDescriptor(
BigInt.prototype, Symbol.toStringTag);
assertTrue(toStringTag.configurable);
assertFalse(toStringTag.enumerable);
assertFalse(toStringTag.writable);
assertEquals("BigInt", toStringTag.value);
}
// Object.prototype.toString
{
const toString = Object.prototype.toString;
assertEquals("[object BigInt]", toString.call(42n));
assertEquals("[object BigInt]", toString.call(Object(42n)));
delete BigInt.prototype[Symbol.toStringTag];
assertEquals("[object Object]", toString.call(42n));
assertEquals("[object Object]", toString.call(Object(42n)));
BigInt.prototype[Symbol.toStringTag] = "foo";
assertEquals("[object foo]", toString.call(42n));
assertEquals("[object foo]", toString.call(Object(42n)));
}
// typeof
{
assertEquals(typeof zero, "bigint");
assertEquals(typeof one, "bigint");
}{
assertEquals(%Typeof(zero), "bigint");
assertEquals(%Typeof(one), "bigint");
}{
assertTrue(typeof 1n === "bigint");
assertFalse(typeof 1n === "BigInt");
assertFalse(typeof 1 === "bigint");
}
// ToString
{
assertEquals(String(zero), "0");
assertEquals(String(one), "1");
}
// .toString(radix)
{
// Single-digit BigInts: random-generated inputs close to kMaxInt.
// Expectations computed with the following Python program:
// def Format(x, base):
// s = ""
// while x > 0:
// s = "0123456789abcdefghijklmnopqrstuvwxyz"[x % base] + s
// x = x / base
// return s
assertEquals("10100110000100101000011100101", BigInt(0x14c250e5).toString(2));
assertEquals("-110110100010011111001011111", BigInt(-0x6d13e5f).toString(2));
assertEquals("1001222020000100000", BigInt(0x18c72873).toString(3));
assertEquals("-1212101122110102020", BigInt(-0x2b19aebe).toString(3));
assertEquals("120303133110120", BigInt(0x18cdf518).toString(4));
assertEquals("-113203101020122", BigInt(-0x178d121a).toString(4));
assertEquals("1323302233400", BigInt(0x18de6256).toString(5));
assertEquals("-2301033210212", BigInt(-0x25f7f454).toString(5));
assertEquals("131050115130", BigInt(0x211f0d5e).toString(6));
assertEquals("-104353333321", BigInt(-0x186bbe91).toString(6));
assertEquals("25466260221", BigInt(0x2f69f47e).toString(7));
assertEquals("-31051540346", BigInt(-0x352c7efa).toString(7));
assertEquals("5004630525", BigInt(0x28133155).toString(8));
assertEquals("-7633240703", BigInt(-0x3e6d41c3).toString(8));
assertEquals("705082365", BigInt(0x121f4264).toString(9));
assertEquals("-780654431", BigInt(-0x1443b36e).toString(9));
assertEquals("297019028", BigInt(0x11b42694).toString(10));
assertEquals("-721151126", BigInt(-0x2afbe496).toString(10));
assertEquals("312914074", BigInt(0x27ca6879).toString(11));
assertEquals("-198025592", BigInt(-0x1813d3a7).toString(11));
assertEquals("191370997", BigInt(0x2d14f083).toString(12));
assertEquals("-1b8aab4a2", BigInt(-0x32b52efa).toString(12));
assertEquals("7818062c", BigInt(0x1c84a48c).toString(13));
assertEquals("-7529695b", BigInt(-0x1badffee).toString(13));
assertEquals("6bc929c4", BigInt(0x2b0a91d0).toString(14));
assertEquals("-63042008", BigInt(-0x270dff78).toString(14));
assertEquals("5e8b8dec", BigInt(0x3cd27d7f).toString(15));
assertEquals("-4005433d", BigInt(-0x28c0821a).toString(15));
assertEquals("10b35ca3", BigInt(0x10b35ca3).toString(16));
assertEquals("-23d4d9d6", BigInt(-0x23d4d9d6).toString(16));
assertEquals("28c3d5e3", BigInt(0x3d75d48c).toString(17));
assertEquals("-10c06328", BigInt(-0x1979b7f0).toString(17));
assertEquals("eb8d349", BigInt(0x1dacf0a5).toString(18));
assertEquals("-1217015h", BigInt(-0x28b3c23f).toString(18));
assertEquals("1018520b", BigInt(0x357da01a).toString(19));
assertEquals("-9c64e33", BigInt(-0x1b0e9571).toString(19));
assertEquals("d7bf9ab", BigInt(0x3309daa3).toString(20));
assertEquals("-58h0h9h", BigInt(-0x14c30c55).toString(20));
assertEquals("64igi9h", BigInt(0x1fdd329c).toString(21));
assertEquals("-45cbc4a", BigInt(-0x15cf9682).toString(21));
assertEquals("7bi7d1h", BigInt(0x32f0dfe3).toString(22));
assertEquals("-61j743l", BigInt(-0x291ff61f).toString(22));
assertEquals("5g5gg25", BigInt(0x325a10bd).toString(23));
assertEquals("-3359flb", BigInt(-0x1bb653c9).toString(23));
assertEquals("392f5ec", BigInt(0x267ed69c).toString(24));
assertEquals("-2ab3icb", BigInt(-0x1bbf7bab).toString(24));
assertEquals("3jb2afo", BigInt(0x36f93c24).toString(25));
assertEquals("-30bcheh", BigInt(-0x2bec76fa).toString(25));
assertEquals("3845agk", BigInt(0x3d04bf64).toString(26));
assertEquals("-1gpjl3g", BigInt(-0x1e720b1a).toString(26));
assertEquals("20bpaf0", BigInt(0x2e8ff627).toString(27));
assertEquals("-292i3c2", BigInt(-0x35f751fe).toString(27));
assertEquals("266113k", BigInt(0x3fd26738).toString(28));
assertEquals("-1eh16bo", BigInt(-0x2bb5726c).toString(28));
assertEquals("19gj7qa", BigInt(0x2f28e8d8).toString(29));
assertEquals("-13a0apf", BigInt(-0x278b4588).toString(29));
assertEquals("iasrb8", BigInt(0x1a99b3be).toString(30));
assertEquals("-frlhoc", BigInt(-0x17106f48).toString(30));
assertEquals("bfe4p2", BigInt(0x139f1ea3).toString(31));
assertEquals("-ioal1a", BigInt(-0x200e49fa).toString(31));
assertEquals("m0v0kf", BigInt(0x2c0f828f).toString(32));
assertEquals("-g4bab5", BigInt(-0x2045a965).toString(32));
assertEquals("9i1kit", BigInt(0x16450a9f).toString(33));
assertEquals("-fqb0e7", BigInt(-0x24d9e889).toString(33));
assertEquals("gb9r6m", BigInt(0x2c3acf46).toString(34));
assertEquals("-jcaemv", BigInt(-0x346f72b3).toString(34));
assertEquals("cw4mbk", BigInt(0x2870cdcb).toString(35));
assertEquals("-hw4eki", BigInt(-0x3817c29b).toString(35));
assertEquals("alzwgj", BigInt(0x263e2c13).toString(36));
assertEquals("-bo4ukz", BigInt(-0x2a0f97d3).toString(36));
// Multi-digit BigInts.
// Test parseInt/toString round trip on a list of randomly generated
// string representations of numbers in various bases.
// Userland polyfill while we wait for BigInt.fromString (see:
// https://mathiasbynens.github.io/proposal-number-fromstring/ ).
// This intentionally only implements what the tests below need.
function ParseBigInt(str, radix) {
const alphabet = "0123456789abcdefghijklmnopqrstuvwxyz";
var result = 0n;
var base = BigInt(radix);
var index = 0;
var negative = false;
if (str[0] === "-") {
negative = true;
index++;
}
for (; index < str.length; index++) {
var digit = alphabet.indexOf(str[index]);
assertTrue(digit >= 0 && digit < radix);
result = result * base + BigInt(digit);
}
if (negative) result = -result;
return result;
}
var positive = [0, 0, // Skip base 0 and 1.
"1100110001100010110011110110010010001011100111100101111000111101100001000",
"1001200022210010220101120212021002011002201122200002211102120120021011020",
"1111113020012203332320220022231110130001001320122012131311333110012023232",
"4214313040222110434114402342013144321401424143322013320403411012033300312",
"5025302003542512450341430541203424555035430434034243510233043041501130015",
"6231052230016515343200525230300322104013130605414211331345043144525012021",
"1146340505617030644211355340006353546230356336306352536433054143503442135",
"7262360724624787621528668212168232276348417717770383567066203032200270570",
"7573792356581293501680046955899735043496925151216904903504319328753434194",
"4a627927557579898720a42647639128174a8689889766a219342133671449069a2235011",
"1a574a5848289924996342a32893380690322330393633b587ba5a15b7b82080222400464",
"5163304c74c387b7a443c92466688595b671a3329b42083b1499b0c10a74a9298a06c3a5a",
"4b63c834356a03c80946133284a709cbbc2a75022757207dc31c14abd4c160dc122327c17",
"d8d59cbb4ca2860de7c002eee4ab3c215b90069200d20dbdc0111cb1e1bab97e8c7609670",
"22d4b69398a7f848e6ae36798811cd1a63d90f340d8607f3ce5566c97c18468787eb2b9fd",
"1176gf69afd32cc105fa70c705927a384dbdb1g8d952f28028g31ebdc9e32a89f16e825ee",
"5d64b74f4d70632h4ee07h7c1e2da9125c42g2727f4b6d95e5cec6ga49566hh731ab5f544",
"7ff8cg7f05dd72916a09a4761ii7b0ibcg68ba39b10436f14efg76ge817317badcbi4gffc",
"6d7c4hci6cd72e4ja26j354i12i71gb0cbj12gi145j91h02hde3b72c65geb7ff9bi9d0c2b",
"c96997f50abe425d13a53kk4af631kg7db208ka5j5bfg8ca5f9c0bjf69j5kgg4jb5h7hi86",
"3g5fd800d9ib9j0i8all5jgb23dh9483ab6le5ad9g4kja8a0b3j5jbjfge7k5fffg2kbheee",
"9j1119d1cd61kmdm7kma105cki313f678fc3h25f4664281bbmg3fk97kfbh7d48j89j178ch",
"d2933cdc9jfe4hl3794kb3e13dg2lihad968ib9jg19dgf1fi482b27ji0d10c6kfkdge5764",
"bf6o0njkm1ij5in5nh7h94584bd80el02b07el5ojk9k9g0gn906do70gbbnckl048c0kdmao",
"8gb7jnge9p9cdgigo394oa33gfaenc3gnb53eceg4b8511gkkm88b0dod85e5bggpc861d7d5",
"qbbnqhkpleb4o8ndaddpc34h5b2iljn3jgnjdn5k57bi3n9i09hjle9hqgqdpgbnk499mak56",
"akg7e2976arn8i2m53gif0dp59bmfd7mk9erlg2qm3fc76da9glf397eh4ooij9il0nfl9gac",
"mehpbfrj5ah2ef3p2hl637gjp1pm5grqn4037pm1qfgfpr9cfljfc145hljehjjb48bb1n6en",
"rg6ik3agnb3p6t2rtja9h4il76i8fkqlt6gplap3fq6pfr7bbcfcp5ffncf3nm4kamap39hse",
"bk8rp9r9r8pltdqpb7euc6s9rcm33969pcq6uk3mtfoktt86di8589oacbam5tn29b9b6dq3j",
"npth8juld44rss3e57iigjg65po3d1h02heo4r103jmg3ocv89buqtgiov35k39rdf8j9t4ca",
"vrmqlwrrrd0uml1womae49jpa9tadh44fw7mucgk06l0uk4uqwuo37t6kwn7wwrm3a6oq081s",
"n5cft6gvufqd8iksquu2amghokk17gbtpguidc290af634p7k7rhmfu7bf1s62ej4megoa1j4",
"3v3gcrmlfc2tl0tefgkiogj41f6y2tmj9w5bxke8y03xqf49ox8gh9wbrhycrkluicqajtnur",
"z2m7b0sy2tzergtkqts5yj0dkrlfkxls81ijgxgfequizpntcwggv2d4rdzcncd0kj9mrmnrb",
];
var negative = [0, 0, // Skip base 0 and 1.
"-100010011110111010111111110001100100111010101000001011010010101100101000",
"-110012122000122102021210112200001000122011010120101201001122000002022102",
"-203210320111001002200122200001312300221100221321010300023323201113122333",
"-133042441230110320040323303341320302144241224443231311022240124413104131",
"-311325230504055004330150145105331121322231155401110315251422505233103112",
"-643153641664240231336166403516403454646560261062114326443664602606315326",
"-200057252627665476551635525303641543165622340301637556323453513664337277",
"-826688166214270516331644053744613530235020517172322840763172114078364165",
"-743042397390679269240157150971957535458122650450558451124173993544604852",
"-73528688500003573942a56a504a2996a1384129563098512a63196697975038692aaa63",
"-616576a2948a9029316290168b71137b027851639a0283150b125b664b74b767a3597805",
"-b875467540719b371b7a36047a7886872a5399c4c630c37149bc3182917a7a7c124475bb",
"-3860411b61d35977721bc81bd715c386c9b70a752940913d265505d8c7c5dd2624b591d7",
"-bad5dd79b083ee0da9a6296664e72c246d827762357116ae7076a22bb369acbc3a201d03",
"-f9b37352aff265124303942a463917a252ff1a2ff4a33777f490b4c103bdcd1a655dbe2c",
"-805fg8c74125214g383a8d8g573c49fa7c4035fbc6db61g5gb5g6beb8f90dae4a9a5g7cc",
"-70aae113459d3h5084b1gg209g3695d20e78d01gcbb71bh1bd4gdge31haf5hc02dghf14e",
"-c55a57haf47b7ih2gh6ea93098ig02b42icga6ead254e0aeeic7g53h5fd6637ge03b2e20",
"-e32f7204624ie596j731g72136cejc25ebbgb0140i4997fcdf477f021d86ci4e10db543a",
"-i7f32c817i3cac1c24c7786k6ig185f47cj1471ki6bb7agiae838027gjge9g59if9f88g6",
"-i30aha2030a9605c270h92e1ca3i02j996hl918gh52fbhb7i16ik1i919ieak3cj384kb61",
"-58jmem8e59li67aellid2083dabh4kh51ci1jg7c6a3k4l1hdgfkdha0fglfm4805kida5b9",
"-cl9iecjg9ak087cad4151lll44296heae2349g70fbjj37998m2ddn6427fgcl2aknhgn1a1",
"-alfjfhho4gf8bi4j2bi3743mhg2aache4c6jcinkmf5ddm7kf9gg350hlja16ealbdlk201j",
"-bhh1146ho3o2m3b839c565hbgjnhjh96oofbmdl7gn8h4f94kli94hkk180o79pc4d2l0721",
"-p00gknh7e05k6a3apg6i9lb46f4a9qeeiq1778ak8il5dcponk5gl2fiednb4pmo1agmoqph",
"-4j8lo4d4p508fnd2hkfb76e8ri81k6hq0op3pr14ca0cn96pccplk7rbahc9cdkdce1q16dn",
"-ednlo3ogf2i8annrel9rm323bpf00meed3oi47n0qrdgnd2n3il4bnsc9s2jd7loh44im8ra",
"-bjjg6fsbpcc2tc1o09m9r6fd6eoq5480har62a5offn9thcfahbno9kf9magl2akl0jgncj9",
"-sonuhat2h60glpbpej9jjado2s5l86122d26tudoc1d6aic2oitu793gk0mlac3dk1dufp1q",
"-i9pbvm53ubh8jqifuarauch8cbgk9cjsl6rlioka1phs1lskg1oosll23hjoli2subgr1rto",
"-w1ncn5t60b5dv669ekwnvk8n2g7djrsl8cdkwun8o3m5divc3jhnkp2381rhj70gc71a6wff",
"-buiq8v33p5ex44ps4s45enj6lrluivm19lcowkvntu72u0xguw13bxgxxe7mdlwt1a4qksae",
"-woiycfmea6i12r2yai49mf4lbd7w2jdoebiogfhnh1i4rwgox57obci8qbsfpb4w07nu19m5",
"-tbttuip1r6ioca6g6dw354o4m78qep9yh03nojx47yq29fqime6zstwllb74501qct8eskxn",
];
for (var base = 2; base <= 36; base++) {
var input = positive[base];
assertEquals(input, ParseBigInt(input, base).toString(base));
input = negative[base];
assertEquals(input, ParseBigInt(input, base).toString(base));
}
}
// .valueOf
{
assertEquals(Object(zero).valueOf(), another_zero);
assertThrows(() => { return BigInt.prototype.valueOf.call("string"); },
TypeError);
assertEquals(-42n, Object(-42n).valueOf());
}
// ToBoolean
{
assertTrue(!zero);
assertFalse(!!zero);
assertTrue(!!!zero);
assertFalse(!one);
assertTrue(!!one);
assertFalse(!!!one);
// This is a hack to test Object::BooleanValue.
assertTrue(%CreateIterResultObject(42, one).done);
assertFalse(%CreateIterResultObject(42, zero).done);
}
// ToNumber
{
assertThrows(() => isNaN(zero), TypeError);
assertThrows(() => isNaN(one), TypeError);
assertThrows(() => +zero, TypeError);
assertThrows(() => +one, TypeError);
}
{
let Zero = {valueOf() { return zero }};
let One = {valueOf() { return one }};
assertThrows(() => isNaN(Zero), TypeError);
assertThrows(() => isNaN(One), TypeError);
assertThrows(() => +Zero, TypeError);
assertThrows(() => +One, TypeError);
}{
let Zero = {valueOf() { return Object(NaN) }, toString() { return zero }};
let One = {valueOf() { return one }, toString() { return NaN }};
assertThrows(() => isNaN(Zero), TypeError);
assertThrows(() => isNaN(One), TypeError);
assertThrows(() => +Zero, TypeError);
assertThrows(() => +One, TypeError);
}
// ToObject
{
const ToObject = x => (new Function("", "return this")).call(x);
function test(x) {
const X = ToObject(x);
assertEquals(typeof x, "bigint");
assertEquals(typeof X, 'object');
assertEquals(X.constructor, BigInt);
assertTrue(X == x);
}
test(0n);
test(-1n);
test(1n);
test(2343423423423423423424234234234235234524353453452345324523452345234534n);
}{
function test(x) {
const X = Object(x);
assertEquals(typeof x, "bigint");
assertEquals(typeof X, 'object');
assertEquals(X.constructor, BigInt);
assertTrue(X == x);
}
test(0n);
test(-1n);
test(1n);
test(2343423423423423423424234234234235234524353453452345324523452345234534n);
}
// Literals
{
// Invalid literals.
assertThrows("00n", SyntaxError);
assertThrows("01n", SyntaxError);
assertThrows("0bn", SyntaxError);
assertThrows("0on", SyntaxError);
assertThrows("0xn", SyntaxError);
assertThrows("1.n", SyntaxError);
assertThrows("1.0n", SyntaxError);
assertThrows("1e25n", SyntaxError);
// Various radixes.
assertTrue(12345n === BigInt(12345));
assertTrue(0xabcden === BigInt(0xabcde));
assertTrue(0xAbCdEn === BigInt(0xabcde));
assertTrue(0o54321n === BigInt(0o54321));
assertTrue(0b1010101n === BigInt(0b1010101));
}
// Binary ops.
{
let One = {valueOf() { return one }};
assertTrue(one + two === three);
assertTrue(One + two === three);
assertTrue(two + One === three);
assertEquals("hello1", "hello" + one);
assertEquals("2hello", two + "hello");
assertThrows("one + 2", TypeError);
assertThrows("2 + one", TypeError);
assertThrows("one + 0.5", TypeError);
assertThrows("0.5 + one", TypeError);
assertThrows("one + null", TypeError);
assertThrows("null + one", TypeError);
assertTrue(three - two === one);
assertThrows("two - 1", TypeError);
assertThrows("2 - one", TypeError);
assertThrows("two - 0.5", TypeError);
assertThrows("2.5 - one", TypeError);
assertTrue(two * three === six);
assertTrue(two * One === two);
assertTrue(One * two === two);
assertThrows("two * 1", TypeError);
assertThrows("1 * two", TypeError);
assertThrows("two * 1.5", TypeError);
assertThrows("1.5 * two", TypeError);
assertTrue(six / three === two);
assertThrows("six / 3", TypeError);
assertThrows("3 / three", TypeError);
assertThrows("six / 0.5", TypeError);
assertThrows("0.5 / six", TypeError);
assertThrows("zero / zero", RangeError);
assertThrows("zero / 0", TypeError);
assertTrue(three % two === one);
assertThrows("three % 2", TypeError);
assertThrows("3 % two", TypeError);
assertThrows("three % 2.5", TypeError);
assertThrows("3.5 % two", TypeError);
assertThrows("three % zero", RangeError);
assertThrows("three % 0", TypeError);
}
// Bitwise binary ops.
{
let One = {valueOf() { return one }};
assertTrue((three & one) === one);
assertTrue((BigInt(-2) & zero) === zero);
assertTrue((three & One) === one);
assertTrue((One & three) === one);
assertThrows("three & 1", TypeError);
assertThrows("1 & three", TypeError);
assertThrows("three & true", TypeError);
assertThrows("true & three", TypeError);
assertThrows("three & {valueOf: function() { return 1; }}", TypeError);
assertThrows("({valueOf: function() { return 1; }}) & three", TypeError);
assertTrue((two | one) === three);
assertThrows("two | 0", TypeError);
assertThrows("0 | two", TypeError);
assertThrows("two | undefined", TypeError);
assertThrows("undefined | two", TypeError);
assertTrue((three ^ one) === two);
assertThrows("three ^ 1", TypeError);
assertThrows("1 ^ three", TypeError);
assertThrows("three ^ 2.5", TypeError);
assertThrows("2.5 ^ three", TypeError);
}
// Shift ops.
{
assertTrue(one << one === two);
assertThrows("one << 1", TypeError);
assertThrows("1 << one", TypeError);
assertThrows("one << true", TypeError);
assertThrows("true << one", TypeError);
assertTrue(three >> one === one);
assertThrows("three >> 1", TypeError);
assertThrows("0xbeef >> one", TypeError);
assertThrows("three >> 1.5", TypeError);
assertThrows("23.45 >> three", TypeError);
assertThrows("three >>> one", TypeError);
assertThrows("three >>> 1", TypeError);
assertThrows("0xbeef >>> one", TypeError);
assertThrows("three >>> {valueOf: function() { return 1; }}", TypeError);
assertThrows("({valueOf: function() { return 1; }}) >>> one", TypeError);
}
// Unary ops.
{
let One = {valueOf() { return one }};
assertTrue(~minus_one === zero);
assertTrue(-minus_one === one);
assertTrue(-One === minus_one);
assertTrue(~~two === two);
assertTrue(-(-two) === two);
assertTrue(~One === BigInt(-2));
let a = minus_one;
assertTrue(a++ === minus_one);
assertTrue(a === zero);
assertTrue(a++ === zero);
assertTrue(a === one);
assertTrue(++a === two);
assertTrue(a === two);
assertTrue(--a === one);
assertTrue(a === one);
assertTrue(a-- === one);
assertTrue(a === zero);
assertTrue(a-- === zero);
assertTrue(a === minus_one);
a = {valueOf() { return minus_one }};
assertTrue(a++ === minus_one);
assertTrue(a++ === zero);
assertTrue(a === one);
a = {valueOf() { return one }};
assertTrue(a-- === one);
assertTrue(a-- === zero);
assertTrue(a === minus_one);
}
// ToPropertyKey
{
let obj = {};
assertEquals(obj[0n], undefined);
assertEquals(obj[0n] = 42, 42);
assertEquals(obj[0n], 42);
assertEquals(obj[0], 42);
obj[0]++;
assertEquals(obj[1n - 1n], 43);
assertEquals(Reflect.get(obj, -0n), 43);
assertEquals(obj[{toString() {return 0n}}], 43);
assertEquals(Reflect.ownKeys(obj), ["0"]);
}{
let obj = {};
const unsafe = 9007199254740993n;
assertEquals(obj[unsafe] = 23, 23);
assertEquals(obj[unsafe], 23);
assertEquals(Reflect.ownKeys(obj), ["9007199254740993"]);
assertEquals(obj[9007199254740993], undefined);
delete obj[unsafe];
assertEquals(Reflect.ownKeys(obj), []);
}{
let arr = [];
assertFalse(4n in arr);
arr[4n] = 42;
assertTrue(4n in arr);
let enumkeys = 0;
for (const key in arr) {
enumkeys++;
assertSame(key, "4");
}
assertEquals(enumkeys, 1);
}{
let str = "blubb";
assertEquals(str[2n], "u");
assertThrows(() => str.slice(2n), TypeError);
}{
let obj = {};
let key = 0;
function set_key(x) { obj[key] = x }
set_key("aaa");
set_key("bbb");
key = 0n;
set_key("ccc");
assertEquals(obj[key], "ccc");
function get_key() { return obj[key] }
assertEquals(get_key(), "ccc");
assertEquals(get_key(), "ccc");
key = 0;
assertEquals(get_key(), "ccc");
}{
assertSame(%ToName(0n), "0");
assertSame(%ToName(-0n), "0");
const unsafe = 9007199254740993n;
assertSame(%ToName(unsafe), "9007199254740993");
}

501
deps/v8/test/mjsunit/harmony/bigint/comparisons.js vendored Normal file
View File

@ -0,0 +1,501 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
'use strict'
const minus_one = BigInt(-1);
const zero = BigInt(0);
const another_zero = BigInt(0);
const one = BigInt(1);
const another_one = BigInt(1);
const two = BigInt(2);
const three = BigInt(3);
const six = BigInt(6);
// Strict equality
{
assertTrue(zero === zero);
assertFalse(zero !== zero);
assertTrue(zero === another_zero);
assertFalse(zero !== another_zero);
assertFalse(zero === one);
assertTrue(zero !== one);
assertTrue(one !== zero);
assertFalse(one === zero);
assertFalse(zero === 0);
assertTrue(zero !== 0);
assertFalse(0 === zero);
assertTrue(0 !== zero);
}{
assertTrue(%StrictEqual(zero, zero));
assertFalse(%StrictNotEqual(zero, zero));
assertTrue(%StrictEqual(zero, another_zero));
assertFalse(%StrictNotEqual(zero, another_zero));
assertFalse(%StrictEqual(zero, one));
assertTrue(%StrictNotEqual(zero, one));
assertTrue(%StrictNotEqual(one, zero));
assertFalse(%StrictEqual(one, zero));
assertFalse(%StrictEqual(zero, 0));
assertTrue(%StrictNotEqual(zero, 0));
assertFalse(%StrictEqual(0, zero));
assertTrue(%StrictNotEqual(0, zero));
}
// Abstract equality
{
assertTrue(%Equal(zero, zero));
assertTrue(%Equal(zero, another_zero));
assertFalse(%Equal(zero, one));
assertFalse(%Equal(one, zero));
assertTrue(%Equal(zero, +0));
assertTrue(%Equal(zero, -0));
assertTrue(%Equal(+0, zero));
assertTrue(%Equal(-0, zero));
assertTrue(%Equal(zero, false));
assertTrue(%Equal(one, true));
assertFalse(%Equal(zero, true));
assertFalse(%Equal(one, false));
assertTrue(%Equal(false, zero));
assertTrue(%Equal(true, one));
assertFalse(%Equal(true, zero));
assertFalse(%Equal(false, one));
assertTrue(%Equal(one, 1));
assertTrue(%Equal(one, Number(1)));
assertTrue(%Equal(1, one));
assertTrue(%Equal(Number(1), one));
assertTrue(%Equal(minus_one, -1));
assertTrue(%Equal(minus_one, Number(-1)));
assertTrue(%Equal(-1, minus_one));
assertTrue(%Equal(Number(-1), minus_one));
assertFalse(%Equal(one, -1));
assertFalse(%Equal(one, Number(-1)));
assertFalse(%Equal(-1, one));
assertFalse(%Equal(Number(-1), one));
assertFalse(%Equal(one, 1.0000000000001));
assertFalse(%Equal(1.0000000000001, one));
assertTrue(%Equal(zero, ""));
assertTrue(%Equal("", zero));
assertTrue(%Equal(one, "1"));
assertTrue(%Equal("1", one));
assertFalse(%Equal(one, "a"));
assertFalse(%Equal("a", one));
assertTrue(%Equal(one, {valueOf() { return true }}));
assertTrue(%Equal({valueOf() { return true }}, one));
assertFalse(%Equal(two, {valueOf() { return true }}));
assertFalse(%Equal({valueOf() { return true }}, two));
assertFalse(%Equal(Symbol(), zero));
assertFalse(%Equal(zero, Symbol()));
}{
assertTrue(zero == zero);
assertTrue(zero == another_zero);
assertFalse(zero == one);
assertFalse(one == zero);
assertTrue(zero == +0);
assertTrue(zero == -0);
assertTrue(+0 == zero);
assertTrue(-0 == zero);
assertTrue(zero == false);
assertTrue(one == true);
assertFalse(zero == true);
assertFalse(one == false);
assertTrue(false == zero);
assertTrue(true == one);
assertFalse(true == zero);
assertFalse(false == one);
assertTrue(one == 1);
assertTrue(one == Number(1));
assertTrue(1 == one);
assertTrue(Number(1) == one);
assertTrue(minus_one == -1);
assertTrue(minus_one == Number(-1));
assertTrue(-1 == minus_one);
assertTrue(Number(-1) == minus_one);
assertFalse(one == -1);
assertFalse(one == Number(-1));
assertFalse(-1 == one);
assertFalse(Number(-1) == one);
assertFalse(one == 1.0000000000001);
assertFalse(1.0000000000001 == one);
assertTrue(zero == "");
assertTrue("" == zero);
assertTrue(zero == " \t\r\n");
assertTrue(one == "1");
assertTrue("1" == one);
assertFalse(" \t\r\n" == one);
assertFalse(one == "a");
assertFalse("a" == one);
assertTrue(zero == "00000000000000" + "0");
assertTrue(one == {valueOf() { return true }});
assertTrue({valueOf() { return true }} == one);
assertFalse(two == {valueOf() { return true }});
assertFalse({valueOf() { return true }} == two);
assertFalse(Symbol() == zero);
assertFalse(zero == Symbol());
assertTrue(one == "0b1");
assertTrue(" 0b1" == one);
assertTrue(one == "0o1");
assertTrue("0o1 " == one);
assertTrue(one == "\n0x1");
assertTrue("0x1" == one);
assertFalse(one == "1j");
assertFalse(one == "0b1ju");
assertFalse(one == "0o1jun");
assertFalse(one == "0x1junk");
}{
assertFalse(%NotEqual(zero, zero));
assertFalse(%NotEqual(zero, another_zero));
assertTrue(%NotEqual(zero, one));
assertTrue(%NotEqual(one, zero));
assertFalse(%NotEqual(zero, +0));
assertFalse(%NotEqual(zero, -0));
assertFalse(%NotEqual(+0, zero));
assertFalse(%NotEqual(-0, zero));
assertFalse(%NotEqual(zero, false));
assertFalse(%NotEqual(one, true));
assertTrue(%NotEqual(zero, true));
assertTrue(%NotEqual(one, false));
assertFalse(%NotEqual(false, zero));
assertFalse(%NotEqual(true, one));
assertTrue(%NotEqual(true, zero));
assertTrue(%NotEqual(false, one));
assertFalse(%NotEqual(one, 1));
assertFalse(%NotEqual(one, Number(1)));
assertFalse(%NotEqual(1, one));
assertFalse(%NotEqual(Number(1), one));
assertFalse(%NotEqual(minus_one, -1));
assertFalse(%NotEqual(minus_one, Number(-1)));
assertFalse(%NotEqual(-1, minus_one));
assertFalse(%NotEqual(Number(-1), minus_one));
assertTrue(%NotEqual(one, -1));
assertTrue(%NotEqual(one, Number(-1)));
assertTrue(%NotEqual(-1, one));
assertTrue(%NotEqual(Number(-1), one));
assertTrue(%NotEqual(one, 1.0000000000001));
assertTrue(%NotEqual(1.0000000000001, one));
assertFalse(%NotEqual(zero, ""));
assertFalse(%NotEqual("", zero));
assertFalse(%NotEqual(one, "1"));
assertFalse(%NotEqual("1", one));
assertTrue(%NotEqual(one, "a"));
assertTrue(%NotEqual("a", one));
assertFalse(%NotEqual(one, {valueOf() { return true }}));
assertFalse(%NotEqual({valueOf() { return true }}, one));
assertTrue(%NotEqual(two, {valueOf() { return true }}));
assertTrue(%NotEqual({valueOf() { return true }}, two));
assertTrue(%NotEqual(Symbol(), zero));
assertTrue(%NotEqual(zero, Symbol()));
}{
assertFalse(zero != zero);
assertFalse(zero != another_zero);
assertTrue(zero != one);
assertTrue(one != zero);
assertFalse(zero != +0);
assertFalse(zero != -0);
assertFalse(+0 != zero);
assertFalse(-0 != zero);
assertFalse(zero != false);
assertFalse(one != true);
assertTrue(zero != true);
assertTrue(one != false);
assertFalse(false != zero);
assertFalse(true != one);
assertTrue(true != zero);
assertTrue(false != one);
assertFalse(one != 1);
assertFalse(one != Number(1));
assertFalse(1 != one);
assertFalse(Number(1) != one);
assertFalse(minus_one != -1);
assertFalse(minus_one != Number(-1));
assertFalse(-1 != minus_one);
assertFalse(Number(-1) != minus_one);
assertTrue(one != -1);
assertTrue(one != Number(-1));
assertTrue(-1 != one);
assertTrue(Number(-1) != one);
assertTrue(one != 1.0000000000001);
assertTrue(1.0000000000001 != one);
assertFalse(zero != "");
assertFalse("" != zero);
assertFalse(one != "1");
assertFalse("1" != one);
assertTrue(one != "a");
assertTrue("a" != one);
assertFalse(one != {valueOf() { return true }});
assertFalse({valueOf() { return true }} != one);
assertTrue(two != {valueOf() { return true }});
assertTrue({valueOf() { return true }} != two);
assertTrue(Symbol() != zero);
assertTrue(zero != Symbol());
}
// SameValue
{
assertTrue(Object.is(zero, zero));
assertTrue(Object.is(zero, another_zero));
assertTrue(Object.is(one, one));
assertTrue(Object.is(one, another_one));
assertFalse(Object.is(zero, +0));
assertFalse(Object.is(zero, -0));
assertFalse(Object.is(+0, zero));
assertFalse(Object.is(-0, zero));
assertFalse(Object.is(zero, one));
assertFalse(Object.is(one, minus_one));
}{
const obj = Object.defineProperty({}, 'foo',
{value: zero, writable: false, configurable: false});
assertTrue(Reflect.defineProperty(obj, 'foo', {value: zero}));
assertTrue(Reflect.defineProperty(obj, 'foo', {value: another_zero}));
assertFalse(Reflect.defineProperty(obj, 'foo', {value: one}));
}
// SameValueZero
{
assertTrue([zero].includes(zero));
assertTrue([zero].includes(another_zero));
assertFalse([zero].includes(+0));
assertFalse([zero].includes(-0));
assertFalse([+0].includes(zero));
assertFalse([-0].includes(zero));
assertTrue([one].includes(one));
assertTrue([one].includes(another_one));
assertFalse([one].includes(1));
assertFalse([1].includes(one));
}{
assertTrue(new Set([zero]).has(zero));
assertTrue(new Set([zero]).has(another_zero));
assertFalse(new Set([zero]).has(+0));
assertFalse(new Set([zero]).has(-0));
assertFalse(new Set([+0]).has(zero));
assertFalse(new Set([-0]).has(zero));
assertTrue(new Set([one]).has(one));
assertTrue(new Set([one]).has(another_one));
}{
assertTrue(new Map([[zero, 42]]).has(zero));
assertTrue(new Map([[zero, 42]]).has(another_zero));
assertFalse(new Map([[zero, 42]]).has(+0));
assertFalse(new Map([[zero, 42]]).has(-0));
assertFalse(new Map([[+0, 42]]).has(zero));
assertFalse(new Map([[-0, 42]]).has(zero));
assertTrue(new Map([[one, 42]]).has(one));
assertTrue(new Map([[one, 42]]).has(another_one));
}
// Abstract comparison
{
let undef = Symbol();
assertTrue(%Equal(zero, zero));
assertTrue(%GreaterThanOrEqual(zero, zero));
assertTrue(%LessThan(zero, one));
assertTrue(%GreaterThan(one, zero));
assertTrue(%LessThan(minus_one, one));
assertTrue(%GreaterThan(one, minus_one));
assertTrue(%Equal(zero, -0));
assertTrue(%LessThanOrEqual(zero, -0));
assertTrue(%GreaterThanOrEqual(zero, -0));
assertTrue(%Equal(-0, zero));
assertTrue(%LessThanOrEqual(-0, zero));
assertTrue(%GreaterThanOrEqual(-0, zero));
assertTrue(%Equal(zero, 0));
assertTrue(%Equal(0, zero));
assertTrue(%LessThan(minus_one, 1));
assertTrue(%GreaterThan(1, minus_one));
assertFalse(%LessThan(six, NaN));
assertFalse(%GreaterThan(six, NaN));
assertFalse(%Equal(six, NaN));
assertFalse(%LessThan(NaN, six));
assertFalse(%GreaterThan(NaN, six));
assertFalse(%Equal(NaN, six));
assertTrue(%LessThan(six, Infinity));
assertTrue(%GreaterThan(Infinity, six));
assertTrue(%GreaterThan(six, -Infinity));
assertTrue(%LessThan(-Infinity, six));
assertTrue(%GreaterThan(six, 5.99999999));
assertTrue(%LessThan(5.99999999, six));
assertTrue(%Equal(zero, ""));
assertTrue(%LessThanOrEqual(zero, ""));
assertTrue(%GreaterThanOrEqual(zero, ""));
assertTrue(%Equal("", zero));
assertTrue(%LessThanOrEqual("", zero));
assertTrue(%GreaterThanOrEqual("", zero));
assertTrue(%Equal(minus_one, "\t-1 "));
assertTrue(%LessThanOrEqual(minus_one, "\t-1 "));
assertTrue(%GreaterThanOrEqual(minus_one, "\t-1 "));
assertTrue(%Equal("\t-1 ", minus_one));
assertTrue(%LessThanOrEqual("\t-1 ", minus_one));
assertTrue(%GreaterThanOrEqual("\t-1 ", minus_one));
assertFalse(%LessThan(minus_one, "-0x1"));
assertFalse(%GreaterThan(minus_one, "-0x1"));
assertFalse(%Equal(minus_one, "-0x1"));
assertFalse(%LessThan("-0x1", minus_one));
assertFalse(%GreaterThan("-0x1", minus_one));
assertFalse(%Equal("-0x1", minus_one));
const unsafe = "9007199254740993"; // 2**53 + 1
assertFalse(%GreaterThan(eval(unsafe + "n"), unsafe));
assertFalse(%LessThan(unsafe, eval(unsafe + "n")));
assertThrows(() => %LessThan(six, Symbol(6)), TypeError);
assertThrows(() => %LessThan(Symbol(6), six), TypeError);
var value_five_string_six = {
valueOf() { return Object(5); },
toString() { return 6; }
};
assertTrue(%LessThanOrEqual(six, value_five_string_six));
assertTrue(%GreaterThanOrEqual(six, value_five_string_six));
assertTrue(%LessThanOrEqual(value_five_string_six, six));
assertTrue(%GreaterThanOrEqual(value_five_string_six, six));
}{
assertFalse(zero < zero);
assertTrue(zero <= zero);
assertTrue(zero < one);
assertTrue(zero <= one);
assertFalse(one < zero);
assertFalse(one <= zero);
assertTrue(minus_one < one);
assertTrue(minus_one <= one);
assertFalse(one < minus_one);
assertFalse(one <= minus_one);
assertFalse(zero < -0);
assertTrue(zero <= -0);
assertFalse(-0 < zero);
assertTrue(-0 <= zero);
assertFalse(zero < 0);
assertTrue(zero <= 0);
assertFalse(0 < zero);
assertTrue(0 <= zero);
assertTrue(minus_one < 1);
assertTrue(minus_one <= 1);
assertFalse(1 < minus_one);
assertFalse(1 <= minus_one);
assertFalse(six < NaN);
assertFalse(six <= NaN);
assertFalse(NaN < six);
assertFalse(NaN <= six);
assertTrue(six < Infinity);
assertTrue(six <= Infinity);
assertFalse(Infinity < six);
assertFalse(Infinity <= six);
assertFalse(six < -Infinity);
assertFalse(six <= -Infinity);
assertTrue(-Infinity < six);
assertTrue(-Infinity <= six);
assertFalse(six < 5.99999999);
assertFalse(six <= 5.99999999);
assertTrue(5.99999999 < six);
assertTrue(5.99999999 <= six);
assertFalse(zero < "");
assertTrue(zero <= "");
assertFalse("" < zero);
assertTrue("" <= zero);
assertFalse(minus_one < "\t-1 ");
assertTrue(minus_one <= "\t-1 ");
assertFalse("\t-1 " < minus_one);
assertTrue("\t-1 " <= minus_one);
assertFalse(minus_one < "-0x1");
assertFalse(minus_one <= "-0x1");
assertFalse("-0x1" < minus_one);
assertFalse("-0x1" <= minus_one);
const unsafe = "9007199254740993"; // 2**53 + 1
assertFalse(eval(unsafe + "n") < unsafe);
assertTrue(eval(unsafe + "n") <= unsafe);
assertFalse(unsafe < eval(unsafe + "n"));
assertTrue(unsafe <= eval(unsafe + "n"));
assertThrows(() => six < Symbol(6), TypeError);
assertThrows(() => six <= Symbol(6), TypeError);
assertThrows(() => Symbol(6) < six, TypeError);
assertThrows(() => Symbol(6) <= six, TypeError);
assertFalse(six < {valueOf() {return Object(5)}, toString() {return 6}});
assertTrue(six <= {valueOf() {return Object(5)}, toString() {return 6}});
assertFalse({valueOf() {return Object(5)}, toString() {return 6}} < six);
assertTrue({valueOf() {return Object(5)}, toString() {return 6}} <= six);
}

86
deps/v8/test/mjsunit/harmony/bigint/dataview.js vendored Normal file
View File

@ -0,0 +1,86 @@
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var buffer = new ArrayBuffer(64);
var dataview = new DataView(buffer, 8, 24);
var bytes = new Uint8Array(buffer);
var b1 = 0xff1234567890abcdefn;
var b1_64 = BigInt.asUintN(64, b1);
dataview.setBigInt64(8, b1);
assertEquals(0x12, bytes[16]);
assertEquals(0x34, bytes[17]);
assertEquals(0x56, bytes[18]);
assertEquals(0x78, bytes[19]);
assertEquals(0x90, bytes[20]);
assertEquals(0xab, bytes[21]);
assertEquals(0xcd, bytes[22]);
assertEquals(0xef, bytes[23]);
assertEquals(b1_64, dataview.getBigInt64(8));
dataview.setBigInt64(8, b1, true); // Little-endian.
assertEquals(0xef, bytes[16]);
assertEquals(0xcd, bytes[17]);
assertEquals(0xab, bytes[18]);
assertEquals(0x90, bytes[19]);
assertEquals(0x78, bytes[20]);
assertEquals(0x56, bytes[21]);
assertEquals(0x34, bytes[22]);
assertEquals(0x12, bytes[23]);
assertEquals(b1_64, dataview.getBigInt64(8, true));
dataview.setBigUint64(8, b1);
assertEquals(0x12, bytes[16]);
assertEquals(0x34, bytes[17]);
assertEquals(0x56, bytes[18]);
assertEquals(0x78, bytes[19]);
assertEquals(0x90, bytes[20]);
assertEquals(0xab, bytes[21]);
assertEquals(0xcd, bytes[22]);
assertEquals(0xef, bytes[23]);
assertEquals(b1_64, dataview.getBigUint64(8));
dataview.setBigUint64(8, b1, true); // Little-endian.
assertEquals(0xef, bytes[16]);
assertEquals(0xcd, bytes[17]);
assertEquals(0xab, bytes[18]);
assertEquals(0x90, bytes[19]);
assertEquals(0x78, bytes[20]);
assertEquals(0x56, bytes[21]);
assertEquals(0x34, bytes[22]);
assertEquals(0x12, bytes[23]);
assertEquals(b1_64, dataview.getBigUint64(8, true));
var b2 = -0x76543210fedcba98n;
dataview.setBigInt64(8, b2, true);
assertEquals(0x68, bytes[16]);
assertEquals(0x45, bytes[17]);
assertEquals(0x23, bytes[18]);
assertEquals(0x01, bytes[19]);
assertEquals(0xef, bytes[20]);
assertEquals(0xcd, bytes[21]);
assertEquals(0xab, bytes[22]);
assertEquals(0x89, bytes[23]);
assertEquals(b2, dataview.getBigInt64(8, true));
assertEquals(0x89abcdef01234568n, dataview.getBigUint64(8, true));
var b3 = -0x8000000000000000n; // The int64_t minimum value.
dataview.setBigInt64(8, b3);
assertEquals(b3, dataview.getBigInt64(8));
assertEquals(-b3, dataview.getBigUint64(8));
var b4 = 0x8000000000000000n;
dataview.setBigInt64(8, b4);
assertEquals(-b4, dataview.getBigInt64(8));
assertEquals(b4, dataview.getBigUint64(8));
assertThrows(() => dataview.setBigInt64(0, 1), TypeError);
assertThrows(() => dataview.setBigUint64(0, 1), TypeError);
assertThrows(() => dataview.setInt32(0, 1n), TypeError);
assertThrows(() => dataview.setUint32(0, 1n), TypeError);
// None of the stores wrote out of bounds.
for (var i = 0; i < 16; i++) assertEquals(0, bytes[i]);
for (var i = 24; i < 64; i++) assertEquals(0, bytes[i]);

83
deps/v8/test/mjsunit/harmony/bigint/dec.js vendored Normal file
View File

@ -0,0 +1,83 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x26ffcdbd233a53e7ca4612f2b02e1f2c1d885c3177e7n,
r: 0x26ffcdbd233a53e7ca4612f2b02e1f2c1d885c3177e6n
}, {
a: 0xf2a29a35193377a223ef0d6d98db95eeb24a4165f288fd2b4an,
r: 0xf2a29a35193377a223ef0d6d98db95eeb24a4165f288fd2b49n
}, {
a: 0x454d22e29e6104n,
r: 0x454d22e29e6103n
}, {
a: -0xb00874640d30e6fce6bf79508378ed17e44dacb48a4200bce536cec462b3c2n,
r: -0xb00874640d30e6fce6bf79508378ed17e44dacb48a4200bce536cec462b3c3n
}, {
a: 0x4c151a24d765249c2bab4a1915b24b80ae437417c5n,
r: 0x4c151a24d765249c2bab4a1915b24b80ae437417c4n
}, {
a: -0xcbd476b1f9ca08ff820941n,
r: -0xcbd476b1f9ca08ff820942n
}, {
a: -0xe848e5830fa1035322b39c2cdd031109ca8n,
r: -0xe848e5830fa1035322b39c2cdd031109ca9n
}, {
a: -0x4d58c5e190f0ebac5bb36ca4d214069f69726c63a5n,
r: -0x4d58c5e190f0ebac5bb36ca4d214069f69726c63a6n
}, {
a: 0x9b396n,
r: 0x9b395n
}, {
a: 0x593921fe8b9d4906cn,
r: 0x593921fe8b9d4906bn
}, {
a: -0xe127928c7cecd6e9ca94d98e858f9c76a0fccac62203aac7710cef1f9e352n,
r: -0xe127928c7cecd6e9ca94d98e858f9c76a0fccac62203aac7710cef1f9e353n
}, {
a: 0xeb14cd952d06eb6fc613016f73b7339cbdd010n,
r: 0xeb14cd952d06eb6fc613016f73b7339cbdd00fn
}, {
a: -0xfdeab6a3dbd603137f680413fecc9e1c80n,
r: -0xfdeab6a3dbd603137f680413fecc9e1c81n
}, {
a: -0x7e9abbdfad170df2129dae8e15088a02b9ba99276a351a05n,
r: -0x7e9abbdfad170df2129dae8e15088a02b9ba99276a351a06n
}, {
a: 0x7b98f57n,
r: 0x7b98f56n
}, {
a: -0x919751deb470faa60d7c5c995c8bed72f9542d710fbbf1341n,
r: -0x919751deb470faa60d7c5c995c8bed72f9542d710fbbf1342n
}, {
a: -0xc5541d89b118a88afdd187228440427c8a24f9d9bn,
r: -0xc5541d89b118a88afdd187228440427c8a24f9d9cn
}, {
a: -0xe6c88a170595fn,
r: -0xe6c88a1705960n
}, {
a: -0xa1ffbfa388c332804dc4dc973n,
r: -0xa1ffbfa388c332804dc4dc974n
}, {
a: 0x67b768ce0c415127a77402861d1901dd7f60a8624ebea6ecafe03adc3cen,
r: 0x67b768ce0c415127a77402861d1901dd7f60a8624ebea6ecafe03adc3cdn
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = --d.a;
if (d.r !== r) {
print("Input: " + d.a.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

11
deps/v8/test/mjsunit/harmony/bigint/div-special-cases.js vendored Normal file
View File

@ -0,0 +1,11 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Regression test for crbug.com/1233397.
let y_power = 13311n * 64n; // Large enough to choose the Barrett algorithm.
// A couple of digits and a couple of intra-digit bits larger.
let x_power = y_power + 50n * 64n + 30n;
let x = 2n ** x_power;
let y = 2n ** y_power;
let q = x / y;

105
deps/v8/test/mjsunit/harmony/bigint/div.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: -0x1e0f357314bac34227333c0c2086430dae88cb538f161174888591n,
b: 0x390n,
r: -0x8700f00dd65d4009ab90c5d3a887e9c8ad110a72ca7e0f84a40n
}, {
a: 0x9b7a0098fd2d495b4b2c76ff5888ae2a0359cfec6b029e6f3ee9b014802n,
b: 0xbn,
r: 0xe225d252e49ef6563ecc4fff0c69b782ed99e89db2ec895bfe6b2ea974n
}, {
a: 0x6821a6dad136b9f64096337b45d6d947cf0f0b55501e33e66fbc4ef9776n,
b: 0xan,
r: 0xa69c3e2ae8578ff06756b8c53c8af53fb1b1abbbb363863d7f93b18f25n
}, {
a: 0xf42f96f0c7f5a9c656a66122a9bcc57aa386bdb9a834e4174d45795ae408dae14e085cn,
b: -0x5e0d81a1107ef9a38b4f24b4n,
r: -0x298a4d479eac8c186fd61939024b420080b6ae6500c70c1n
}, {
a: 0xbaf7baed984dda3c20f23201f366257c601f7fbcaf51d8b738a68fd92b4n,
b: 0xd24a1eafcn,
r: 0xe39bd4d870d72880e6ad88ec17bcca6bd0eaacfbbd28ba7458n
}, {
a: -0xa658d0683d450bfec3de3fe4253f4348dd8e9a5b1002f6c24ff0en,
b: -0xeffb9a6fa690e0be59aba488b7a7c5a85a65a018242n,
r: 0xb1730d7206n
}, {
a: 0x5a65f7b2dace4550099f4009192caa513468ef4da7e2fd81n,
b: 0xf144f8bfad42d9beaf7b82a46561n,
r: 0x5feae36e8e4932adcb21n
}, {
a: -0x87271b0cbb63eba5e3d70f6af1aa6ec60c0a7884fb8d657b03en,
b: -0xb67f8c18099ce8fa0c0f4ce2852b5590f7a8037d326b0n,
r: 0xbd9602n
}, {
a: 0xd4bc42a434dba1427d387f0858aaf39c6281ffc0f10b8b0996cb3bfn,
b: -0x4198d1fec9b48e38d42f2e295abc39c2a6866527efn,
r: -0x33e39b6878d955n
}, {
a: 0x6a6f0c97d974dfd20337ca611dbdc96433964a206d54n,
b: 0x16c7c6f9e0e4e24d521e463fecb394e2936f3104590n,
r: 0x4an
}, {
a: -0xd09af7515272d81a64307afaed8854c8e2996d8e01d4864n,
b: 0x7521dfcbdf4cfbbf8d3859bf67618c91dc6915718303dbn,
r: -0x1cn
}, {
a: 0xf0da5f24832a2b651aac5dff62b22475212c26e123ff78c34560f35e9bcn,
b: -0xf9n,
r: -0xf79fbd51bf65f518c82563b974e4632b505ebe13adbfb6c297859a98cn
}, {
a: 0x76f4f5b5de8a263514554d62273e51f40342d5df692ae17625ead5b5fen,
b: -0xa5e697c57fb65858604e0a060737e7d9d1en,
r: -0xb78fb2167de210959e57cd3n
}, {
a: -0xa714d4d9d747fa5258f80f3887f4dda8a11423050046282n,
b: -0xaa3b218ab92e21920a707487fdbn,
r: 0xfb437487ba8580181ca3n
}, {
a: -0x165f3c659ac4157cb3af081b3fc42c0c788e2df501596c2b8n,
b: -0xfaa86d6eca3n,
r: 0x16d94bce4865cf842d17a399d8b4467f3f369fn
}, {
a: 0x268d93a21aab44c52f961b1c97c002f427eb8b11e0707e3879c3a348f8e2b1c40c122n,
b: 0x70ccda2e2bba53b124c877bb4edbdbd387742cfe59d9bn,
r: 0x577effaeb2338647e38edb43n
}, {
a: 0x3a13493c9e8d3d986a2a56c0aa811be408e1560f30ae155n,
b: -0x62a1a35fd7e184be45a1d0ba67888f0d982afb7a90an,
r: -0x96bcn
}, {
a: -0x2a3f3f90ea280bf64e7e460f004ea4fb2553637cb7c844f349f045ffdbn,
b: -0xf2af2581bddfd9bfc1158c86211c4f4b169c0b1n,
r: 0x2c90ab8577b8d0ee86en
}, {
a: 0x8fd5f992d4d767c8a360ad32142fa9e9d87bc0036d1d6bb7aa7471dd7f38bn,
b: 0xe70n,
r: 0x9f6709805e05fd8b3c433e470387f06391b6948459e4c2bc072747e2a0n
}, {
a: 0x52c0e08ba0a22a00498058dfeeaab2b21909e81e30c48652699n,
b: 0x1d516c96827an,
r: 0x2d2967f58654a5d30934348b225bf2b6e2a3123dn
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a / d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: /");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

56
deps/v8/test/mjsunit/harmony/bigint/exp.js vendored Normal file
View File

@ -0,0 +1,56 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
assertEquals(1n, (-1n) ** 0n);
assertEquals(-1n, (-1n) ** 1n);
assertEquals(1n, (-1n) ** 2n);
assertEquals(-1n, (-1n) ** 3n);
assertEquals(1n, (-1n) ** 4n);
// Multi-digit exponents.
assertEquals(1n, (-1n) ** (2n ** 80n));
assertEquals(-1n, (-1n) ** ((2n ** 80n) + 1n));
assertEquals(1n, 0n ** 0n);
assertEquals(0n, 0n ** 1n);
assertEquals(0n, 0n ** 23n);
assertEquals(1n, 1n ** 0n);
assertEquals(1n, 1n ** 1n);
assertEquals(1n, 99n ** 0n);
assertEquals(2n, 2n ** 1n);
assertEquals(4n, 2n ** 2n);
assertEquals(8n, 2n ** 3n);
assertEquals(16n, 2n ** 4n);
assertEquals(151115727451828646838272n, 2n ** 77n);
assertEquals(3n, 3n ** 1n);
assertEquals(9n, 3n ** 2n);
assertEquals(27n, 3n ** 3n);
assertEquals(81n, 3n ** 4n);
assertEquals(243n, 3n ** 5n);
assertEquals(30903154382632612361920641803529n, 3n ** 66n);
assertEquals(1n, (-2n) ** 0n);
assertEquals(-2n, (-2n) ** 1n);
assertEquals(4n, (-2n) ** 2n);
assertEquals(-8n, (-2n) ** 3n);
assertEquals(16n, (-2n) ** 4n);
assertEquals(-32n, (-2n) ** 5n);
assertEquals(1n, (-3n) ** 0n);
assertEquals(-3n, (-3n) ** 1n);
assertEquals(9n, (-3n) ** 2n);
assertEquals(-27n, (-3n) ** 3n);
assertEquals(81n, (-3n) ** 4n);
assertEquals(-243n, (-3n) ** 5n);
assertThrows(() => 3n ** -2n, RangeError); // Negative exponent.
assertThrows(() => 2n ** (1024n ** 4n), RangeError); // Too big.
// Mixed types
assertThrows(() => 1n ** 1, TypeError);
assertThrows(() => 1 ** 1n, TypeError);

83
deps/v8/test/mjsunit/harmony/bigint/inc.js vendored Normal file
View File

@ -0,0 +1,83 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0xb3df90n,
r: 0xb3df91n
}, {
a: 0xaacd53fc9545eb394304a3c69caba730230a6527730an,
r: 0xaacd53fc9545eb394304a3c69caba730230a6527730bn
}, {
a: 0x32efa4ba1c29098be7df8fa0f3c74a183612ecn,
r: 0x32efa4ba1c29098be7df8fa0f3c74a183612edn
}, {
a: -0xcabed06f63ad50406b96187208cf9ec6faf46413ce83e280c31ben,
r: -0xcabed06f63ad50406b96187208cf9ec6faf46413ce83e280c31bdn
}, {
a: -0x8a40ce58f753466f4008faa0814e76d9b594908df0e42cf6ad4a781e60ce2n,
r: -0x8a40ce58f753466f4008faa0814e76d9b594908df0e42cf6ad4a781e60ce1n
}, {
a: -0x848c8fc23bc93801n,
r: -0x848c8fc23bc93800n
}, {
a: -0x13a8316c5af3f3b06aab6642e717a7bdn,
r: -0x13a8316c5af3f3b06aab6642e717a7bcn
}, {
a: -0x5f5e517cf7efe577cd689c36d1beb3d9df4cfdc3fcb55ed9e9d8fan,
r: -0x5f5e517cf7efe577cd689c36d1beb3d9df4cfdc3fcb55ed9e9d8f9n
}, {
a: 0n,
r: 0x1n
}, {
a: 0x107d5ec8048c4d715e213ec74f9f04006d3f2d90dd95d17c3e82f7a4ccn,
r: 0x107d5ec8048c4d715e213ec74f9f04006d3f2d90dd95d17c3e82f7a4cdn
}, {
a: 0xb8e09fc6037a75bbfn,
r: 0xb8e09fc6037a75bc0n
}, {
a: 0x515d1b999660074184n,
r: 0x515d1b999660074185n
}, {
a: 0xe12def67dc33628638612b8137d0fa425ea2dn,
r: 0xe12def67dc33628638612b8137d0fa425ea2en
}, {
a: 0x96a9n,
r: 0x96aan
}, {
a: -0x9df122a299a5e65b275028n,
r: -0x9df122a299a5e65b275027n
}, {
a: 0x20dd05bfb5ed6ebfb05da9a7488800b8895fbfe6d709eecb6071cda73e13n,
r: 0x20dd05bfb5ed6ebfb05da9a7488800b8895fbfe6d709eecb6071cda73e14n
}, {
a: 0xb38294d2e5523534c56dd6ef38ba744b29e3a3bb6f863f1aeaen,
r: 0xb38294d2e5523534c56dd6ef38ba744b29e3a3bb6f863f1aeafn
}, {
a: -0x6b58de4ba9b2699ea6777dc1adc0b2486n,
r: -0x6b58de4ba9b2699ea6777dc1adc0b2485n
}, {
a: 0xf40028a48894df5d81131046477a22e55cbead5n,
r: 0xf40028a48894df5d81131046477a22e55cbead6n
}, {
a: -0x44cbe6c7f5e7e879d3cb2eaffc4af0a43affc094218031a1f123746549dd7b8cdcbdn,
r: -0x44cbe6c7f5e7e879d3cb2eaffc4af0a43affc094218031a1f123746549dd7b8cdcbcn
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = ++d.a;
if (d.r !== r) {
print("Input: " + d.a.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

81
deps/v8/test/mjsunit/harmony/bigint/json.js vendored Normal file
View File

@ -0,0 +1,81 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
'use strict'
// Without .toJSON method.
assertEquals(undefined, BigInt.prototype.toJSON);
assertThrows(() => JSON.stringify(42n), TypeError);
assertThrows(() => JSON.stringify(Object(42n)), TypeError);
// With .toJSON method that returns a string.
BigInt.prototype.toJSON = function() {
assertEquals("bigint", typeof this);
return String(this);
}
assertEquals("\"42\"", JSON.stringify(42n));
BigInt.prototype.toJSON = function() {
assertEquals("object", typeof this);
return String(this);
}
assertEquals("\"42\"", JSON.stringify(Object(42n)));
// With .toJSON method that returns a BigInt primitive.
BigInt.prototype.toJSON = function() {return this};
assertThrows(() => JSON.stringify(42n), TypeError);
assertThrows(() => JSON.stringify(Object(42n)), TypeError);
// With .toJSON method that returns a BigInt object.
BigInt.prototype.toJSON = function() {return Object(this)};
assertThrows(() => JSON.stringify(42n), TypeError);
assertThrows(() => JSON.stringify(Object(42n)), TypeError);
// Without .toJSON method but with a replacer returning a string.
delete BigInt.prototype.toJSON;
let replacer;
replacer = function(k, v) {
assertEquals("bigint", typeof v);
assertTrue(42n == v);
return "43";
}
assertEquals("\"43\"", JSON.stringify(42n, replacer));
replacer = function(k, v) {
assertEquals("object", typeof v);
assertTrue(42n == v);
return "43";
}
assertEquals("\"43\"", JSON.stringify(Object(42n), replacer));
// Without .toJSON method but with a replacer returning a BigInt primitive.
assertEquals(undefined, BigInt.prototype.toJSON);
replacer = () => 43n;
assertThrows(() => JSON.stringify(42n, replacer), TypeError);
assertThrows(() => JSON.stringify(Object(42n), replacer), TypeError);
// Without .toJSON method but with a replacer returning a BigInt object.
assertEquals(undefined, BigInt.prototype.toJSON);
replacer = () => Object(43n);
assertThrows(() => JSON.stringify(42n, replacer), TypeError);
assertThrows(() => JSON.stringify(Object(42n), replacer), TypeError);

8
deps/v8/test/mjsunit/harmony/bigint/misc.js vendored Normal file
View File

@ -0,0 +1,8 @@
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Create BigInt in large object space for which MakeImmutable reduces the
// length.
const x = 2n ** (2n ** 22n);
assertEquals(1n, x - (x - 1n));

8
deps/v8/test/mjsunit/harmony/bigint/mod-special-cases.js vendored Normal file
View File

@ -0,0 +1,8 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
let quotient = 0x1234567890abcdef12345678n; // Bigger than one digit_t.
let dividend = quotient * 10n;
let result = dividend % quotient;
assertEquals(0n, result);

105
deps/v8/test/mjsunit/harmony/bigint/mod.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0xaed3c714bb42a73d708bcf1dc9a9deebadc913ef42bac6a6178a60n,
b: -0xf3d6bd1c059b79n,
r: 0x2a4f893c8ece3n
}, {
a: -0x8a6d8cb8e32aba50e08fd50aecbda6821e1863bf9a2n,
b: 0xe19ab8530bce542ec6b4c848fc383a2b688f07976dd523dabn,
r: -0x8a6d8cb8e32aba50e08fd50aecbda6821e1863bf9a2n
}, {
a: 0x7cd19a308b217ddd9dcda69ebe37767f09a483cb87060314aeade6f6c619d27c3n,
b: 0xae30b5c754e0an,
r: 0x619154797565dn
}, {
a: -0xaa90d777e849974d7ebebd2ed76dce635e36713e9e0c97cen,
b: 0xcc2bc7239bf83ecafc74b25750981df258n,
r: -0xa32d47bc250c5a41d147a862099778685en
}, {
a: 0x7386178fe1159c4ca3c4e5caa6eda4413926047efd22007931c22ab54bn,
b: 0xc05100caa704bca144n,
r: 0x55ead7f83d4a795753n
}, {
a: -0xa48867cf46692351a59bc89c0ddc9a6d2cd9f72578c0bab72d8389n,
b: 0x77c2eec6cc0bef33dd4756b223c35a0f2b528f8648a7n,
r: -0x184a6eed8fcd32399c59605c7255b5614b388be24b44n
}, {
a: 0xac7681c26f78191107c9cde47f984fc7ffb7bffd0a055fc14n,
b: -0xe2d91d1a0e1edc3f806a24c36f7ca0a8a9b44b66c9n,
r: 0xdf0b3460335089fca0b1da676b3d1e9caf15afd3den
}, {
a: -0x3035011f4adba0c032ddc2fc884ff7663b45cb3baebec0fn,
b: 0xcc27f9a21470911a61aae50ae118ebcf85ea4dn,
r: -0xc5ea1db5af95ccdce2844b13b82659be1ac2adn
}, {
a: -0x2dbe79c42b1e8db7aea4ca9cfaf1350528b096e23f69ea322cn,
b: -0x82f7e4f2ee432485n,
r: -0x824bddbaf61ce383n
}, {
a: 0xc5c7fbeb60fdb9f8e8347ebf9fe303e3223394b2db93ce2n,
b: 0xcd988b4cb278a39fd3ae58c16616855f01fab0fb0n,
r: 0xc3b5157e680c8ca66df1bd640c6ad1601bd612b02n
}, {
a: 0x73dd1e27450edb450fe4bd70494a8ad85a8ad9691bc40bf500a1n,
b: 0xc8fb467f71be8a6b965d21857ecfdn,
r: 0x646e6d9fa1e2eb2933b2e5a837d37n
}, {
a: -0xecb217583ec4240399bfa34560b45f1fd08efd0ebb56b2dn,
b: 0xeba34abn,
r: -0xc2d347bn
}, {
a: 0x29c8a9854802b9317b90683eb82609b3aa695598807fea0482a56567n,
b: -0xabe5e55b228f8n,
r: 0x52303615b525fn
}, {
a: 0x7b532ee90b3945dbed20180632f46c90d0edb558e39456103f50e5a74ff1dn,
b: 0x17n,
r: 0x6n
}, {
a: -0x6f1dbf8dedea796a2423fad9688d71340963da3a4f005f13e9cd4aa03b96c864552cn,
b: -0x408a4f36ec4a1b74642fb0a4559en,
r: -0x33c06c53e6e47ca87f36447f1b0n
}, {
a: -0xe77508ff49bc76c78678676ca1edc82eb167f3b07d3208d89d26582ef74d60n,
b: -0xf005fb1a8b29035c72980abe4a0715c90n,
r: -0x159e8c7616079663b4e12765a05cc6d40n
}, {
a: 0x626749ef019017f53b2c686f26594e6d3c5f247cf0ed7024cca277n,
b: 0x5bd931ea8c6939115ad69f6ce3c6bbc300320n,
r: 0x3a4b041c36d0a45ef932745eab473943b1a97n
}, {
a: -0x960dde134b881d3366d659c7d8c3eb6346f50c08c6f78en,
b: -0xc9e7fa60f6ce1997012f5a6164138447fa248754985905dc6n,
r: -0x960dde134b881d3366d659c7d8c3eb6346f50c08c6f78en
}, {
a: 0x702dc0033e09e9e58ec3fc96f861587ad13cea1ed7b7eb301n,
b: 0x71f0c97687b4f3318be2fe54b90273n,
r: 0x4e1859254ac1d42f7c812decef00a3n
}, {
a: 0x39376649769a0abb26133deee934330ef21a2f90ea89476569630021af6023235n,
b: -0x4aaaec4085f65ccc9d547beb122160afcbb3n,
r: 0x3027d5ebb37c5aa438f11dfcafa3b003b91bn
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a % d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: %");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

10
deps/v8/test/mjsunit/harmony/bigint/mul-special-cases.js vendored Normal file
View File

@ -0,0 +1,10 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Regression test for crbug.com/1223724
const kBits = 500 * 64;
const a = BigInt.asUintN(kBits, -1n);
const b = a * a;
const expected = (a << BigInt(kBits)) - a;
assertEquals(expected, b);

105
deps/v8/test/mjsunit/harmony/bigint/mul.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x2bf1f236c2df29f7c99be052dfe1b69ae158d777fea487af889f6259f472c0n,
b: -0xae0090dfn,
r: -0x1dde8b7f987479d7b308e2b8a122703d417f921fd4ab04fcac81439ace4f445c7bf540n
}, {
a: -0x71cd629b6682b5b1c50f9436ded88468bcn,
b: -0xb24ce1d11726048158fb42c02e9361973193n,
r: 0x4f42fbebca0bc1746d114996d9c9cceb4065c347da31dc0efa88db41f1f724aef81ff4n
}, {
a: 0xef7c15fb2256338bd0650fa51c28551108ccb9828850f1b415d0c8f1a47fc0e2f86n,
b: 0xc17n,
r: 0xb4f552dbf2c20292f5475d025276b9c70f16316c91e0a9a2833bf2d616bc484f808d0an
}, {
a: 0xcc8a5a56c623d9f9be2103bc237976f26n,
b: 0x13a02fec7cfd49c5a081c06bbbaac5c70dc3an,
r: 0xfae417740ef1963ad78aa4252159d986593845690f4f5fe759f6d913d79810473d69cn
}, {
a: -0x519n,
b: 0x7de5551df3ec2619a89139153663a79f8bdb47047423c8070d7cfddc26d43af8ee9n,
r: -0x281c60ee5b06ece38cc4c4bfd2242017c4ff0cd05b40a66abf3c22a1741efe09ef81c1n
}, {
a: 0x6fb9ba0d0n,
b: -0x86b45ffb80fbf2b61abc14b28855780f83e187fd6ae26e09d28d6f05260e1n,
r: -0x3ac9efdd4e930fcbf654819060b858f182f7768db6bc72deb8d734d2ea10fa02b656d0n
}, {
a: -0xde2e7a0883a63d69d2120108f92943e4a34b63e8468c12b38a0519a6498n,
b: -0xb1857781fefn,
r: 0x9a11f83db6da31f78a2415d3891f79a0f6aafc69553fb458a2bc3ae2e2f65cb09251e8n
}, {
a: -0x2c90284ebdb5237ba7c9562f596ef9a21254a3n,
b: -0xb55feab8b45cc1bcdcfc5585c9114de0n,
r: 0x1f929eda8d33ec2ded8d76382a4cb731f805d28e827521a27154b6618a6f87ed5215a0n
}, {
a: 0x11ffe68d26ca29eac43b64n,
b: -0xe3311b278fec1fb3f8f59acfd9147c773197fc54c66b25bdn,
r: -0xff95d530fd53e61744d86d09f9ab5401b1efb2133af5c47ffeca31aca22a4da414cd4n
}, {
a: 0xbda74de44eeb2995a4185325014863n,
b: 0xf99164c7248a0372d72d82cbf65fdb345c84bca6n,
r: 0xb8e3712f119fefa47168950100b33aa1ec4e61a970d0eec2d2dd4b925cc4dfd709a432n
}, {
a: 0x47fc0bb6d761e12a1f7cf2a14f4cc777486b22516ca339641fn,
b: -0xd2fa2494ae242494f307n,
r: -0x3b531808ad9095f9f904dba47ef4a0aef54f736cc2836accb7b1b70f07ee862e8729d9n
}, {
a: 0x91d09f35203fcf69974d347ab718912cn,
b: 0xfc2d9a00611e4e1767b67db898b951e5d2bbb9n,
r: 0x8fa3561bff2cc00a780a71e5b16d6092296514d401c88fc54e04a91062775cb4e40cccn
}, {
a: 0x5a5b1ede360dafcac08c92f4b809e401502df5ab8569303a2n,
b: -0xb64d963b1ac4eb46ddd65n,
r: -0x40582a6083cd0feb5b33ac138feaf9250b5084e561807e56a8415c810a1bf9861d48ean
}, {
a: 0xf68275dc25d6af7dde130n,
b: 0xfe330b766e44f479e342e3315812e977d4d5e39bffe42111dn,
r: 0xf4c697f78dc7c9b3207b50cf2cf3035aa065e96c37c0be3345f71f34096f057e76b270n
}, {
a: 0x77009ed053f71n,
b: -0x647aecfc2af4079a586fbba99070c3f51d5465d9a4fd8c12cdab10854n,
r: -0x2eb5627edb1072a65a1db2d243d0bf2eeb5c3ff6ad61ec1063e9ee40b783bd06d55914n
}, {
a: 0xccfa15bb6125b01bece5a919ab5e9128e784d63e50b5990ba8047a7effn,
b: 0x1a366ac48cdan,
r: 0x14fcf8728aa3dc5ef26b077dfc012d592c3a0cdfc3331942f921f037eea5af9eff9926n
}, {
a: 0x4fc54a59f2n,
b: -0x93bbcbd684987407c4ec4a3cbdc7c4821c33ca20ca8449b0055905e9a8ffn,
r: -0x2e08ce533fdc7bb8a3a2280cfb116c85837b74606ed25f8daad623baa4ac7de758680en
}, {
a: -0xcf21626f318089a85738f7e9cdcf0a477f4d880ce58679n,
b: -0xc7ca8704a49fdb8f9567c68cn,
r: 0xa1a6d11a77d8e1b723bfa0242407a454274145c31bb6ede29bb0e3883b08951b36202cn
}, {
a: 0x20c3cb19e51d4e2ac2c89f26e052bef8n,
b: -0xab2a148297108425ebd2fd17d897f647e0792fn,
r: -0x15e82b69a0eaed04cd140c6aed3b1f5bc0fc5de7ceddcb2d77615767b19dd82c744788n
}, {
a: -0xcc4f48f45d8165569348fb995370n,
b: 0x140cc111df0a06e32335478ded744eb3a737a53409n,
r: -0x10005f808c07a1d91faac090aad06804b491919a9d2ed58f6caa52448ad97bd486aef0n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a * d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: *");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

83
deps/v8/test/mjsunit/harmony/bigint/neg.js vendored Normal file
View File

@ -0,0 +1,83 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0xcn,
r: -0xcn
}, {
a: -0x5a3d0f6cdb7987a2d262838c05359f786a484d052529n,
r: 0x5a3d0f6cdb7987a2d262838c05359f786a484d052529n
}, {
a: -0x98d8c6cbfd67b6b652b7a4670478f6706e06a3n,
r: 0x98d8c6cbfd67b6b652b7a4670478f6706e06a3n
}, {
a: -0xe66ac692ff012bd0f4ca38804628f71ff411aede09c59597n,
r: 0xe66ac692ff012bd0f4ca38804628f71ff411aede09c59597n
}, {
a: -0x97e1e0c13c0c0c420aca92268ea802047c30570335de0000dn,
r: 0x97e1e0c13c0c0c420aca92268ea802047c30570335de0000dn
}, {
a: 0x6b2eddc3b212913abed4f5c84e3eee64d6463224dff8n,
r: -0x6b2eddc3b212913abed4f5c84e3eee64d6463224dff8n
}, {
a: -0xfcd42a712dd928deb51ab2d151fa6bee0f4dd2fa6n,
r: 0xfcd42a712dd928deb51ab2d151fa6bee0f4dd2fa6n
}, {
a: -0x75ba8e0e92a05ff552f2dc3afb39a4dn,
r: 0x75ba8e0e92a05ff552f2dc3afb39a4dn
}, {
a: 0x4570376e541836fab5190e08an,
r: -0x4570376e541836fab5190e08an
}, {
a: 0x15aca33cfb06n,
r: -0x15aca33cfb06n
}, {
a: 0x7ec0027910c44b791bf193c6f25487a9435n,
r: -0x7ec0027910c44b791bf193c6f25487a9435n
}, {
a: -0x31f0d92f358618e6b29a2899bd988533838d33839fb37n,
r: 0x31f0d92f358618e6b29a2899bd988533838d33839fb37n
}, {
a: 0xb4f84118d797244c982f1n,
r: -0xb4f84118d797244c982f1n
}, {
a: 0x626n,
r: -0x626n
}, {
a: 0x9f35c8968457d07608699df5894c0542f35b73b0b5ce8423aan,
r: -0x9f35c8968457d07608699df5894c0542f35b73b0b5ce8423aan
}, {
a: -0xb5be1f7937895adc457f051d1f4bc74d556b432dn,
r: 0xb5be1f7937895adc457f051d1f4bc74d556b432dn
}, {
a: 0xcacb413b3cab5a5f5086511728d1afbaa82ca41e69805daf47503e2n,
r: -0xcacb413b3cab5a5f5086511728d1afbaa82ca41e69805daf47503e2n
}, {
a: -0x77ef7cbb15cee20a519a1n,
r: 0x77ef7cbb15cee20a519a1n
}, {
a: -0x71ac9bfe7f5f70038c7fn,
r: 0x71ac9bfe7f5f70038c7fn
}, {
a: -0x500a02b8fd66ee1067022c02c7241acdc42b947bfb933aa95a8d6n,
r: 0x500a02b8fd66ee1067022c02c7241acdc42b947bfb933aa95a8d6n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = -d.a;
if (d.r !== r) {
print("Input: " + d.a.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

83
deps/v8/test/mjsunit/harmony/bigint/not.js vendored Normal file
View File

@ -0,0 +1,83 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x9f0305cd75e4n,
r: -0x9f0305cd75e5n
}, {
a: -0xe8e9c8312f553c9n,
r: 0xe8e9c8312f553c8n
}, {
a: -0x1a29f0783a66534da3c024ad1cc854073f886888fen,
r: 0x1a29f0783a66534da3c024ad1cc854073f886888fdn
}, {
a: -0xfc2cc19496c1ced95be832ca5246d41c526b9fa28b88bcd39813aa336n,
r: 0xfc2cc19496c1ced95be832ca5246d41c526b9fa28b88bcd39813aa335n
}, {
a: 0x13ebn,
r: -0x13ecn
}, {
a: 0x4c12d642b2a132f0c927ec7504b530fb45d5e249163ffdc59feb3de31881n,
r: -0x4c12d642b2a132f0c927ec7504b530fb45d5e249163ffdc59feb3de31882n
}, {
a: 0x49637a624cb8782002e3e0874ad76215e188cee948c7ce7b0f66e1d0n,
r: -0x49637a624cb8782002e3e0874ad76215e188cee948c7ce7b0f66e1d1n
}, {
a: -0x81cbae84e6753b885ada46c0bf72368c083fed622fn,
r: 0x81cbae84e6753b885ada46c0bf72368c083fed622en
}, {
a: -0xcdf793acfdd08b6n,
r: 0xcdf793acfdd08b5n
}, {
a: 0x88n,
r: -0x89n
}, {
a: -0x1fn,
r: 0x1en
}, {
a: 0x5c3278e76266b9e93d63eb4f2aa53716220aa1n,
r: -0x5c3278e76266b9e93d63eb4f2aa53716220aa2n
}, {
a: -0x9f4fe05n,
r: 0x9f4fe04n
}, {
a: 0xdn,
r: -0xen
}, {
a: -0x74a9d63d02bd1393b311211e35c8b2d11e2367ffffb812683365f02d98n,
r: 0x74a9d63d02bd1393b311211e35c8b2d11e2367ffffb812683365f02d97n
}, {
a: 0x8a2831ae3e1b6b21a7b3d7ee921a0c0edf29b272d654f647169a5a6141d3aaf41439n,
r: -0x8a2831ae3e1b6b21a7b3d7ee921a0c0edf29b272d654f647169a5a6141d3aaf4143an
}, {
a: 0xa2ef28270a7e668e190bc303537f5a8ba3f0d59bcn,
r: -0xa2ef28270a7e668e190bc303537f5a8ba3f0d59bdn
}, {
a: -0x4f8bd11ee4ef38682a0c94en,
r: 0x4f8bd11ee4ef38682a0c94dn
}, {
a: 0x5436d0721d1282755068add3b5ab5424cb455fad50811a9afff0be5n,
r: -0x5436d0721d1282755068add3b5ab5424cb455fad50811a9afff0be6n
}, {
a: 0x5db6907c92529f517d24a6ff7303de42cb9059ae2adc0c22n,
r: -0x5db6907c92529f517d24a6ff7303de42cb9059ae2adc0c23n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = ~d.a;
if (d.r !== r) {
print("Input: " + d.a.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

105
deps/v8/test/mjsunit/harmony/bigint/or.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x77a87n,
b: 0xde08e7433fb9584911b8cb4bc7eed802299b4489fc635974d063847da4e8b461df5dn,
r: 0xde08e7433fb9584911b8cb4bc7eed802299b4489fc635974d063847da4e8b467ffdfn
}, {
a: -0x1d3ff6f353f2d035ed7b4b8e5e4ae1c8d162n,
b: -0xcf829b11c2f996f388b22cd03aeb75ec434f3be8fde6466n,
r: -0x192f308302c00024a55a4004520a81c84062n
}, {
a: 0x6dbbc93af9a9c222187dn,
b: -0xfaa906348dc49859c34bc7c6n,
r: -0xfaa9020404c400500149c781n
}, {
a: 0xf8n,
b: 0x4388532n,
r: 0x43885fan
}, {
a: -0x3ee35e1823b91414618f05995e11594920539921e9440n,
b: -0x58c5811ee19db01b7d9824c49682af55956119cfbc9868287ef138da08ee3n,
r: -0x3c80040002800414010101891c1048082051180008423n
}, {
a: -0xa2a70c5da9a7e98f242e82d518n,
b: 0n,
r: -0xa2a70c5da9a7e98f242e82d518n
}, {
a: 0x7868475f450ff2b15a03eccb4d26ce8711383f615cn,
b: 0x1c62774e1db239cb461c4190b54de4d872f9484cf82ed1258cc14580cf29f608n,
r: 0x1c62774e1db239cb461c41f8fd4fffdd7ffbf95efbeedb6daecfc791ff3ff75cn
}, {
a: 0x865d033028551a71f6f9f8d7b36cf9819n,
b: -0x68e30391d9831a4ea3e65b2e433f55ba398n,
r: -0x68610290c9830a4482000206000c1102387n
}, {
a: -0x817a0dacbafbaf40ef819fc62a8efc4b4960n,
b: -0x5af313e32a5386e29cb5d2b34d54f04da389f33d52444f177671e41n,
r: -0x12a04840a008a008f019504008074430841n
}, {
a: -0xef8c9475210c0a31aa12c34db6e7737609c75b78a54cn,
b: -0xba91b4ec3a5390db84febaeaddb8209155413e2e02fb0n,
r: -0xa9080441210808300a02820d9282011400034260250cn
}, {
a: -0xf4e707078d14001959f4n,
b: 0n,
r: -0xf4e707078d14001959f4n
}, {
a: 0x601f0n,
b: 0x246fbfn,
r: 0x266fffn
}, {
a: -0x9ccd3d1b6d4bcde8643ad641d395980bn,
b: -0x379e57728185fd098383a23c7f56dn,
r: -0x13901650808484018100003859009n
}, {
a: 0xcc4b3ba719bd1b37f254f36a72ee375ad22abn,
b: -0xb0c220750f2dad9de91ffb8a7bbf8ffefen,
r: -0x4000640e0c8098a0095880188a02dc55n
}, {
a: 0xa230c33b718cd563f9c1577f4f8da160851902341ba1a6e6bdcbec413d98a18n,
b: 0xc2f4e2db2df59ccc34690479ebe64df967n,
r: 0xa230c33b718cd563f9c1577f4f8dad6fcf3db2ff5bede7e6bdcffeff7ddfb7fn
}, {
a: -0x5fbac9a8f47n,
b: 0xf1bfe6f97e8f516685372b06ea89659c3df4ab3f6779e5c0b41e1b570fn,
r: -0x54ba0808841n
}, {
a: -0x7fd2d4a4c60ba795e2fcn,
b: 0x33dcea557cc5156dacb9ad7b252598172f92d8cf7d38e69f0a0n,
r: -0xd02d02000082194025cn
}, {
a: -0x3833089d7cf4e0181247572037a90cc2506342a2191137345e3a0e10n,
b: 0xededf5c7e54cd86afc6d838205c8a78cac7a0e410792a21cf3e4e38dd8ca2dd80n,
r: -0x283208103824c01802450720300908c2004142200111072052180210n
}, {
a: -0x188818a47abbfe64357ccd1a33fb5cb875f86n,
b: -0x14faf1811ee737d048c025f7a1fe156f7e90d23a699d040609e631836500df2e30cdn,
r: -0x108808202299d040201c411832500cb061085n
}, {
a: 0xf60c0260022920bdbd1c837778657936956c15b4cb1n,
b: 0xa10df3b397c24n,
r: 0xf60c0260022920bdbd1c8377786579b79dffb7b7cb5n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a | d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: |");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

32
deps/v8/test/mjsunit/harmony/bigint/property-names.js vendored Normal file
View File

@ -0,0 +1,32 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var { 9007199254740991n: it } = { 9007199254740991n: 1 };
assertEquals(it, 1);
var { 999999999999999999n: it } = { 999999999999999999n: 1 }; // greater than max safe integer
assertEquals(it, 1);
var obj = { 0xfffffffffffffffffffffn: 1};
assertEquals(1, obj["19342813113834066795298815"]);
var obj2 = {0o777777777777777777777777777n: 1};
assertEquals(1, obj2["2417851639229258349412351"]);
var obj3 = { 0x4n: 'hi' };
assertEquals('hi', obj3[4]);
assertEquals(undefined, obj3["0x4"]);
let obj4 =
{12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890n: 1};
assertEquals(
1,
obj4["12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"]);
// 130 hex digits
let obj5 = {0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn: 1};
assertEquals(
1,
obj5["3432398830065304857490950399540696608634717650071652704697231729592771591698828026061279820330727277488648155695740429018560993999858321906287014145557528575"]);

23
deps/v8/test/mjsunit/harmony/bigint/regress-fftmul-2.js vendored Normal file
View File

@ -0,0 +1,23 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
function fastAssertEquals(expected, actual) {
if (expected === actual) return;
// Formatting large BigInts to base-10 string is slow and verbose, so format
// them to hex strings and report only a prefix.
throw new MjsUnitAssertionError(
'Failure:\nexpected:\n0x' +
expected.toString(16).substring(0, 1000) +
'...n\nfound:\n0x' +
actual.toString(16).substring(0, 1000) + '...n');
}
function regress_1228267(power) {
let a = 2n ** power;
let a_squared = a * a;
let expected = 2n ** (2n * power);
fastAssertEquals(expected, a_squared);
}
regress_1228267(1273000n); // This triggered the bug on 32-bit platforms.
regress_1228267(2564000n); // This triggered the bug on 64-bit platforms.

12
deps/v8/test/mjsunit/harmony/bigint/regress-fftmul.js vendored Normal file
View File

@ -0,0 +1,12 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
function regress_1227752(power) {
let a = 2n ** power;
let a_squared = a * a;
let expected = 2n ** (2n * power);
assertEquals(expected, a_squared);
}
regress_1227752(48016n); // This triggered the bug on 32-bit platforms.
regress_1227752(95960n); // This triggered the bug on 64-bit platforms.

25
deps/v8/test/mjsunit/harmony/bigint/regress-minuszero.js vendored Normal file
View File

@ -0,0 +1,25 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
assertTrue(BigInt("-0 ") == -0);
assertTrue("-0 " == 0n);
assertTrue(BigInt("-0") == -0);
assertTrue(-0n == -0);
assertTrue(-0n == 0n);
assertTrue(BigInt("-0 ") > -1);
assertTrue("-0 " > -1n);
assertTrue(BigInt("-0") > -1);
assertTrue(-0n > -1);
assertEquals(BigInt("-0 ") & 1n, 0n);
assertEquals(BigInt("-0") & 1n, 0n);
assertEquals(-0n & 1n, 0n);
var zero = BigInt("-0 ");
assertEquals(1n, ++zero);
zero = BigInt("-0");
assertEquals(1n, ++zero);
zero = -0n;
assertEquals(1n, ++zero);

17
deps/v8/test/mjsunit/harmony/bigint/regress-tonumbercode.js vendored Normal file
View File

@ -0,0 +1,17 @@
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
function f(x, b) {
if (b) return Math.trunc(+(x))
else return Math.trunc(Number(x))
}
%PrepareFunctionForOptimization(f);
f("1", true);
f("2", true);
f("2", false);
%OptimizeFunctionOnNextCall(f);
f(3n);

32
deps/v8/test/mjsunit/harmony/bigint/regress-tostring-2.js vendored Normal file
View File

@ -0,0 +1,32 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Specific regression test for crbug.com/1236694.
let long = '1000000000000000000000000000000000000000000000'.repeat(20) + '0';
let short = '100000000000000000000000000000000000000000000'.repeat(20) + '0';
BigInt(long).toLocaleString();
BigInt(short).toLocaleString();
// Generalized to test a range of similar inputs. Considerations to keep
// execution times reasonable while testing interesting cases:
// - The number of zeros should grow large enough to potentially fill two
// entire digits (i.e. >= 38), which makes the recursion take the early
// termination path, which is worthy of test coverage.
// - The number of repeats should grow large enough to shift any bug-triggering
// bit pattern to any position in a digit, i.e. >= 64.
// - Fewer repeats may be easier to debug in case of failure, but likely don't
// provide additional test coverage, so we test very few distinct values.
// - To test the fast algorithm, (zeros+1)*repeats must be >= 810 or so.
function test(zeros, repeats) {
let chunk = '1' + '0'.repeat(zeros);
let input = chunk.repeat(repeats);
assertEquals(input, BigInt(input).toString(),
`bug for ${zeros} zeros repeated ${repeats} times`);
}
for (let zeros = 1; zeros < 50; zeros++) {
for (let repeats = 64; repeats > 0; repeats -= 20) {
test(zeros, repeats);
}
}
test(96, 11); // Found to hit the extra-early recursion termination path.

8
deps/v8/test/mjsunit/harmony/bigint/regress-tostring.js vendored Normal file
View File

@ -0,0 +1,8 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Regression test for crbug.com/1232733
let big = 10n ** 900n;
let expected = "1" + "0".repeat(900);
assertEquals(expected, big.toString());

39
deps/v8/test/mjsunit/harmony/bigint/regressions.js vendored Normal file
View File

@ -0,0 +1,39 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var a = 5n;
var b = a / -1n;
assertEquals(5n, a);
assertEquals(-5n, b);
assertEquals(5n, 5n / 1n);
assertEquals(5n, -5n / -1n);
assertEquals(-5n, -5n / 1n);
assertEquals(0n, 5n % 1n);
assertEquals(0n, -5n % 1n);
assertEquals(0n, 5n % -1n);
assertEquals(0n, -5n % -1n);
assertTrue(0n === 0n);
// crbug.com/818277: Must throw without DCHECK failures.
// In order to run acceptably fast in Debug mode, this test assumes that
// we allow at least 1 billion bits in a BigInt.
var close_to_limit = 2n ** 1000000000n;
assertThrows(() => close_to_limit ** 100n, RangeError);
// Check boundary conditions of the power-of-two fast path.
// The following "max" constants are just under BigInt::kMaxLengthBits
// and replicate the computation of that constant.
var kMaxInt = 2n ** 31n - 1n;
var max64 = kMaxInt - 64n - 2n;
var max32 = kMaxInt - 32n - 2n;
// Platform independence trick: at least one of the two operations will throw!
assertThrows(() => { var a = 2n ** max32; var b = 2n ** max64; }, RangeError);
(function() {
function Constructor() { }
Constructor.prototype = 5n;
assertThrows(() => ({}) instanceof Constructor, TypeError);
})();

28
deps/v8/test/mjsunit/harmony/bigint/rematerialize-on-deopt.js vendored Normal file
View File

@ -0,0 +1,28 @@
// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax --turbofan
{
function test(a, b, c) {
let x = BigInt.asUintN(64, a + b);
console.log(x);
try {
return BigInt.asUintN(64, x + c);
} catch(_) {
return x;
}
}
%PrepareFunctionForOptimization(test);
test(3n, 4n, 5n);
test(6n, 7n, 8n);
test(9n, 2n, 1n);
%OptimizeFunctionOnNextCall(test);
test(1n, 2n, 3n);
test(3n, 2n, 1n);
assertEquals(6n, test(1n, 3n, 2n));
assertEquals(5n, test(2n, 3n, 2));
}

105
deps/v8/test/mjsunit/harmony/bigint/sar.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0x211a34fn,
b: 0xa6n,
r: 0n
}, {
a: 0xa0d0aff5d2783ad192f37423n,
b: 0x7n,
r: 0x141a15feba4f075a325e6e8n
}, {
a: -0x68ba010a12ed551fc17c67f63331eea3n,
b: 0xae5n,
r: -0x1n
}, {
a: 0xb64dc8009n,
b: 0xf1n,
r: 0n
}, {
a: -0x364cdec628e438712e4f8cb7an,
b: 0x48cn,
r: -0x1n
}, {
a: -0xb417099aba80a783f52790b779b38c2e6fbdf5f490d7b02a59e81032een,
b: 0x6a3n,
r: -0x1n
}, {
a: 0x9d2b41n,
b: 0n,
r: 0x9d2b41n
}, {
a: -0x4a070c83b02ba86434228a50cbaf50ddf38n,
b: -0x63n,
r: -0x25038641d815d4321a11452865d7a86ef9c0000000000000000000000000n
}, {
a: 0x3e76514036ccb958c98f60n,
b: -0x76n,
r: 0xf9d94500db32e563263d8000000000000000000000000000000n
}, {
a: -0x51fe20d47ba564bc09337d5c8d284deb5006549bad2629230198f34n,
b: -0xfn,
r: -0x28ff106a3dd2b25e0499beae469426f5a8032a4dd693149180cc79a0000n
}, {
a: 0x49adce1d09dadc5a0635f24d066d3a29e37b9be6059b88d0239d6ca6d92267a372n,
b: -0x6n,
r: 0x126b73874276b716818d7c93419b4e8a78dee6f98166e23408e75b29b64899e8dc80n
}, {
a: 0xca19971406fb07cn,
b: -0x17n,
r: 0x650ccb8a037d83e000000n
}, {
a: 0xd8de8f631313b1f98f77d265ee48014f82eb20n,
b: 0xen,
r: 0x3637a3d8c4c4ec7e63ddf4997b920053e0bn
}, {
a: -0x550d3470c8ad9b8f22ed01a4b1d3f648n,
b: -0x4dn,
r: -0xaa1a68e1915b371e45da034963a7ec900000000000000000000n
}, {
a: -0xa7eadcd4a1b8037081952f0a9199n,
b: -0xcfn,
r: -0x53f56e6a50dc01b840ca978548cc8000000000000000000000000000000000000000000000000000n
}, {
a: -0x65b3933c9e1eb5f953f6cc55cn,
b: 0xa6cn,
r: -0x1n
}, {
a: -0x92cea858475460661a2831a28434bde95e5132e1dcaeb161ec89bd9555f41n,
b: -0xbn,
r: -0x4967542c23aa30330d1418d1421a5ef4af289970ee5758b0f644decaaafa0800n
}, {
a: -0x1d838ade17fe571916a26314b6a8b42e9b6e2b74238de734d6f5575df7n,
b: -0x7n,
r: -0xec1c56f0bff2b8c8b51318a5b545a174db715ba11c6f39a6b7aabaefb80n
}, {
a: 0xdd5bf8581e32875d44e26ef10c45bdff68d209015933586dc37211n,
b: -0xa9n,
r: 0x1bab7f0b03c650eba89c4dde2188b7bfed1a41202b266b0db86e422000000000000000000000000000000000000000000n
}, {
a: -0xa92d3014dcn,
b: -0x4cn,
r: -0xa92d3014dc0000000000000000000n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a >> d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: >>");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

105
deps/v8/test/mjsunit/harmony/bigint/shl.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: -0xe813d76adc0a177778c0c232c595e8572b783210f4a7009d7c1787n,
b: 0x9en,
r: -0x3a04f5dab70285ddde30308cb1657a15cade0c843d29c0275f05e1c000000000000000000000000000000000000000n
}, {
a: -0xded00dff14554cn,
b: 0xd9n,
r: -0x1bda01bfe28aa98000000000000000000000000000000000000000000000000000000n
}, {
a: -0x50c2df089209be37998c8f6e30c4c95a61e77a9241n,
b: 0x46n,
r: -0x1430b7c224826f8de66323db8c3132569879dea490400000000000000000n
}, {
a: 0x668086293eab52b52b879f00375d0f513f1ff9a93df788e38527en,
b: -0x3n,
r: 0xcd010c527d56a56a570f3e006eba1ea27e3ff3527bef11c70a4fn
}, {
a: 0n,
b: -0x1n,
r: 0n
}, {
a: 0x26bd28fb3e06bb0ddan,
b: -0xcn,
r: 0x26bd28fb3e06bb0n
}, {
a: -0xa04dca5c74bdb1dbf2f0n,
b: -0x3fn,
r: -0x1409cn
}, {
a: -0xd6b46ec3ead311e2e45ca4ae8aa9cf5acf4c2d6c61de06e9e36n,
b: -0xan,
r: -0x35ad1bb0fab4c478b917292ba2aa73d6b3d30b5b187781ba8n
}, {
a: -0x1f1922aen,
b: -0xbfn,
r: -0x1n
}, {
a: 0x47n,
b: -0x2n,
r: 0x11n
}, {
a: -0xf64n,
b: 0x7en,
r: -0x3d900000000000000000000000000000000n
}, {
a: -0x78dn,
b: -0x85en,
r: -0x1n
}, {
a: -0xa03bc462b00e4113a2472eb73dn,
b: 0n,
r: -0xa03bc462b00e4113a2472eb73dn
}, {
a: 0x3816aa0f01396f4abe0ee7164e211ce60ce590b615d86f6e6363c0bdd513d8a0n,
b: 0x4n,
r: 0x3816aa0f01396f4abe0ee7164e211ce60ce590b615d86f6e6363c0bdd513d8a00n
}, {
a: -0xaf8711d29fdecd42a255f14aafe13b9404cced5df0af8b86080af7682cben,
b: 0x1n,
r: -0x15f0e23a53fbd9a8544abe2955fc277280999dabbe15f170c1015eed0597cn
}, {
a: 0x218b11dfn,
b: 0n,
r: 0x218b11dfn
}, {
a: 0x263fcb4707e6fd4a21b1f646ddd90a5e78d781c272621dcaf861d6250d7be675e067n,
b: -0x868n,
r: 0n
}, {
a: 0x8312b459b585847682en,
b: 0x4en,
r: 0x20c4ad166d61611da0b80000000000000000000n
}, {
a: 0xb45d42e0595a4b104b0b9a177ffdc52b401b61659fe163e720621aef8c8e6191ba7an,
b: 0x3n,
r: 0x5a2ea1702cad25882585cd0bbffee295a00db0b2cff0b1f390310d77c64730c8dd3d0n
}, {
a: -0x42d2c4n,
b: 0xfdn,
r: -0x85a588000000000000000000000000000000000000000000000000000000000000000n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a << d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: <<");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

105
deps/v8/test/mjsunit/harmony/bigint/sub.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: 0xc4fd438551d58edn,
b: 0x91b42ee55a50d974an,
r: -0x90ef31a1d4ff03e5dn
}, {
a: -0x86b766ec276e390087458ce093b07b2574732d5f3f5125n,
b: 0x4b1fe0dd23316de1b38b343d4112fbd7e8c8d081de5dbabda7357fd9e868466693den,
r: -0x4b1fe0dd23316de1b38b34c3f879e7ff5701d10923ea9b5157b0a54e5b95a5a5e503n
}, {
a: 0x63e1eac0d5470c8f802ec390b6415c43ed16d28d6dn,
b: -0xbe26927b2f6ae85b5d3062d869d22da005805d23142a236955127b6ca688c07fn,
r: 0xbe26927b2f6ae85b5d30633c4bbcee754c8ceca342edb41f966ebf59bd5b4decn
}, {
a: -0x873cf988993d97e5180fn,
b: -0xd791aa365f881a7f05f21f73ef390c0b37408dd0a908801682464178426an,
r: 0xd791aa365f881a7f05f21f73ef390c0b37408dd021cb868de908a9932a5bn
}, {
a: -0xcb273d5b123eff101c62f016ae2896223b93b9114e40d1fn,
b: 0x2169f8c954623f8381bf12fd0927e1a645f5b3c6c00e58105c297ba40446208dn,
r: -0x2169f8c954623f838e7186d2ba4bd19747bbe2c82af0e1727fe2b735192a2dacn
}, {
a: -0xe965bf745fffcf22n,
b: 0x7c3b92f8a030cbfca7cc5f2fd454459c79a3ac2201524468fbn,
r: -0x7c3b92f8a030cbfca7cc5f2fd454459c7a8d11e175b244381dn
}, {
a: 0n,
b: 0x6975a8ededffd265f472e660e18n,
r: -0x6975a8ededffd265f472e660e18n
}, {
a: -0x236bda1a3a9635190f26c3739b7342f33a27cd2568n,
b: 0x1a7e6n,
r: -0x236bda1a3a9635190f26c3739b7342f33a27cecd4en
}, {
a: 0xb682b9c88f0b6d7b5e9a4f77dd0d7885d62cd162783b2e55b30b954e10caf3n,
b: 0x2c6574161d9aff7bbebd95e561fbd5d70d893e8c9772bcc697cddn,
r: 0xb682b9c88c451639fcc09f8021219f27800d140507629a6ce9946981a74e16n
}, {
a: 0xdd6aa5240c4n,
b: 0xb9c7bef20c0cc0f814cce3c40d43e4c26en,
r: -0xb9c7bef20c0cc0f814cce3b636999281aan
}, {
a: 0x35cd14329d5f81dbn,
b: 0x25997b1f3500f9b27f2ceean,
r: -0x25997b1bd82fb688a934d0fn
}, {
a: -0x55ec15d7ed316df3fc7bcfcce0f0a6d7034113bad6d74bae88d4aab03032n,
b: 0x9d09b8869aab44d6690fad48c8dffd0e18cc21fb26c2a80ac08fd4f42296f46d37cddn,
r: -0x9d09b886a00a0633e7e2c42808a7ba0ae6db2c6896f6b9466dfd49af0b243f183ad0fn
}, {
a: 0n,
b: -0xfbf3b308a6066d497e1cn,
r: 0xfbf3b308a6066d497e1cn
}, {
a: 0x6acfc1e4b681be9582cd28453387ed2c29f5eb4cd6d78aaac67n,
b: -0x4f5997n,
r: 0x6acfc1e4b681be9582cd28453387ed2c29f5eb4cd6d78fa05fen
}, {
a: -0xc93eb5cae0c90eb77e702ccb44eea6180829d0b360872n,
b: 0xdn,
r: -0xc93eb5cae0c90eb77e702ccb44eea6180829d0b36087fn
}, {
a: -0x324ef140a16c5c20a9a189a720136f4836ea98056n,
b: 0x49471582a658bf5524128e130b3378d29331baa8eb8n,
r: -0x49796473e6fa2bb144bc2f9cb2538c41db68a540f0en
}, {
a: 0x6f15ac8490de4e308286fdde1142ad0052c2cn,
b: 0x9ca6c715de18d7f64a751452e967b5807eec951777245ce5fe3n,
r: -0x9ca6c715de18d78734c88fc20b1984fdf7eeb70634775c933b7n
}, {
a: -0xc303adn,
b: 0x5ec0a706a54978a59b10007942e563957ad22e708678fbfdb02862b2c3n,
r: -0x5ec0a706a54978a59b10007942e563957ad22e708678fbfdb02925b670n
}, {
a: -0xdb736b5f3979c24f70aafa5f17711d725d552a9778e1n,
b: 0x70b56a0773498a45b796cf79ea18211614cn,
r: -0xdb736b5f408518efe7df930372ea8a69fbf6aca8da2dn
}, {
a: 0xe91b9a797168c6b7440f946n,
b: -0x2588c1301521dd9646a2e22e3aca462ca95e76069be2f7b95d8bb81ccn,
r: 0x2588c1301521dd9646a2e22e3aca462caa4791a11554608014cfc7b12n
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a - d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: -");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}

50
deps/v8/test/mjsunit/harmony/bigint/tonumber.js vendored Normal file
View File

@ -0,0 +1,50 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
function Check(bigint, number_string) {
var number = Number(bigint);
if (number_string.substring(0, 2) === "0x") {
assertEquals(number_string.substring(2), number.toString(16));
} else {
assertEquals(number_string, number.toString());
}
}
// Values in Smi range.
Check(0n, "0");
Check(1n, "1");
Check(-1n, "-1");
// Values in double range.
Check(12345678912n, "12345678912");
Check(-12345678912345n, "-12345678912345");
Check(0xfffffffffffffn, "0xfffffffffffff"); // 52 bits.
Check(0x1fffffffffffffn, "0x1fffffffffffff"); // 53 bits.
Check(0x3fffffffffffffn, "0x40000000000000"); // 54 bits, rounding up.
Check(0x3ffffffffffffen, "0x3ffffffffffffe"); // 54 bits, rounding down.
Check(0x7ffffffffffffdn, "0x7ffffffffffffc"); // 55 bits, rounding down.
Check(0x7ffffffffffffen, "0x80000000000000"); // 55 bits, tie to even.
Check(0x7fffffffffffffn, "0x80000000000000"); // 55 bits, rounding up.
Check(0x1ffff0000ffff0000n, "0x1ffff0000ffff0000"); // 65 bits.
Check(100000000000000008192n, "100000000000000000000"); // Tie to even.
// Check the cornercase where the most significant cut-off bit is 1.
// If a digit beyond the mantissa is non-zero, we must round up;
// otherwise tie to even.
// ...digit2 ][ digit1 ][ digit0 ]
// [ mantissa ]
Check(0x01000000000000080000000000000000001000n,
"0x1000000000000100000000000000000000000");
Check(0x01000000000000080000000000000000000000n,
"0x1000000000000000000000000000000000000");
Check(0x01000000000000180000000000000000000000n,
"0x1000000000000200000000000000000000000");
// Values near infinity.
Check(1n << 1024n, "Infinity");
Check(-1n << 1024n, "-Infinity");
Check(1n << 1023n, "8.98846567431158e+307");
Check((1n << 1024n) - (1n << 972n), "1.7976931348623155e+308");
Check((1n << 1024n) - (1n << 971n), "1.7976931348623157e+308");
Check((1n << 1024n) - (1n << 970n), "Infinity"); // Rounding up overflows.

17
deps/v8/test/mjsunit/harmony/bigint/tostring-toolong.js vendored Normal file
View File

@ -0,0 +1,17 @@
// Copyright 2021 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
const kLongString = 100_000; // Bigger than kMaxRenderedLength in bigint.cc.
const str = 'z'.repeat(kLongString);
try {
BigInt(str);
assertUnreachable("should have thrown");
} catch (e) {
assertTrue(e instanceof SyntaxError);
assertTrue(e.message.startsWith("Cannot convert zzz"));
// Despite adding "Cannot convert", the overall message is shorter than
// the invalid string, because it only includes a prefix of the string.
assertTrue(e.message.length < kLongString);
}

199
deps/v8/test/mjsunit/harmony/bigint/turbo.js vendored Normal file
View File

@ -0,0 +1,199 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
'use strict'
function test(f, {input, check}) {
let result;
try {
result = { value: f(input), exception: false }
} catch(e) {
result = { value: e, exception: true }
}
check(result);
}
function Test(f, ...cases) {
for (let i = 0; i < cases.length; ++i) {
%PrepareFunctionForOptimization(f);
test(f, cases[i]);
%OptimizeFunctionOnNextCall(f);
for (let j = 0; j < cases.length; ++j) {
test(f, cases[j]);
}
%DeoptimizeFunction(f);
}
}
function V(input, expected_value) {
function check(result) {
assertFalse(result.exception, `unexpected exception ${result.value} on input ${input}`);
assertEquals(expected_value, result.value);
}
return {input, check};
}
function E(input, expected_exception) {
function check(result) {
assertTrue(result.exception, `expected exception ${expected_exception.name} on input ${input}`);
assertInstanceof(result.value, expected_exception);
}
return {input, check};
}
const six = {[Symbol.toPrimitive]() {return 6n}};
////////////////////////////////////////////////////////////////////////////////
// The first argument to {Test} is the function to test. The other arguments are
// the test cases, basically pairs of input and expected output. {Test} runs the
// function first unoptimized on one of the inputs, and then optimized on all
// inputs.
////////////////////////////////////////////////////////////////////////////////
Test(x => Number(x),
V(1n, 1), V(1, 1), V("", 0), V(1.4, 1.4), V(null, 0), V(six, 6));
Test(x => Math.trunc(+x),
E(1n, TypeError), V(1, 1), V("", 0), V(1.4, 1), V(null, 0), E(six, TypeError));
Test(x => Math.trunc(Number(x)),
V(1n, 1), V(1, 1), V("", 0), V(1.4, 1), V(null, 0), V(six, 6));
Test(x => String(x),
V(1n, "1"), V(1, "1"), V(1.4, "1.4"), V(null, "null"), V(six, "6"));
Test(x => BigInt(x),
V(true, 1n), V(false, 0n), V(42n, 42n), E(NaN, RangeError), V(six, 6n));
Test(x => typeof x,
V(1n, "bigint"), V(1, "number"), V(six, "object"));
Test(x => typeof x == "bigint",
V(1n, true), V(1, false), V(six, false));
Test(x => !x,
V(0n, true), V(42n, false), V(0x10000000000000000n, false), V(1, false),
V(undefined, true), V(six, false));
Test(x => !!x,
V(0n, false), V(42n, true), V(0x10000000000000000n, true), V(1, true),
V(undefined, false), V(six, true));
Test(x => +x,
E(-3n, TypeError), V(-4, -4), V(1.4, 1.4), V(null, 0), V("5", 5),
E(six, TypeError));
Test(x => -x,
V(-3n, 3n), V(-4, 4), V(1.4, -1.4), V(null, -0), V("5", -5), V(six, -6n));
Test(x => ~x,
V(-3n, 2n), V(-4, 3), V(1.5, -2), V(null, -1), V("5", -6), V(six, -7n));
Test(x => ++x,
V(-3n, -2n), V(-4, -3), V(1.5, 2.5), V(null, 1), V("5", 6), V(six, 7n));
Test(x => --x,
V(-3n, -4n), V(-4, -5), V(1.5, 0.5), V(null, -1), V("5", 4), V(six, 5n));
Test(x => x++,
V(-3n, -3n), V(-4, -4), V(1.5, 1.5), V(null, 0), V("5", 5), V(six, 6n));
Test(x => x--,
V(-3n, -3n), V(-4, -4), V(1.5, 1.5), V(null, 0), V("5", 5), V(six, 6n));
Test(x => x + 42,
E(1n, TypeError), V(2, 44), V(null, 42), V("a", "a42"), E(six, TypeError));
Test(x => x + 42n,
V(1n, 43n), E(2, TypeError), E(null, TypeError), V("a", "a42"), V(six,48n));
Test(x => x - 4,
E(1n, TypeError), V(3, -1), V(null, -4), V("a", NaN), E(six, TypeError));
Test(x => x - 4n,
V(1n, -3n), E(3, TypeError), E(null, TypeError), E("a", TypeError),
V(six, 2n));
Test(x => x * 42,
E(2n, TypeError), V(3, 126), V("a", NaN), V(null, 0), E(six, TypeError));
Test(x => x * 42n,
V(2n, 84n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 252n));
Test(x => x / 2,
E(2n, TypeError), V(6, 3), V("a", NaN), V(null, 0), E(six, TypeError));
Test(x => x / 2n,
V(2n, 1n), E(6, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 3n));
Test(x => x % 2,
E(2n, TypeError), V(3, 1), V("a", NaN), V(null, 0), E(six, TypeError));
Test(x => x % 2n,
V(2n, 0n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 0n));
Test(x => x | 5,
E(2n, TypeError), V(3, 7), V("a", 5), V(null, 5), E(six, TypeError));
Test(x => x | 5n,
V(2n, 7n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 7n));
Test(x => x & 5,
E(2n, TypeError), V(3, 1), V("a", 0), V(null, 0), E(six, TypeError));
Test(x => x & 5n,
V(2n, 0n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 4n));
Test(x => x ^ 5,
E(2n, TypeError), V(3, 6), V("a", 5), V(null, 5), E(six, TypeError));
Test(x => x ^ 5n,
V(2n, 7n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 3n));
Test(x => x << 3,
E(2n, TypeError), V(3, 24), V("a", 0), V(null, 0), E(six, TypeError));
Test(x => x << 3n,
V(2n, 16n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 48n));
Test(x => x >> 1,
E(2n, TypeError), V(3, 1), V("a", 0), V(null, 0), E(six, TypeError));
Test(x => x >> 1n,
V(2n, 1n), E(3, TypeError), E("a", TypeError), E(null, TypeError),
V(six, 3n));
Test(x => x >>> 1,
E(2n, TypeError), V(3, 1), V("a", 0), V(null, 0), E(six, TypeError));
Test(x => x >>> 1n,
E(2n, TypeError), E(3, TypeError), E("a", TypeError), E(null, TypeError),
E(six, TypeError));
Test(x => x === 42,
V(1n, false), V(2, false), V(null, false), V("a", false), V(six, false));
Test(x => x === 42,
V(42n, false), V(42, true), V(null, false), V("42", false), V(six, false));
Test(x => x === 42n,
V(1n, false), V(2, false), V(null, false), V("a", false), V(six, false));
Test(x => x === 42n,
V(42n, true), V(42, false), V(null, false), V("42", false), V(six, false));
Test(x => x == 42,
V(1n, false), V(2, false), V(null, false), V("a", false), V(six, false));
Test(x => x == 42,
V(42n, true), V(42, true), V(null, false), V("42", true), V(six, false));
Test(x => x == 42n,
V(1n, false), V(2, false), V(null, false), V("a", false), V(six, false));
Test(x => x == 42n,
V(42n, true), V(42, true), V(null, false), V("42", true), V(six, false));
Test(x => x < 42,
V(1n, true), V(2, true), V(null, true), V("41", true), V(six, true));
Test(x => x < 42,
V(42n, false), V(42, false), V(null, true), V("42", false), V(six, true));
Test(x => x < 42n,
V(1n, true), V(2, true), V(null, true), V("41", true), V(six, true));
Test(x => x < 42n,
V(42n, false), V(42, false), V(null, true), V("42", false), V(six, true));

241
deps/v8/test/mjsunit/harmony/bigint/typedarray.js vendored Normal file
View File

@ -0,0 +1,241 @@
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
var intarray = new BigInt64Array(8);
var uintarray = new BigUint64Array(8);
function test(f) {
%PrepareFunctionForOptimization(f);
f();
f(); // Make sure we test ICs.
f();
%OptimizeFunctionOnNextCall(f);
f();
}
function test_both(f) {
test(() => f(BigInt64Array));
test(() => f(BigUint64Array));
}
test(function basic_assignment() {
const x = 0x1234567890abcdefn;
intarray[0] = x;
assertEquals(x, intarray[0]);
uintarray[0] = x;
assertEquals(x, uintarray[0]);
const y = -0x76543210fedcba98n;
intarray[0] = y;
assertEquals(y, intarray[0]);
});
test(function construct() {
var a = new BigInt64Array([1n, -2n, {valueOf: () => 3n}]);
assertArrayEquals([1n, -2n, 3n], a);
assertThrows(() => new BigInt64Array([4, 5]), TypeError);
var b = new BigUint64Array([6n, -7n]);
assertArrayEquals([6n, 0xfffffffffffffff9n], b);
var c = new BigUint64Array(new BigInt64Array([8n, -9n]));
assertArrayEquals([8n, 0xfffffffffffffff7n], c);
var d = new BigInt64Array(new BigUint64Array([10n, 0xfffffffffffffff5n]));
assertArrayEquals([10n, -11n], d);
assertThrows(() => new BigInt64Array(new Int32Array([12, 13])), TypeError);
assertThrows(() => new Int32Array(new BigInt64Array([14n, -15n])), TypeError);
});
test_both(function copyWithin(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
a.copyWithin(0, 1, 3);
assertArrayEquals([2n, 3n, 3n], a);
});
test_both(function entries(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var it = a.entries();
assertEquals([0, 1n], it.next().value);
assertEquals([1, 2n], it.next().value);
assertEquals([2, 3n], it.next().value);
assertTrue(it.next().done);
});
test_both(function every(BigArray) {
var a = BigArray.of(2n, 3n, 4n);
var seen = [];
assertTrue(a.every((x) => {seen.push(x); return x > 1n}));
assertEquals([2n, 3n, 4n], seen);
});
test_both(function fill(BigArray) {
var a = BigArray.of(1n, 2n, 3n, 4n);
a.fill(7n, 1, 3);
assertArrayEquals([1n, 7n, 7n, 4n], a);
assertThrows(() => (new BigArray(3).fill(1)), TypeError);
});
test_both(function filter(BigArray) {
var a = BigArray.of(1n, 3n, 4n, 2n);
var b = a.filter((x) => x > 2n);
assertArrayEquals([3n, 4n], b);
});
test_both(function find(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals(2n, a.find((x) => x === 2n));
assertEquals(undefined, a.find((x) => x === 2));
});
test_both(function findIndex(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals(1, a.findIndex((x) => x === 2n));
assertEquals(-1, a.findIndex((x) => x === 2));
});
test_both(function forEach(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var seen = [];
a.forEach((x) => seen.push(x));
assertEquals([1n, 2n, 3n], seen);
});
test_both(function from(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var b = BigArray.from(a);
assertArrayEquals([1n, 2n, 3n], b);
assertThrows(() => BigArray.from([4, 5]), TypeError);
var c = BigArray.from([6, 7], BigInt);
assertArrayEquals([6n, 7n], c);
assertThrows(() => Int32Array.from([4n, 5n]), TypeError);
assertThrows(() => Int32Array.from([4, 5], BigInt), TypeError);
});
test(function from_mixed() {
var contents = [1n, 2n, 3n];
var a = new BigInt64Array(contents);
var b = BigUint64Array.from(a);
assertArrayEquals(contents, b);
var c = BigInt64Array.from(b);
assertArrayEquals(contents, c);
});
test_both(function includes(BigArray) {
var a = BigArray.of(0n, 1n, 2n);
assertTrue(a.includes(1n));
assertFalse(a.includes(undefined));
assertFalse(a.includes(1));
assertFalse(a.includes(0x1234567890abcdef123n)); // More than 64 bits.
});
test_both(function indexOf(BigArray) {
var a = BigArray.of(0n, 1n, 2n);
assertEquals(1, a.indexOf(1n));
assertEquals(-1, a.indexOf(undefined));
assertEquals(-1, a.indexOf(1));
assertEquals(-1, a.indexOf(0x1234567890abcdef123n)); // More than 64 bits.
});
test_both(function join(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals("1-2-3", a.join("-"));
});
test_both(function keys(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var it = a.keys();
assertEquals(0, it.next().value);
assertEquals(1, it.next().value);
assertEquals(2, it.next().value);
assertTrue(it.next().done);
});
test_both(function lastIndexOf(BigArray) {
var a = BigArray.of(0n, 1n, 2n);
assertEquals(1, a.lastIndexOf(1n));
assertEquals(-1, a.lastIndexOf(undefined));
assertEquals(-1, a.lastIndexOf(1));
assertEquals(-1, a.lastIndexOf(0x1234567890abcdef123n)); // > 64 bits.
});
test_both(function map(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var b = a.map((x) => 2n * x);
assertEquals(BigArray, b.constructor);
assertArrayEquals([2n, 4n, 6n], b);
});
test_both(function of(BigArray) {
var a = BigArray.of(true, 2n, {valueOf: () => 3n}, "4");
assertArrayEquals([1n, 2n, 3n, 4n], a);
assertThrows(() => BigArray.of(1), TypeError)
assertThrows(() => BigArray.of(undefined), TypeError)
});
test_both(function reduce(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals(6n, a.reduce((sum, x) => sum + x, 0n));
});
test_both(function reduceRight(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals(6n, a.reduce((sum, x) => sum + x, 0n));
});
test_both(function reverse(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
a.reverse();
assertArrayEquals([3n, 2n, 1n], a);
});
test_both(function set(BigArray) {
var a = new BigArray(7);
a.set(BigArray.of(1n, 2n, 3n), 2);
assertArrayEquals([0n, 0n, 1n, 2n, 3n, 0n, 0n], a);
a.set([4n, 5n, 6n], 1);
assertArrayEquals([0n, 4n, 5n, 6n, 3n, 0n, 0n], a);
assertThrows(() => a.set([7, 8, 9], 3), TypeError);
assertThrows(() => a.set(Int32Array.of(10, 11), 2), TypeError);
var Other = BigArray == BigInt64Array ? BigUint64Array : BigInt64Array;
a.set(Other.of(12n, 13n), 4);
assertArrayEquals([0n, 4n, 5n, 6n, 12n, 13n, 0n], a);
});
test_both(function slice(BigArray) {
var a = BigArray.of(1n, 2n, 3n, 4n);
var b = a.slice(1, 3);
assertArrayEquals([2n, 3n], b);
});
test_both(function some(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertTrue(a.some((x) => x === 2n));
});
test_both(function sort(BigArray) {
var a = BigArray.of(7n, 2n, 5n, 3n);
a.sort();
assertArrayEquals([2n, 3n, 5n, 7n], a);
});
test_both(function subarray(BigArray) {
var a = BigArray.of(1n, 2n, 3n, 4n);
var b = a.subarray(1, 3);
assertEquals(BigArray, b.constructor);
assertArrayEquals([2n, 3n], b);
});
test_both(function toString(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
assertEquals("1,2,3", a.toString());
});
test_both(function values(BigArray) {
var a = BigArray.of(1n, 2n, 3n);
var it = a.values();
assertEquals(1n, it.next().value);
assertEquals(2n, it.next().value);
assertEquals(3n, it.next().value);
assertTrue(it.next().done);
});

105
deps/v8/test/mjsunit/harmony/bigint/xor.js vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Generated by tools/bigint-tester.py.
var data = [{
a: -0x46505bec40d461c595b5e4be178b7d00n,
b: -0x9170e5437d4e3ec7c0971e2c6d3bbbd2929ff108ea4ee64f7a91aa367fn,
r: 0x9170e5437d4e3ec7c0971e2c6d7deb897edf25692fdb53abc486214a81n
}, {
a: -0x49171f24aa9660f7f854148018a8b03256200508n,
b: 0x75c2103e4e8e52d0311n,
r: -0x49171f24aa9660f7f85413dc39ab54dab30d0617n
}, {
a: -0x3cde31210d299e4f6734f76c4f2df3056fn,
b: -0x402b7fe66d16877867f43n,
r: 0x3cde31210d299a4dd0ca91bd275a757a2cn
}, {
a: 0x727n,
b: 0xe1c82371da63bdb801273077095be8977ff9f14aa619829bf4b418n,
r: 0xe1c82371da63bdb801273077095be8977ff9f14aa619829bf4b33fn
}, {
a: 0x7c2b1e0918a85bf5faea9077b7dn,
b: -0xed714ba58fd54b19n,
r: -0x7c2b1e0918a68ce140b26d23066n
}, {
a: 0x1dded5fd695f4babcan,
b: 0x7e1cb4346c68e84f8fbdd3501daead2ce99a90e56038n,
r: 0x7e1cb4346c68e84f8fbdd3501db373f914f3cfaecbf2n
}, {
a: 0xec7d9595de759652a3bb96c80edca63790c32ce7f6cf0ef0n,
b: -0x67f0feef424f56d6ae6856a20901199de53ebn,
r: -0xec7d9595de73e95d4d4fb23d63b640b2fae3bcf66f115d1bn
}, {
a: 0x69ab204291f752866c3d49fdf1d656298f43e896cea3ef31a04n,
b: -0x5f5b2fd130e33ed76fa22de5ac70bdf96dee80a09e3107e1c93a135ea80b7e3640cdn,
r: -0x5f5b2fd130e33ed769389fe1856fc8d10b2d543f412c628351ce2dd7c4e140c55ac9n
}, {
a: -0xd396d40076en,
b: 0x3158623c80393n,
r: -0x318bf4e8804ffn
}, {
a: 0x8c1dbfbd68007d171986777446303896a1ee46n,
b: -0x75fd69710f5bea1cece9d59ec4bca29712b49dcf5ee5cc3299d7fb4fb024f10ae955fn,
r: -0x75fd69710f5bea1cece9d59ec4bca29fd36f6619dee21d4301b08c0bd3277860f7b19n
}, {
a: -0x4c6e3ccbabdd6f58450ec3ec8adfb10831b70893cb996f0ac97a0ae2f3a943185d1n,
b: 0xeb136731a19867949d46886e62050c4b446767a076c73dn,
r: -0x4c6e3ccbabdd6f58450ecd5dbcacab11b7ce4147a31f892a99bebea485d344742een
}, {
a: 0xeaff60e10ebb4b8f2da6a517n,
b: -0x17af62a3e808af1be3d864132dfd7363bc95872580585d7a9904n,
r: -0x17af62a3e808af1be3d864132dfd999cdc74899ecbd770dc3c15n
}, {
a: -0xd4424b4f09210108076d63bd621180f280df8f4480n,
b: -0x20953185dd2c534b3cb8da73ce55ab386d62fe8a793a1e74cdf3ad95f3cc2573b3n,
r: 0x20953185dd2c534b3cb8da731a17e0776443ff827e577dc9afe22d677313aa37cdn
}, {
a: 0x84317d7ec6df6dbfe9413cee812ff95c587f61c7b8de5828d445a69555cff26fba9n,
b: -0x853c667aed62685df5993748e5668802b7bf918f8c1222a5267c33f013ff1e10f1b909n,
r: -0x8534256d3a8e05ab2e67a35b2b8e9afd227a16799069af40a4f177aa7aaa42efd742a2n
}, {
a: -0xe3b4bf724b172b23c5834ed6f70f984ab3b146070770cbc3b86779db7n,
b: -0x68166de3a03d9efce30cb36e242db000c850c0d4f454594e23a1a7cn,
r: 0xe3dca91fa8b716bd39604265992bb5fab37916c7d3849f9af644d87cdn
}, {
a: -0x5358b8efb260b40e37cb5b45eb4e7864n,
b: -0x3e617e3967a5b3554ebf24f1e51a253dfc20a76ef01f02442fn,
r: 0x3e617e3967a5b3554eec7c490aa84589f2176c35b5f44c3c4dn
}, {
a: -0x702359917a8aceedc381n,
b: -0x714f08d9c29e9fc0044982eb2469707896265n,
r: 0x714f08d9c29e9fc0034bb77233c1dc964a1e4n
}, {
a: -0x455ac38dn,
b: -0x6152562bf5b6f785abec41e8625bccd3bf3067225733dan,
r: 0x6152562bf5b6f785abec41e8625bccd3bf3067670df055n
}, {
a: 0x47n,
b: 0xa3d30490286ddf5d4f4256n,
r: 0xa3d30490286ddf5d4f4211n
}, {
a: -0x530cc599859ccdbbb3c1dcb46248a4474c63323cc58a7891da79e0322b91c795ac57n,
b: 0x2d986083244cd488657c947a952ae15b23d90ebbc34daan,
r: -0x530cc599859ccdbbb3c1dc99fa28276300b7ba59b91e0204f098bb11f29f7c56e1fdn
}];
var error_count = 0;
for (var i = 0; i < data.length; i++) {
var d = data[i];
var r = d.a ^ d.b;
if (d.r !== r) {
print("Input A: " + d.a.toString(16));
print("Input B: " + d.b.toString(16));
print("Result: " + r.toString(16));
print("Expected: " + d.r);
print("Op: ^");
error_count++;
}
}
if (error_count !== 0) {
print("Finished with " + error_count + " errors.")
quit(1);
}