tests/corelib/big_integer_vm_test.dart - Issue 620943002: Add a bigint test with --no_intrinsify.

Unified Diff: tests/corelib/big_integer_vm_test.dart

Issue 620943002: Add a bigint test with --no_intrinsify. (Closed) Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: tests/corelib/big_integer_vm_test.dart

===================================================================

--- tests/corelib/big_integer_vm_test.dart (revision 40918)

+++ tests/corelib/big_integer_vm_test.dart (working copy)

@@ -1,1663 +0,0 @@

-// BSD-style license that can be found in the LICENSE file.

-// Testing Bigints.

-library big_integer_test;

-import "package:expect/expect.dart";

-foo() => 1234567890123456789;

-bar() => 12345678901234567890;

-testSmiOverflow() {

- var a = 1073741823;

- var b = 1073741822;

- Expect.equals(2147483645, a + b);

- a = -1000000000;

- b = 1000000001;

- Expect.equals(-2000000001, a - b);

- Expect.equals(-1000000001000000000, a * b);

-testBigintAdd() {

- // Bigint and Smi.

- var a = 12345678901234567890;

- var b = 2;

- Expect.equals(12345678901234567892, a + b);

- Expect.equals(12345678901234567892, b + a);

- // Bigint and Bigint.

- a = 10000000000000000001;

- Expect.equals(20000000000000000002, a + a);

- // Bigint and double.

- a = 100000000000000000000.0;

- b = 200000000000000000000;

- Expect.isTrue((a + b) is double);

- Expect.equals(300000000000000000000.0, a + b);

- Expect.isTrue((b + a) is double);

- Expect.equals(300000000000000000000.0, b + a);

-testBigintSub() {

- // Bigint and Smi.

- var a = 12345678901234567890;

- var b = 2;

- Expect.equals(12345678901234567888, a - b);

- Expect.equals(-12345678901234567888, b - a);

- // Bigint and Bigint.

- a = 10000000000000000001;

- Expect.equals(20000000000000000002, a + a);

- // Bigint and double.

- a = 100000000000000000000.0;

- b = 200000000000000000000;

- Expect.isTrue((a + b) is double);

- Expect.equals(-100000000000000000000.0, a - b);

- Expect.isTrue((b + a) is double);

- Expect.equals(100000000000000000000.0, b - a);

- Expect.equals(-1, 0xF00000000 - 0xF00000001);

-testBigintMul() {

- // Bigint and Smi.

- var a = 12345678901234567890;

- var b = 10;

- Expect.equals(123456789012345678900, a * b);

- Expect.equals(123456789012345678900, b * a);

- // Bigint and Bigint.

- a = 12345678901234567890;

- b = 10000000000000000;

- Expect.equals(123456789012345678900000000000000000, a * b);

- // Bigint and double.

- a = 2.0;

- b = 200000000000000000000;

- Expect.isTrue((a * b) is double);

- Expect.equals(400000000000000000000.0, a * b);

- Expect.isTrue((b * a) is double);

- Expect.equals(400000000000000000000.0, b * a);

-testBigintHugeMul() {

- var block = 32 * 256; // 32 bit digits with 8 bit 'carry'.

- var bits = block * 32; // plenty of blocks in longest column sum;

- var a = 1 << bits;

- var a1 = a - 1; // all 1's

- var p1 = a1 * a1;

- var p2 = a * a - a - a + 1;

- // Use isTrue instead of equals to avoid trying to print such big numbers.

- Expect.isTrue(p1 == p2, 'products do not match');

-testBigintTruncDiv() {

- var a = 12345678901234567890;

- var b = 10;

- // Bigint and Smi.

- Expect.equals(1234567890123456789, a ~/ b);

- Expect.equals(0, b ~/ a);

- Expect.equals(123456789, 123456789012345678 ~/ 1000000000);

- // Bigint and Bigint.

- a = 12345678901234567890;

- b = 10000000000000000;

- Expect.equals(1234, a ~/ b);

- // Bigint and double.

- a = 100000000000000000000.0;

- b = 200000000000000000000;

- Expect.equals(0, a ~/ b);

- Expect.equals(2, b ~/ a);

-testBigintDiv() {

- // Bigint and Smi.

- Expect.equals(1234567890123456789.1, 12345678901234567891 / 10);

- Expect.equals(0.000000001234, 1234 / 1000000000000);

- Expect.equals(12345678901234000000.0, 123456789012340000000 / 10);

- // Bigint and Bigint.

- var a = 12345670000000000000;

- var b = 10000000000000000;

- Expect.equals(1234.567, a / b);

- // Bigint and double.

- a = 400000000000000000000.0;

- b = 200000000000000000000;

- Expect.equals(2.0, a / b);

- Expect.equals(0.5, b / a);

-testBigintModulo() {

- // Bigint and Smi.

- var a = 1000000000005;

- var b = 10;

- Expect.equals(5, a % b);

- Expect.equals(10, b % a);

- // Bigint & Bigint

- a = 10000000000000000001;

- b = 10000000000000000000;

- Expect.equals(1, a % b);

- Expect.equals(10000000000000000000, b % a);

- // Bigint & double.

- a = 10000000100000000.0;

- b = 10000000000000000;

- Expect.equals(100000000.0, a % b);

- Expect.equals(10000000000000000.0, b % a);

- // Transitioning from Mint to Bigint.

- var iStart = 4611686018427387900;

- var prevX = -23 % iStart;

- for (int i = iStart + 1; i < iStart + 10; i++) {

- var x = -23 % i;

- Expect.equals(1, x - prevX);

- Expect.isTrue(x > 0);

- prevX = x;

- }

-testBigintNegate() {

- var a = 0xF000000000000000F;

- var b = ~a; // negate.

- Expect.equals(-0xF0000000000000010, b);

- Expect.equals(0, a & b);

- Expect.equals(-1, a | b);

-testShiftAmount() {

- Expect.equals(0, 12 >> 111111111111111111111111111111);

- Expect.equals(-1, -12 >> 111111111111111111111111111111);

- bool exceptionCaught = false;

- try {

- var a = 1 << 1111111111111111111111111111;

- } on OutOfMemoryError catch (e) {

- exceptionCaught = true;

- }

- Expect.equals(true, exceptionCaught);

-addSubParsed(String a, String b, String sum) {

- int int_a = int.parse(a);

- int int_b = int.parse(b);

- int int_sum = int.parse(sum);

- int computed_sum = int_a + int_b;

- Expect.equals(int_sum, computed_sum);

- String str_sum = computed_sum >= 0 ?

- "0x${computed_sum.toRadixString(16)}" :

- "-0x${(-computed_sum).toRadixString(16)}";

- Expect.equals(sum.toLowerCase(), str_sum);

- int computed_difference1 = int_sum - int_a;

- Expect.equals(int_b, computed_difference1);

- String str_difference1 = computed_difference1 >= 0 ?

- "0x${computed_difference1.toRadixString(16)}" :

- "-0x${(-computed_difference1).toRadixString(16)}";

- Expect.equals(b.toLowerCase(), str_difference1);

- int computed_difference2 = int_sum - int_b;

- Expect.equals(int_a, computed_difference2);

- String str_difference2 = computed_difference2 >= 0 ?

- "0x${computed_difference2.toRadixString(16)}" :

- "-0x${(-computed_difference2).toRadixString(16)}";

- Expect.equals(a.toLowerCase(), str_difference2);

-testBigintAddSub() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- addSubParsed(zero, zero, zero);

- addSubParsed(zero, one, one);

- addSubParsed(one, zero, one);

- addSubParsed(one, one, "0x2");

- addSubParsed(minus_one, minus_one, "-0x2");

- addSubParsed("0x123", zero, "0x123");

- addSubParsed(zero, "0x123", "0x123");

- addSubParsed("0x123", one, "0x124");

- addSubParsed(one, "0x123", "0x124");

- addSubParsed("0xFFFFFFF", one, // 28 bit overflow.

- "0x10000000");

- addSubParsed("0xFFFFFFFF", one, // 32 bit overflow.

- "0x100000000");

- addSubParsed("0xFFFFFFFFFFFFFF", one, // 56 bit overflow.

- "0x100000000000000");

- addSubParsed("0xFFFFFFFFFFFFFFFF", one, // 64 bit overflow.

- "0x10000000000000000");

- addSubParsed("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", // 128 bit.

- one,

- "0x100000000000000000000000000000000");

- addSubParsed("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- one,

- "0x10000000000000000000000000000000000000000000");

- addSubParsed("0x8000000", // 28 bit overflow.

- "0x8000000",

- "0x10000000");

- addSubParsed("0x80000000", // 32 bit overflow.

- "0x80000000",

- "0x100000000");

- addSubParsed("0x80000000000000", // 56 bit overflow.

- "0x80000000000000",

- "0x100000000000000");

- addSubParsed("0x8000000000000000", // 64 bit overflow.

- "0x8000000000000000",

- "0x10000000000000000");

- addSubParsed("0x80000000000000000000000000000000", // 128 bit.

- "0x80000000000000000000000000000000",

- "0x100000000000000000000000000000000");

- addSubParsed("0x8000000000000000000000000000000000000000000",

- "0x8000000000000000000000000000000000000000000",

- "0x10000000000000000000000000000000000000000000");

- {

- String a = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";

- String sum1 = "0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF1";

- String times2 = "0x2468ACF13579BDE02468ACF121579BDE02468ACF13579BDE0";

- addSubParsed(a, zero, a);

- addSubParsed(a, one, sum1);

- addSubParsed(a, a, times2);

- }

- addSubParsed("-0x123", minus_one, "-0x124");

- addSubParsed(minus_one, "-0x123", "-0x124");

- addSubParsed("-0xFFFFFFF", minus_one, // 28 bit overflow.

- "-0x10000000");

- addSubParsed("-0xFFFFFFFF", minus_one, // 32 bit overflow.

- "-0x100000000");

- addSubParsed("-0xFFFFFFFFFFFFFF", minus_one, // 56 bit overflow.

- "-0x100000000000000");

- addSubParsed("-0xFFFFFFFFFFFFFFFF", minus_one, // 64 bit overflow.

- "-0x10000000000000000");

- addSubParsed("-0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", // 128 bit.

- minus_one,

- "-0x100000000000000000000000000000000");

- addSubParsed("-0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- minus_one,

- "-0x10000000000000000000000000000000000000000000");

- addSubParsed("-0x8000000", // 28 bit overflow.

- "-0x8000000",

- "-0x10000000");

- addSubParsed("-0x80000000", // 32 bit overflow.

- "-0x80000000",

- "-0x100000000");

- addSubParsed("-0x80000000000000", // 56 bit overflow.

- "-0x80000000000000",

- "-0x100000000000000");

- addSubParsed("-0x8000000000000000", // 64 bit overflow.

- "-0x8000000000000000",

- "-0x10000000000000000");

- addSubParsed("-0x80000000000000000000000000000000", // 128 bit.

- "-0x80000000000000000000000000000000",

- "-0x100000000000000000000000000000000");

- addSubParsed("-0x8000000000000000000000000000000000000000000",

- "-0x8000000000000000000000000000000000000000000",

- "-0x10000000000000000000000000000000000000000000");

- {

- String a = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF0";

- String sum1 = "-0x123456789ABCDEF01234567890ABCDEF0123456789ABCDEF1";

- String times2 = "-0x2468ACF13579BDE02468ACF121579BDE02468ACF13579BDE0";

- addSubParsed(a, zero, a);

- addSubParsed(a, minus_one, sum1);

- addSubParsed(a, a, times2);

- }

- addSubParsed("0x10000000000000000000000000000000000000000000",

- "0xFFFF",

- "0x1000000000000000000000000000000000000000FFFF");

- addSubParsed("0x10000000000000000000000000000000000000000000",

- "0xFFFF00000000",

- "0x10000000000000000000000000000000FFFF00000000");

- addSubParsed("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0x100000000",

- "0x1000000000000000000000000000000000000FFFFFFFF");

- addSubParsed("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0x10000000000000000000",

- "0x10000000000000000000000000FFFFFFFFFFFFFFFFFFF");

- addSubParsed("0xB", "-0x7", "0x4");

- addSubParsed("-0xB", "-0x7", "-0x12");

- addSubParsed("0xB", "0x7", "0x12");

- addSubParsed("-0xB", "0x7", "-0x4");

- addSubParsed("-0x7", "0xB", "0x4");

- addSubParsed("-0x7", "-0xB", "-0x12");

- addSubParsed("0x7", "0xB", "0x12");

- addSubParsed("0x7", "-0xB", "-0x4");

-shiftLeftParsed(String a, int amount, String result) {

- int int_a = int.parse(a);

- int int_result = int.parse(result);

- int shifted = int_a << amount;

- Expect.equals(int_result, shifted);

- String str_shifted = shifted >= 0 ?

- "0x${shifted.toRadixString(16)}" :

- "-0x${(-shifted).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_shifted);

- int back_shifted = shifted >> amount;

- Expect.equals(int_a, back_shifted);

- String str_back_shifted = back_shifted >= 0 ?

- "0x${back_shifted.toRadixString(16)}" :

- "-0x${(-back_shifted).toRadixString(16)}";

- Expect.equals(a.toLowerCase(), str_back_shifted);

-testBigintLeftShift() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- shiftLeftParsed(zero, 0, zero);

- shiftLeftParsed(one, 0, one);

- shiftLeftParsed("0x1234", 0, "0x1234");

- shiftLeftParsed(zero, 100000, zero);

- shiftLeftParsed(one, 1, "0x2");

- shiftLeftParsed(one, 28, "0x10000000");

- shiftLeftParsed(one, 32, "0x100000000");

- shiftLeftParsed(one, 64, "0x10000000000000000");

- shiftLeftParsed("0x5", 28, "0x50000000");

- shiftLeftParsed("0x5", 32, "0x500000000");

- shiftLeftParsed("0x5", 56, "0x500000000000000");

- shiftLeftParsed("0x5", 64, "0x50000000000000000");

- shiftLeftParsed("0x5", 128, "0x500000000000000000000000000000000");

- shiftLeftParsed("0x5", 27, "0x28000000");

- shiftLeftParsed("0x5", 31, "0x280000000");

- shiftLeftParsed("0x5", 55, "0x280000000000000");

- shiftLeftParsed("0x5", 63, "0x28000000000000000");

- shiftLeftParsed("0x5", 127, "0x280000000000000000000000000000000");

- shiftLeftParsed("0x8000001", 1, "0x10000002");

- shiftLeftParsed("0x80000001", 1, "0x100000002");

- shiftLeftParsed("0x8000000000000001", 1, "0x10000000000000002");

- shiftLeftParsed("0x8000001", 29, "0x100000020000000");

- shiftLeftParsed("0x80000001", 33, "0x10000000200000000");

- shiftLeftParsed("0x8000000000000001", 65,

- "0x100000000000000020000000000000000");

- shiftLeftParsed(minus_one, 0, minus_one);

- shiftLeftParsed("-0x1234", 0, "-0x1234");

- shiftLeftParsed(minus_one, 1, "-0x2");

- shiftLeftParsed(minus_one, 28, "-0x10000000");

- shiftLeftParsed(minus_one, 32, "-0x100000000");

- shiftLeftParsed(minus_one, 64, "-0x10000000000000000");

- shiftLeftParsed("-0x5", 28, "-0x50000000");

- shiftLeftParsed("-0x5", 32, "-0x500000000");

- shiftLeftParsed("-0x5", 64, "-0x50000000000000000");

- shiftLeftParsed("-0x5", 27, "-0x28000000");

- shiftLeftParsed("-0x5", 31, "-0x280000000");

- shiftLeftParsed("-0x5", 63, "-0x28000000000000000");

- shiftLeftParsed("-0x8000001", 1, "-0x10000002");

- shiftLeftParsed("-0x80000001", 1, "-0x100000002");

- shiftLeftParsed("-0x8000000000000001", 1, "-0x10000000000000002");

- shiftLeftParsed("-0x8000001", 29, "-0x100000020000000");

- shiftLeftParsed("-0x80000001", 33, "-0x10000000200000000");

- shiftLeftParsed("-0x8000000000000001", 65,

- "-0x100000000000000020000000000000000");

-shiftRightParsed(String a, int amount, String result) {

- int int_a = int.parse(a);

- int int_result = int.parse(result);

- int shifted = int_a >> amount;

- Expect.equals(int_result, shifted);

- String str_shifted = shifted >= 0 ?

- "0x${shifted.toRadixString(16)}" :

- "-0x${(-shifted).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_shifted);

-testBigintRightShift() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- shiftRightParsed(one, 1, zero);

- shiftRightParsed(minus_one, 1, minus_one);

- shiftRightParsed("-0x2", 1, minus_one);

- shiftRightParsed("0x12345678", 29, zero);

- shiftRightParsed("-0x12345678", 29, minus_one);

- shiftRightParsed("-0x12345678", 100, minus_one);

- shiftRightParsed("0x5", 1, "0x2");

- shiftRightParsed("0x5", 2, "0x1");

- shiftRightParsed("-0x5", 1, "-0x3");

- shiftRightParsed("-0x5", 2, "-0x2");

- shiftRightParsed("0x10000001", 28, one);

- shiftRightParsed("0x100000001", 32, one);

- shiftRightParsed("0x10000000000000001", 64, one);

- shiftRightParsed("-0x10000001", 28, "-0x2");

- shiftRightParsed("-0x100000001", 32, "-0x2");

- shiftRightParsed("-0x10000000000000001", 64, "-0x2");

- shiftRightParsed("0x30000000", 29, one);

- shiftRightParsed("0x300000000", 33, one);

- shiftRightParsed("0x30000000000000000", 65, one);

- shiftRightParsed("-0x30000000", 29, "-0x2");

- shiftRightParsed("-0x300000000", 33, "-0x2");

- shiftRightParsed("-0x30000000000000000", 65, "-0x2");

-bitAndParsed(String a, String b, String result) {

- int int_a = int.parse(a);

- int int_b = int.parse(b);

- int int_result = int.parse(result);

- int anded = int_a & int_b;

- Expect.equals(int_result, anded);

- String str_anded = anded >= 0 ?

- "0x${anded.toRadixString(16)}" :

- "-0x${(-anded).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_anded);

- int anded2 = int_b & int_a;

- Expect.equals(int_result, anded2);

- String str_anded2 = anded2 >= 0 ?

- "0x${anded2.toRadixString(16)}" :

- "-0x${(-anded2).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_anded2);

-testBigintBitAnd() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- bitAndParsed(one, zero, zero);

- bitAndParsed(one, one, one);

- bitAndParsed(minus_one, zero, zero);

- bitAndParsed(minus_one, one, one);

- bitAndParsed(minus_one, minus_one, minus_one);

- bitAndParsed("0x5", "0x3", one);

- bitAndParsed("0x5", minus_one, "0x5");

- bitAndParsed("0x50000000", one, zero);

- bitAndParsed("0x50000000", minus_one, "0x50000000");

- bitAndParsed("0x500000000", one, zero);

- bitAndParsed("0x500000000", minus_one, "0x500000000");

- bitAndParsed("0x50000000000000000", one, zero);

- bitAndParsed("0x50000000000000000", minus_one, "0x50000000000000000");

- bitAndParsed("-0x50000000", "-0x50000000", "-0x50000000");

- bitAndParsed("-0x500000000", "-0x500000000", "-0x500000000");

- bitAndParsed("-0x50000000000000000",

- "-0x50000000000000000",

- "-0x50000000000000000");

- bitAndParsed("0x1234567890ABCDEF012345678",

- "0x876543210FEDCBA0987654321",

- "0x224422000A9C9A0002244220");

- bitAndParsed("-0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "-0x977557799FEFCFEF997755778");

- bitAndParsed("0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "0x101014589002044F010101458");

- bitAndParsed("0x1234567890ABCDEF012345678FFFFFFFFFFFFFFFFFFFFFFFFF",

- "-0x876543210FEDCBA0987654321",

- "0x1234567890ABCDEF012345678789ABCDEF012345F6789ABCDF");

- bitAndParsed("0x12345678", "0xFFFFFFF", "0x2345678");

- bitAndParsed("0x123456789", "0xFFFFFFFF", "0x23456789");

- bitAndParsed("-0x10000000", "0xFFFFFFF", "0x0");

- bitAndParsed("-0x100000000", "0xFFFFFFFF", "0x0");

- bitAndParsed("-0x10000001", "0xFFFFFFF", "0xFFFFFFF");

- bitAndParsed("-0x100000001", "0xFFFFFFFF", "0xFFFFFFFF");

- bitAndParsed("-0x10000001", "0x3FFFFFFF", "0x2FFFFFFF");

- bitAndParsed("-0x100000001", "0x3FFFFFFFF", "0x2FFFFFFFF");

- bitAndParsed("-0x10000000000000001",

- "0x3FFFFFFFFFFFFFFFF",

- "0x2FFFFFFFFFFFFFFFF");

- bitAndParsed("-0x100000000000000", "0xFFFFFFFFFFFFFF", "0x0");

- bitAndParsed("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", "0x0");

- bitAndParsed("-0x300000000000000",

- "0xFFFFFFFFFFFFFFF",

- "0xD00000000000000");

- bitAndParsed("-0x30000000000000000",

- "0xFFFFFFFFFFFFFFFFF",

- "0xD0000000000000000");

- bitAndParsed("-0x10000000", "-0x10000000", "-0x10000000");

- bitAndParsed("-0x100000000", "-0x100000000", "-0x100000000");

- bitAndParsed("-0x100000000000000",

- "-0x100000000000000",

- "-0x100000000000000");

- bitAndParsed("-0x10000000000000000",

- "-0x10000000000000000",

- "-0x10000000000000000");

- bitAndParsed("-0x3", "-0x2", "-0x4");

- bitAndParsed("-0x10000000", "-0x10000001", "-0x20000000");

- bitAndParsed("-0x100000000", "-0x100000001", "-0x200000000");

- bitAndParsed("-0x100000000000000",

- "-0x100000000000001",

- "-0x200000000000000");

- bitAndParsed("-0x10000000000000000",

- "-0x10000000000000001",

- "-0x20000000000000000");

- bitAndParsed("0x123456789ABCDEF01234567890",

- "0x3FFFFFFF", // Max Smi for 32 bits.

- "0x34567890");

- bitAndParsed("0x123456789ABCDEF01274567890",

- "0x3FFFFFFF", // Max Smi for 32 bits.

- "0x34567890");

- bitAndParsed("0x123456789ABCDEF01234567890",

- "0x40000000", // Max Smi for 32 bits + 1.

- "0x0");

- bitAndParsed("0x123456789ABCDEF01274567890",

- "0x40000000", // Max Smi for 32 bits + 1.

- "0x40000000");

- bitAndParsed("0x123456789ABCDEF01234567890",

- "0x3FFFFFFFFFFFFFFF", // Max Smi for 64 bits.

- "0x3CDEF01234567890");

- bitAndParsed("0x123456789ACCDEF01234567890",

- "0x4000000000000000", // Max Smi for 64 bits + 1.

- "0x4000000000000000");

- bitAndParsed("0x123456789ABCDEF01234567890",

- "0x4000000000000000", // Max Smi for 64 bits + 1.

- "0x0");

-bitOrParsed(String a, String b, String result) {

- int int_a = int.parse(a);

- int int_b = int.parse(b);

- int int_result = int.parse(result);

- int ored = int_a | int_b;

- Expect.equals(int_result, ored);

- String str_ored = ored >= 0 ?

- "0x${ored.toRadixString(16)}" :

- "-0x${(-ored).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_ored);

- int ored2 = int_b | int_a;

- Expect.equals(int_result, ored2);

- String str_ored2 = ored2 >= 0 ?

- "0x${ored2.toRadixString(16)}" :

- "-0x${(-ored2).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_ored2);

-testBigintBitOr() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- bitOrParsed(one, zero, one);

- bitOrParsed(one, one, one);

- bitOrParsed(minus_one, zero, minus_one);

- bitOrParsed(minus_one, one, minus_one);

- bitOrParsed(minus_one, minus_one, minus_one);

- bitOrParsed("-0x3", one, "-0x3");

- bitOrParsed("0x5", "0x3", "0x7");

- bitOrParsed("0x5", minus_one, minus_one);

- bitOrParsed("0x5", zero, "0x5");

- bitOrParsed("0x50000000", one, "0x50000001");

- bitOrParsed("0x50000000", minus_one, minus_one);

- bitOrParsed("0x500000000", one, "0x500000001");

- bitOrParsed("0x500000000", minus_one, minus_one);

- bitOrParsed("0x50000000000000000", one, "0x50000000000000001");

- bitOrParsed("0x50000000000000000", minus_one, minus_one);

- bitOrParsed("-0x50000000", "-0x50000000", "-0x50000000");

- bitOrParsed("-0x500000000", "-0x500000000", "-0x500000000");

- bitOrParsed("-0x50000000000000000",

- "-0x50000000000000000",

- "-0x50000000000000000");

- bitOrParsed("0x1234567890ABCDEF012345678",

- "0x876543210FEDCBA0987654321",

- "0x977557799FEFCFEF997755779");

- bitOrParsed("-0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "-0x224422000A9C9A0002244221");

- bitOrParsed("0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "-0x854101010F440200985410101");

- bitOrParsed("0x1234567890ABCDEF012345678FFFFFFFFFFFFFFFFFFFFFFFFF",

- "-0x876543210FEDCBA0987654321",

- "-0x1");

- bitOrParsed("0x12345678", "0xFFFFFFF", "0x1FFFFFFF");

- bitOrParsed("0x123456789", "0xFFFFFFFF", "0x1FFFFFFFF");

- bitOrParsed("-0x10000000", "0xFFFFFFF", "-0x1");

- bitOrParsed("-0x100000000", "0xFFFFFFFF", "-0x1");

- bitOrParsed("-0x10000001", "0xFFFFFFF", "-0x10000001");

- bitOrParsed("-0x100000001", "0xFFFFFFFF", "-0x100000001");

- bitOrParsed("-0x10000001", "0x3FFFFFFF", "-0x1");

- bitOrParsed("-0x100000001", "0x3FFFFFFFF", "-0x1");

- bitOrParsed("-0x10000000000000001", "0x3FFFFFFFFFFFFFFFF", "-0x1");

- bitOrParsed("-0x100000000000000", "0xFFFFFFFFFFFFFF", "-0x1");

- bitOrParsed("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", "-0x1");

- bitOrParsed("-0x300000000000000", "0xFFFFFFFFFFFFFFF", "-0x1");

- bitOrParsed("-0x30000000000000000", "0xFFFFFFFFFFFFFFFFF", "-0x1");

- bitOrParsed("-0x10000000", "-0x10000000", "-0x10000000");

- bitOrParsed("-0x100000000", "-0x100000000", "-0x100000000");

- bitOrParsed("-0x100000000000000",

- "-0x100000000000000",

- "-0x100000000000000");

- bitOrParsed("-0x10000000000000000",

- "-0x10000000000000000",

- "-0x10000000000000000");

- bitOrParsed("-0x10000000", "-0x10000001", "-0x1");

- bitOrParsed("-0x100000000", "-0x100000001", "-0x1");

- bitOrParsed("-0x100000000000000", "-0x100000000000001", "-0x1");

- bitOrParsed("-0x10000000000000000", "-0x10000000000000001", "-0x1");

- bitOrParsed("-0x10000000000000000", "-0x1", "-0x1");

-bitXorParsed(String a, String b, String result) {

- int int_a = int.parse(a);

- int int_b = int.parse(b);

- int int_result = int.parse(result);

- int xored = int_a ^ int_b;

- Expect.equals(int_result, xored);

- String str_xored = xored >= 0 ?

- "0x${xored.toRadixString(16)}" :

- "-0x${(-xored).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_xored);

- int xored2 = int_b ^ int_a;

- Expect.equals(int_result, xored2);

- String str_xored2 = xored2 >= 0 ?

- "0x${xored2.toRadixString(16)}" :

- "-0x${(-xored2).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_xored2);

- int xored3 = int_a ^ xored2;

- Expect.equals(int_b, xored3);

- String str_xored3 = xored3 >= 0 ?

- "0x${xored3.toRadixString(16)}" :

- "-0x${(-xored3).toRadixString(16)}";

- Expect.equals(b.toLowerCase(), str_xored3);

-testBigintBitXor() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- bitXorParsed(one, zero, one);

- bitXorParsed(one, one, zero);

- bitXorParsed(minus_one, zero, minus_one);

- bitXorParsed(minus_one, one, "-0x2");

- bitXorParsed(minus_one, minus_one, zero);

- bitXorParsed("0x5", "0x3", "0x6");

- bitXorParsed("0x5", minus_one, "-0x6");

- bitXorParsed("0x5", zero, "0x5");

- bitXorParsed(minus_one, "-0x8", "0x7");

- bitXorParsed("0x50000000", one, "0x50000001");

- bitXorParsed("0x50000000", minus_one, "-0x50000001");

- bitXorParsed("0x500000000", one, "0x500000001");

- bitXorParsed("0x500000000", minus_one, "-0x500000001");

- bitXorParsed("0x50000000000000000", one, "0x50000000000000001");

- bitXorParsed("0x50000000000000000", minus_one, "-0x50000000000000001");

- bitXorParsed("-0x50000000", "-0x50000000", zero);

- bitXorParsed("-0x500000000", "-0x500000000", zero);

- bitXorParsed("-0x50000000000000000", "-0x50000000000000000", zero);

- bitXorParsed("0x1234567890ABCDEF012345678",

- "0x876543210FEDCBA0987654321",

- "0x955115599F46064F995511559");

- bitXorParsed("-0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "0x955115599F46064F995511557");

- bitXorParsed("0x1234567890ABCDEF012345678",

- "-0x876543210FEDCBA0987654321",

- "-0x955115599F46064F995511559");

- bitXorParsed("0x1234567890ABCDEF012345678FFFFFFFFFFFFFFFFFFFFFFFFF",

- "-0x876543210FEDCBA0987654321",

- "-0x1234567890ABCDEF012345678789ABCDEF012345F6789ABCE0");

- bitXorParsed("0x12345678", "0xFFFFFFF", "0x1DCBA987");

- bitXorParsed("0x123456789", "0xFFFFFFFF", "0x1DCBA9876");

- bitXorParsed("-0x10000000", "0xFFFFFFF", "-0x1");

- bitXorParsed("-0x100000000", "0xFFFFFFFF", "-0x1");

- bitXorParsed("-0x10000001", "0xFFFFFFF", "-0x20000000");

- bitXorParsed("-0x100000001", "0xFFFFFFFF", "-0x200000000");

- bitXorParsed("-0x10000001", "0x3FFFFFFF", "-0x30000000");

- bitXorParsed("-0x100000001", "0x3FFFFFFFF", "-0x300000000");

- bitXorParsed("-0x10000000000000001",

- "0x3FFFFFFFFFFFFFFFF",

- "-0x30000000000000000");

- bitXorParsed("-0x100000000000000", "0xFFFFFFFFFFFFFF", "-0x1");

- bitXorParsed("-0x10000000000000000", "0xFFFFFFFFFFFFFFFF", "-0x1");

- bitXorParsed("-0x300000000000000",

- "0xFFFFFFFFFFFFFFF",

- "-0xD00000000000001");

- bitXorParsed("-0x30000000000000000",

- "0xFFFFFFFFFFFFFFFFF",

- "-0xD0000000000000001");

- bitXorParsed("-0x10000000", "-0x10000000", zero);

- bitXorParsed("-0x100000000", "-0x100000000", zero);

- bitXorParsed("-0x100000000000000", "-0x100000000000000", zero);

- bitXorParsed("-0x10000000000000000", "-0x10000000000000000", zero);

- bitXorParsed("-0x10000000", "-0x10000001", "0x1FFFFFFF");

- bitXorParsed("-0x100000000", "-0x100000001", "0x1FFFFFFFF");

- bitXorParsed("-0x100000000000000",

- "-0x100000000000001",

- "0x1FFFFFFFFFFFFFF");

- bitXorParsed("-0x10000000000000000",

- "-0x10000000000000001",

- "0x1FFFFFFFFFFFFFFFF");

-bitNotParsed(String a, String result) {

- int int_a = int.parse(a);

- int int_result = int.parse(result);

- int inverted = ~int_a;

- Expect.equals(int_result, inverted);

- String str_inverted = inverted >= 0 ?

- "0x${inverted.toRadixString(16)}" :

- "-0x${(-inverted).toRadixString(16)}";

- Expect.equals(result.toLowerCase(), str_inverted);

- int back = ~inverted;

- Expect.equals(int_a, back);

- String str_back = back >= 0 ?

- "0x${back.toRadixString(16)}" :

- "-0x${(-back).toRadixString(16)}";

- Expect.equals(a.toLowerCase(), str_back);

-testBigintBitNot() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- bitNotParsed(zero, minus_one);

- bitNotParsed(one, "-0x2");

- bitNotParsed("0x5", "-0x6");

- bitNotParsed("0x50000000", "-0x50000001");

- bitNotParsed("0xFFFFFFF", "-0x10000000");

- bitNotParsed("0xFFFFFFFF", "-0x100000000");

- bitNotParsed("0xFFFFFFFFFFFFFF", "-0x100000000000000");

- bitNotParsed("0xFFFFFFFFFFFFFFFF", "-0x10000000000000000");

- bitNotParsed("0x1234567890ABCDEF012345678",

- "-0x1234567890ABCDEF012345679");

-mulDivParsed(String a, String b, String product) {

- int int_a = int.parse(a);

- int int_b = int.parse(b);

- int int_product = int.parse(product);

- int computed_product = int_a * int_b;

- Expect.equals(int_product, computed_product);

- String str_product = computed_product >= 0 ?

- "0x${computed_product.toRadixString(16)}" :

- "-0x${(-computed_product).toRadixString(16)}";

- Expect.equals(product.toLowerCase(), str_product);

- int computed_product2 = int_b * int_a;

- Expect.equals(int_product, computed_product2);

- String str_product2 = computed_product2 >= 0 ?

- "0x${computed_product2.toRadixString(16)}" :

- "-0x${(-computed_product2).toRadixString(16)}";

- Expect.equals(product.toLowerCase(), str_product2);

- if (int_a != 0) {

- int computed_quotient1 = int_product ~/ int_a;

- Expect.equals(int_b, computed_quotient1);

- String str_quotient1 = computed_quotient1 >= 0 ?

- "0x${computed_quotient1.toRadixString(16)}" :

- "-0x${(-computed_quotient1).toRadixString(16)}";

- Expect.equals(b.toLowerCase(), str_quotient1);

- }

- if (int_b != 0) {

- int computed_quotient2 = int_product ~/ int_b;

- Expect.equals(int_a, computed_quotient2);

- String str_quotient2 = computed_quotient2 >= 0 ?

- "0x${computed_quotient2.toRadixString(16)}" :

- "-0x${(-computed_quotient2).toRadixString(16)}";

- Expect.equals(a.toLowerCase(), str_quotient2);

- }

-testBigintMultiplyDivide() {

- String zero = "0x0";

- String one = "0x1";

- String minus_one = "-0x1";

- mulDivParsed(zero, zero, zero);

- mulDivParsed(one, one, one);

- mulDivParsed(one, zero, zero);

- mulDivParsed(zero, one, zero);

- mulDivParsed(one, minus_one, minus_one);

- mulDivParsed(minus_one, minus_one, one);

- mulDivParsed("0x42", one, "0x42");

- mulDivParsed("0x42", "0x2", "0x84");

- mulDivParsed("0xFFFF", "0x2", "0x1FFFE");

- mulDivParsed("0x3", "0x5", "0xF");

- mulDivParsed("0xFFFFF", "0x5", "0x4FFFFB");

- mulDivParsed("0xFFFFFFF", "0x5", "0x4FFFFFFB");

- mulDivParsed("0xFFFFFFFF", "0x5", "0x4FFFFFFFB");

- mulDivParsed("0xFFFFFFFFFFFFFFFF", "0x5", "0x4FFFFFFFFFFFFFFFB");

- mulDivParsed("0xFFFFFFFFFFFFFFFF", "0x3039",

- "0x3038FFFFFFFFFFFFCFC7");

- mulDivParsed("0xFFFFFFFFFFFFFFFF",

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0xFFFFFFFFFFFFFFFEFFFFFFFFFF0000000000000001");

- mulDivParsed(

- "0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000",

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000",

- "0xFFFFFFFFFFFFFFFEFFFFFFFFFF000000000000000100000000000000"

- "000000000000000000000000000000000000000000000000000000000000");

- mulDivParsed("0x10000001", "0x5", "0x50000005");

- mulDivParsed(

- "0x1234567890ABCDEF01234567890ABCDEF01234567890ABCDEF"

- "01234567890ABCDEF01234567890ABCDEF",

- "0x1234567890ABCDEF01234567890ABCDEF01234567890ABCDEF"

- "01234567890ABCDEF01234567890ABCDEF",

- "0x14B66DC328828BCA670CBE52943AA3894CCCE15C8F5ED1E55F"

- "328F6D3F579F992299850C4B5B95213EF3FB7B4E73B5F43D4299"

- "5B9F6FD5441C275F2FF89F86F28F47A94CA37481090DCCCDCA6475F09A2F2A521");

- mulDivParsed(

- "0x1234567890ABCDEF01234567890ABCDEF01234567890ABCDEF01234567890ABCDEF"

- "01234567890ABCDEF",

- "0x1234567890123456789012345678901234567890123456789012345678901234567890"

- "123456789012345678901234567890123456789012345678901234567890123456789012"

- "345678901234567890123456789012345678901234567890123456789012345678901234"

- "567890123456789012345678901234567890123456789012345678901234567890123456"

- "789012345678901234567890123456789012345678901234567890123456789012345678"

- "90123456789012345678901234567890",

- "0x14B66DC327D3C88D7EAA988BBFFA9BBA877826E7EDAF373907A931FBFC3A25231DF7F2"

- "516F511FB1638F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A"

- "8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F"

- "0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B"

- "570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B570F4A8F0B57"

- "0F4A8F0B570F4A8F0B570F4A8F0B570F35D89D93E776C67DD864B2034B5C739007933027"

- "5CDFD41E07A15D0F5AD5256BED5F1CF91FBA375DE70");

- mulDivParsed(

- "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFF",

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000"

- "0000000000000000000000000000000000000000000000000000000000000000000001");

- mulDivParsed(

- "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFF",

- "0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFF",

- "0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFC0000000000000000000000000000000000000000000000000000000"

- "000000000000000000000000000000000000000000000000000000000000000000000000"

- "0000000000000000000000000000001");

- // A 256 28-bit digits number squared.

- mulDivParsed(

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",

- "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"

- "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE000000"

- "000000000000000000000000000000000000000000000000000000000000000000000000"

- "0000000000000000000000000000000000000000000000000000000001");