mirror of
https://github.com/dart-lang/sdk
synced 2024-09-19 21:01:50 +00:00
284f662022
Change-Id: I764d0457da85b2935e1d83309eab4c4b5b3ea000 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/126204 Commit-Queue: Bob Nystrom <rnystrom@google.com> Reviewed-by: Lasse R.H. Nielsen <lrn@google.com> Auto-Submit: Bob Nystrom <rnystrom@google.com>
472 lines
18 KiB
Dart
472 lines
18 KiB
Dart
// Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
// Testing integers with and without intrinsics.
|
|
// VMOptions=
|
|
// VMOptions=--no_intrinsify
|
|
|
|
library integer_arithmetic_test;
|
|
|
|
import "package:expect/expect.dart";
|
|
|
|
String toHexString(int value) => value >= 0
|
|
? "0x${value.toRadixString(16)}"
|
|
: "-0x${value.toRadixString(16).substring(1)}";
|
|
|
|
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 = toHexString(computed_sum);
|
|
Expect.equals(sum.toLowerCase(), str_sum);
|
|
int computed_difference1 = int_sum - int_a;
|
|
Expect.equals(int_b, computed_difference1);
|
|
String str_difference1 = toHexString(computed_difference1);
|
|
Expect.equals(b.toLowerCase(), str_difference1);
|
|
int computed_difference2 = int_sum - int_b;
|
|
Expect.equals(int_a, computed_difference2);
|
|
String str_difference2 = toHexString(computed_difference2);
|
|
Expect.equals(a.toLowerCase(), str_difference2);
|
|
}
|
|
|
|
testAddSub() {
|
|
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(
|
|
"0x7FFFFFFFFFFFFFFF",
|
|
one, // 64 bit overflow.
|
|
"-0x8000000000000000");
|
|
addSubParsed(
|
|
minus_one,
|
|
one, // 64 bit overflow.
|
|
zero);
|
|
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",
|
|
zero);
|
|
|
|
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(
|
|
"-0x8000000000000000",
|
|
minus_one, // 64 bit overflow.
|
|
"0x7FFFFFFFFFFFFFFF");
|
|
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",
|
|
"0x0");
|
|
|
|
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,
|
|
{String? result_back_shifted}) {
|
|
result_back_shifted ??= a;
|
|
int int_a = int.parse(a);
|
|
int int_result = int.parse(result);
|
|
int int_result_back_shifted = int.parse(result_back_shifted);
|
|
int shifted = int_a << amount;
|
|
Expect.equals(int_result, shifted);
|
|
String str_shifted = toHexString(shifted);
|
|
Expect.equals(result.toLowerCase(), str_shifted);
|
|
int back_shifted = shifted >> amount;
|
|
Expect.equals(int_result_back_shifted, back_shifted);
|
|
String str_back_shifted = toHexString(back_shifted);
|
|
Expect.equals(result_back_shifted.toLowerCase(), str_back_shifted);
|
|
}
|
|
|
|
testLeftShift() {
|
|
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, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("0x5", 28, "0x50000000");
|
|
shiftLeftParsed("0x5", 32, "0x500000000");
|
|
shiftLeftParsed("0x5", 56, "0x500000000000000");
|
|
shiftLeftParsed("0x5", 64, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("0x5", 128, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("0x5", 27, "0x28000000");
|
|
shiftLeftParsed("0x5", 31, "0x280000000");
|
|
shiftLeftParsed("0x5", 55, "0x280000000000000");
|
|
shiftLeftParsed("0x5", 63, "-0x8000000000000000",
|
|
result_back_shifted: "-0x1");
|
|
shiftLeftParsed("0x5", 127, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("0x8000001", 1, "0x10000002");
|
|
shiftLeftParsed("0x80000001", 1, "0x100000002");
|
|
shiftLeftParsed("0x8000000000000001", 1, "0x2", result_back_shifted: "0x1");
|
|
shiftLeftParsed("0x8000001", 29, "0x100000020000000");
|
|
shiftLeftParsed("0x80000001", 33, "0x200000000", result_back_shifted: "0x1");
|
|
shiftLeftParsed("0x8000000000000001", 65, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("0x7fffffffffffffff", 1, "-0x2", result_back_shifted: "-0x1");
|
|
shiftLeftParsed("0x7fffffffffffffff", 29, "-0x20000000",
|
|
result_back_shifted: "-0x1");
|
|
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, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("-0x5", 28, "-0x50000000");
|
|
shiftLeftParsed("-0x5", 32, "-0x500000000");
|
|
shiftLeftParsed("-0x5", 64, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("-0x5", 27, "-0x28000000");
|
|
shiftLeftParsed("-0x5", 31, "-0x280000000");
|
|
shiftLeftParsed("-0x5", 63, "-0x8000000000000000",
|
|
result_back_shifted: minus_one);
|
|
shiftLeftParsed("-0x8000001", 1, "-0x10000002");
|
|
shiftLeftParsed("-0x80000001", 1, "-0x100000002");
|
|
shiftLeftParsed("-0x8000001", 29, "-0x100000020000000");
|
|
shiftLeftParsed("-0x80000001", 33, "-0x200000000",
|
|
result_back_shifted: "-0x1");
|
|
shiftLeftParsed("-0x7fffffffffffffff", 1, "0x2", result_back_shifted: "0x1");
|
|
shiftLeftParsed("-0x7fffffffffffffff", 65, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("-0x8000000000000000", 1, zero, result_back_shifted: zero);
|
|
shiftLeftParsed("-0x8000000000000000", 29, zero, result_back_shifted: zero);
|
|
}
|
|
|
|
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 = toHexString(shifted);
|
|
Expect.equals(result.toLowerCase(), str_shifted);
|
|
}
|
|
|
|
testRightShift() {
|
|
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("0x1000000000000001", 60, one);
|
|
shiftRightParsed("0x1000000000000001", 64, zero);
|
|
shiftRightParsed("-0x10000001", 28, "-0x2");
|
|
shiftRightParsed("-0x100000001", 32, "-0x2");
|
|
shiftRightParsed("-0x1000000000000001", 64, minus_one);
|
|
shiftRightParsed("0x30000000", 29, one);
|
|
shiftRightParsed("0x300000000", 33, one);
|
|
shiftRightParsed("0x3000000000000000", 61, one);
|
|
shiftRightParsed("0x3000000000000000", 65, zero);
|
|
shiftRightParsed("-0x30000000", 29, "-0x2");
|
|
shiftRightParsed("-0x300000000", 33, "-0x2");
|
|
shiftRightParsed("-0x3000000000000000", 60, "-0x3");
|
|
shiftRightParsed("-0x3000000000000000", 65, minus_one);
|
|
}
|
|
|
|
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 = toHexString(anded);
|
|
Expect.equals(result.toLowerCase(), str_anded);
|
|
int anded2 = int_b & int_a;
|
|
Expect.equals(int_result, anded2);
|
|
String str_anded2 = toHexString(anded2);
|
|
Expect.equals(result.toLowerCase(), str_anded2);
|
|
}
|
|
|
|
testBitAnd() {
|
|
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("0x5000000000000000", one, zero);
|
|
bitAndParsed("0x5000000000000000", minus_one, "0x5000000000000000");
|
|
bitAndParsed("-0x50000000", "-0x50000000", "-0x50000000");
|
|
bitAndParsed("-0x500000000", "-0x500000000", "-0x500000000");
|
|
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("-0x100000000000000", "0xFFFFFFFFFFFFFF", "0x0");
|
|
bitAndParsed(
|
|
"-0x1000000000000000", "0xFFFFFFFFFFFFFFFF", "-0x1000000000000000");
|
|
bitAndParsed("-0x300000000000000", "0xFFFFFFFFFFFFFFF", "0xD00000000000000");
|
|
bitAndParsed(
|
|
"-0x3000000000000000", "0xFFFFFFFFFFFFFFFF", "-0x3000000000000000");
|
|
bitAndParsed("-0x10000000", "-0x10000000", "-0x10000000");
|
|
bitAndParsed("-0x100000000", "-0x100000000", "-0x100000000");
|
|
bitAndParsed(
|
|
"-0x100000000000000", "-0x100000000000000", "-0x100000000000000");
|
|
bitAndParsed(
|
|
"-0x1000000000000000", "-0x1000000000000000", "-0x1000000000000000");
|
|
bitAndParsed("-0x3", "-0x2", "-0x4");
|
|
bitAndParsed("-0x10000000", "-0x10000001", "-0x20000000");
|
|
bitAndParsed("-0x100000000", "-0x100000001", "-0x200000000");
|
|
bitAndParsed(
|
|
"-0x100000000000000", "-0x100000000000001", "-0x200000000000000");
|
|
bitAndParsed(
|
|
"-0x1000000000000000", "-0x1000000000000001", "-0x2000000000000000");
|
|
}
|
|
|
|
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 = toHexString(ored);
|
|
Expect.equals(result.toLowerCase(), str_ored);
|
|
int ored2 = int_b | int_a;
|
|
Expect.equals(int_result, ored2);
|
|
String str_ored2 = toHexString(ored2);
|
|
Expect.equals(result.toLowerCase(), str_ored2);
|
|
}
|
|
|
|
testBitOr() {
|
|
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("0x5000000000000000", one, "0x5000000000000001");
|
|
bitOrParsed("0x5000000000000000", minus_one, minus_one);
|
|
bitOrParsed("-0x50000000", "-0x50000000", "-0x50000000");
|
|
bitOrParsed("-0x500000000", "-0x500000000", "-0x500000000");
|
|
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("-0x1000000000000001", "0x3FFFFFFFFFFFFFFF", "-0x1");
|
|
bitOrParsed("-0x100000000000000", "0xFFFFFFFFFFFFFF", "-0x1");
|
|
bitOrParsed("-0x1000000000000000", "0xFFFFFFFFFFFFFFF", "-0x1");
|
|
bitOrParsed("-0x300000000000000", "0xFFFFFFFFFFFFFFF", "-0x1");
|
|
bitOrParsed("-0x3000000000000000", "0xFFFFFFFFFFFFFFFF", "-0x1");
|
|
bitOrParsed("-0x10000000", "-0x10000000", "-0x10000000");
|
|
bitOrParsed("-0x100000000", "-0x100000000", "-0x100000000");
|
|
bitOrParsed("-0x100000000000000", "-0x100000000000000", "-0x100000000000000");
|
|
bitOrParsed(
|
|
"-0x1000000000000000", "-0x1000000000000000", "-0x1000000000000000");
|
|
bitOrParsed("-0x10000000", "-0x10000001", "-0x1");
|
|
bitOrParsed("-0x100000000", "-0x100000001", "-0x1");
|
|
bitOrParsed("-0x100000000000000", "-0x100000000000001", "-0x1");
|
|
bitOrParsed("-0x1000000000000000", "-0x1000000000000001", "-0x1");
|
|
bitOrParsed("-0x1000000000000000", "-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 = toHexString(xored);
|
|
Expect.equals(result.toLowerCase(), str_xored);
|
|
int xored2 = int_b ^ int_a;
|
|
Expect.equals(int_result, xored2);
|
|
String str_xored2 = toHexString(xored2);
|
|
Expect.equals(result.toLowerCase(), str_xored2);
|
|
int xored3 = int_a ^ xored2;
|
|
Expect.equals(int_b, xored3);
|
|
String str_xored3 = toHexString(xored3);
|
|
Expect.equals(b.toLowerCase(), str_xored3);
|
|
}
|
|
|
|
testBitXor() {
|
|
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("0x5000000000000000", one, "0x5000000000000001");
|
|
bitXorParsed("0x5000000000000000", minus_one, "-0x5000000000000001");
|
|
bitXorParsed("-0x50000000", "-0x50000000", zero);
|
|
bitXorParsed("-0x500000000", "-0x500000000", zero);
|
|
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(
|
|
"-0x1000000000000001", "0x3FFFFFFFFFFFFFFF", "-0x3000000000000000");
|
|
bitXorParsed("-0x100000000000000", "0xFFFFFFFFFFFFFF", "-0x1");
|
|
bitXorParsed("-0x1000000000000000", "0xFFFFFFFFFFFFFFF", "-0x1");
|
|
bitXorParsed("-0x300000000000000", "0xFFFFFFFFFFFFFFF", "-0xD00000000000001");
|
|
bitXorParsed("-0x3000000000000000", "-0x1", "0x2FFFFFFFFFFFFFFF");
|
|
bitXorParsed("-0x10000000", "-0x10000000", zero);
|
|
bitXorParsed("-0x100000000", "-0x100000000", zero);
|
|
bitXorParsed("-0x100000000000000", "-0x100000000000000", zero);
|
|
bitXorParsed("-0x1000000000000000", "-0x1000000000000000", zero);
|
|
bitXorParsed("-0x10000000", "-0x10000001", "0x1FFFFFFF");
|
|
bitXorParsed("-0x100000000", "-0x100000001", "0x1FFFFFFFF");
|
|
bitXorParsed("-0x100000000000000", "-0x100000000000001", "0x1FFFFFFFFFFFFFF");
|
|
bitXorParsed(
|
|
"-0x1000000000000000", "-0x1000000000000001", "0x1FFFFFFFFFFFFFFF");
|
|
}
|
|
|
|
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 = toHexString(inverted);
|
|
Expect.equals(result.toLowerCase(), str_inverted);
|
|
int back = ~inverted;
|
|
Expect.equals(int_a, back);
|
|
String str_back = toHexString(back);
|
|
Expect.equals(a.toLowerCase(), str_back);
|
|
}
|
|
|
|
testBitNot() {
|
|
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("0x7FFFFFFFFFFFFFFF", "-0x8000000000000000");
|
|
bitNotParsed("-0x1", "0x0");
|
|
}
|
|
|
|
main() {
|
|
testAddSub();
|
|
testLeftShift();
|
|
testRightShift();
|
|
testBitAnd();
|
|
testBitOr();
|
|
testBitXor();
|
|
testBitNot();
|
|
}
|