tyler.durden
/
test262
mirror of https://github.com/tc39/test262.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add messages to relational comparison tests

This commit is contained in:
Josh Wolfe 2017-10-06 02:25:58 -07:00
parent 60c232b4d4
commit 30e192da57
16 changed files with 300 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
test/language/expressions/greater-than-or-equal/bigint-and-bigint.js
View File

@ -21,36 +21,36 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n >= 0n, true);
assert.sameValue(1n >= 1n, true);
assert.sameValue(-1n >= -1n, true);
assert.sameValue(0n >= -0n, true);
assert.sameValue(-0n >= 0n, true);
assert.sameValue(0n >= 1n, false);
assert.sameValue(1n >= 0n, true);
assert.sameValue(0n >= -1n, true);
assert.sameValue(-1n >= 0n, false);
assert.sameValue(1n >= -1n, true);
assert.sameValue(-1n >= 1n, false);
assert.sameValue(0x1fffffffffffff01n >= 0x1fffffffffffff02n, false);
assert.sameValue(0x1fffffffffffff02n >= 0x1fffffffffffff01n, true);
assert.sameValue(-0x1fffffffffffff01n >= -0x1fffffffffffff02n, true);
assert.sameValue(-0x1fffffffffffff02n >= -0x1fffffffffffff01n, false);
assert.sameValue(0x10000000000000000n >= 0n, true);
assert.sameValue(0n >= 0x10000000000000000n, false);
assert.sameValue(0x10000000000000000n >= 1n, true);
assert.sameValue(1n >= 0x10000000000000000n, false);
assert.sameValue(0x10000000000000000n >= -1n, true);
assert.sameValue(-1n >= 0x10000000000000000n, false);
assert.sameValue(0x10000000000000001n >= 0n, true);
assert.sameValue(0n >= 0x10000000000000001n, false);
assert.sameValue(-0x10000000000000000n >= 0n, false);
assert.sameValue(0n >= -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000000n >= 1n, false);
assert.sameValue(1n >= -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000000n >= -1n, false);
assert.sameValue(-1n >= -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000001n >= 0n, false);
assert.sameValue(0n >= -0x10000000000000001n, true);
assert.sameValue(0x10000000000000000n >= 0x100000000n, true);
assert.sameValue(0x100000000n >= 0x10000000000000000n, false);
assert.sameValue(0n >= 0n, true, "0n >= 0n");
assert.sameValue(1n >= 1n, true, "1n >= 1n");
assert.sameValue(-1n >= -1n, true, "-1n >= -1n");
assert.sameValue(0n >= -0n, true, "0n >= -0n");
assert.sameValue(-0n >= 0n, true, "-0n >= 0n");
assert.sameValue(0n >= 1n, false, "0n >= 1n");
assert.sameValue(1n >= 0n, true, "1n >= 0n");
assert.sameValue(0n >= -1n, true, "0n >= -1n");
assert.sameValue(-1n >= 0n, false, "-1n >= 0n");
assert.sameValue(1n >= -1n, true, "1n >= -1n");
assert.sameValue(-1n >= 1n, false, "-1n >= 1n");
assert.sameValue(0x1fffffffffffff01n >= 0x1fffffffffffff02n, false, "0x1fffffffffffff01n >= 0x1fffffffffffff02n");
assert.sameValue(0x1fffffffffffff02n >= 0x1fffffffffffff01n, true, "0x1fffffffffffff02n >= 0x1fffffffffffff01n");
assert.sameValue(-0x1fffffffffffff01n >= -0x1fffffffffffff02n, true, "-0x1fffffffffffff01n >= -0x1fffffffffffff02n");
assert.sameValue(-0x1fffffffffffff02n >= -0x1fffffffffffff01n, false, "-0x1fffffffffffff02n >= -0x1fffffffffffff01n");
assert.sameValue(0x10000000000000000n >= 0n, true, "0x10000000000000000n >= 0n");
assert.sameValue(0n >= 0x10000000000000000n, false, "0n >= 0x10000000000000000n");
assert.sameValue(0x10000000000000000n >= 1n, true, "0x10000000000000000n >= 1n");
assert.sameValue(1n >= 0x10000000000000000n, false, "1n >= 0x10000000000000000n");
assert.sameValue(0x10000000000000000n >= -1n, true, "0x10000000000000000n >= -1n");
assert.sameValue(-1n >= 0x10000000000000000n, false, "-1n >= 0x10000000000000000n");
assert.sameValue(0x10000000000000001n >= 0n, true, "0x10000000000000001n >= 0n");
assert.sameValue(0n >= 0x10000000000000001n, false, "0n >= 0x10000000000000001n");
assert.sameValue(-0x10000000000000000n >= 0n, false, "-0x10000000000000000n >= 0n");
assert.sameValue(0n >= -0x10000000000000000n, true, "0n >= -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n >= 1n, false, "-0x10000000000000000n >= 1n");
assert.sameValue(1n >= -0x10000000000000000n, true, "1n >= -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n >= -1n, false, "-0x10000000000000000n >= -1n");
assert.sameValue(-1n >= -0x10000000000000000n, true, "-1n >= -0x10000000000000000n");
assert.sameValue(-0x10000000000000001n >= 0n, false, "-0x10000000000000001n >= 0n");
assert.sameValue(0n >= -0x10000000000000001n, true, "0n >= -0x10000000000000001n");
assert.sameValue(0x10000000000000000n >= 0x100000000n, true, "0x10000000000000000n >= 0x100000000n");
assert.sameValue(0x100000000n >= 0x10000000000000000n, false, "0x100000000n >= 0x10000000000000000n");

20
test/language/expressions/greater-than-or-equal/bigint-and-non-finite.js
View File

@ -19,13 +19,13 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n >= Infinity, false);
assert.sameValue(Infinity >= 1n, true);
assert.sameValue(-1n >= Infinity, false);
assert.sameValue(Infinity >= -1n, true);
assert.sameValue(1n >= -Infinity, true);
assert.sameValue(-Infinity >= 1n, false);
assert.sameValue(-1n >= -Infinity, true);
assert.sameValue(-Infinity >= -1n, false);
assert.sameValue(0n >= NaN, false);
assert.sameValue(NaN >= 0n, false);
assert.sameValue(1n >= Infinity, false, "1n >= Infinity");
assert.sameValue(Infinity >= 1n, true, "Infinity >= 1n");
assert.sameValue(-1n >= Infinity, false, "-1n >= Infinity");
assert.sameValue(Infinity >= -1n, true, "Infinity >= -1n");
assert.sameValue(1n >= -Infinity, true, "1n >= -Infinity");
assert.sameValue(-Infinity >= 1n, false, "-Infinity >= 1n");
assert.sameValue(-1n >= -Infinity, true, "-1n >= -Infinity");
assert.sameValue(-Infinity >= -1n, false, "-Infinity >= -1n");
assert.sameValue(0n >= NaN, false, "0n >= NaN");
assert.sameValue(NaN >= 0n, false, "NaN >= 0n");

20
test/language/expressions/greater-than-or-equal/bigint-and-number-extremes.js
View File

@ -20,19 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n >= Number.MAX_VALUE, false);
assert.sameValue(Number.MAX_VALUE >= 1n, true);
assert.sameValue(1n >= -Number.MAX_VALUE, true);
assert.sameValue(-Number.MAX_VALUE >= 1n, false);
assert.sameValue(1n >= Number.MAX_VALUE, false, "1n >= Number.MAX_VALUE");
assert.sameValue(Number.MAX_VALUE >= 1n, true, "Number.MAX_VALUE >= 1n");
assert.sameValue(1n >= -Number.MAX_VALUE, true, "1n >= -Number.MAX_VALUE");
assert.sameValue(-Number.MAX_VALUE >= 1n, false, "-Number.MAX_VALUE >= 1n");
assert.sameValue(
0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn >= Number.MAX_VALUE,
false);
false,
"0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn >= Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE >= 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
true);
true,
"Number.MAX_VALUE >= 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn");
assert.sameValue(
0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n >= Number.MAX_VALUE,
true);
true,
"0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n >= Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE >= 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n,
false);
false,
"Number.MAX_VALUE >= 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n");

40
test/language/expressions/greater-than-or-equal/bigint-and-number.js
View File

@ -20,23 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n >= 0, true);
assert.sameValue(0 >= 0n, true);
assert.sameValue(0n >= -0, true);
assert.sameValue(-0 >= 0n, true);
assert.sameValue(0n >= 0.000000000001, false);
assert.sameValue(0.000000000001 >= 0n, true);
assert.sameValue(0n >= 1, false);
assert.sameValue(1 >= 0n, true);
assert.sameValue(1n >= 0, true);
assert.sameValue(0 >= 1n, false);
assert.sameValue(1n >= 0.999999999999, true);
assert.sameValue(0.999999999999 >= 1n, false);
assert.sameValue(1n >= 1, true);
assert.sameValue(1 >= 1n, true);
assert.sameValue(0n >= Number.MIN_VALUE, false);
assert.sameValue(Number.MIN_VALUE >= 0n, true);
assert.sameValue(0n >= -Number.MIN_VALUE, true);
assert.sameValue(-Number.MIN_VALUE >= 0n, false);
assert.sameValue(-10n >= Number.MIN_VALUE, false);
assert.sameValue(Number.MIN_VALUE >= -10n, true);
assert.sameValue(0n >= 0, true, "0n >= 0");
assert.sameValue(0 >= 0n, true, "0 >= 0n");
assert.sameValue(0n >= -0, true, "0n >= -0");
assert.sameValue(-0 >= 0n, true, "-0 >= 0n");
assert.sameValue(0n >= 0.000000000001, false, "0n >= 0.000000000001");
assert.sameValue(0.000000000001 >= 0n, true, "0.000000000001 >= 0n");
assert.sameValue(0n >= 1, false, "0n >= 1");
assert.sameValue(1 >= 0n, true, "1 >= 0n");
assert.sameValue(1n >= 0, true, "1n >= 0");
assert.sameValue(0 >= 1n, false, "0 >= 1n");
assert.sameValue(1n >= 0.999999999999, true, "1n >= 0.999999999999");
assert.sameValue(0.999999999999 >= 1n, false, "0.999999999999 >= 1n");
assert.sameValue(1n >= 1, true, "1n >= 1");
assert.sameValue(1 >= 1n, true, "1 >= 1n");
assert.sameValue(0n >= Number.MIN_VALUE, false, "0n >= Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE >= 0n, true, "Number.MIN_VALUE >= 0n");
assert.sameValue(0n >= -Number.MIN_VALUE, true, "0n >= -Number.MIN_VALUE");
assert.sameValue(-Number.MIN_VALUE >= 0n, false, "-Number.MIN_VALUE >= 0n");
assert.sameValue(-10n >= Number.MIN_VALUE, false, "-10n >= Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE >= -10n, true, "Number.MIN_VALUE >= -10n");

66
test/language/expressions/greater-than/bigint-and-bigint.js
View File

@ -21,36 +21,36 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n > 0n, false);
assert.sameValue(1n > 1n, false);
assert.sameValue(-1n > -1n, false);
assert.sameValue(0n > -0n, false);
assert.sameValue(-0n > 0n, false);
assert.sameValue(0n > 1n, false);
assert.sameValue(1n > 0n, true);
assert.sameValue(0n > -1n, true);
assert.sameValue(-1n > 0n, false);
assert.sameValue(1n > -1n, true);
assert.sameValue(-1n > 1n, false);
assert.sameValue(0x1fffffffffffff01n > 0x1fffffffffffff02n, false);
assert.sameValue(0x1fffffffffffff02n > 0x1fffffffffffff01n, true);
assert.sameValue(-0x1fffffffffffff01n > -0x1fffffffffffff02n, true);
assert.sameValue(-0x1fffffffffffff02n > -0x1fffffffffffff01n, false);
assert.sameValue(0x10000000000000000n > 0n, true);
assert.sameValue(0n > 0x10000000000000000n, false);
assert.sameValue(0x10000000000000000n > 1n, true);
assert.sameValue(1n > 0x10000000000000000n, false);
assert.sameValue(0x10000000000000000n > -1n, true);
assert.sameValue(-1n > 0x10000000000000000n, false);
assert.sameValue(0x10000000000000001n > 0n, true);
assert.sameValue(0n > 0x10000000000000001n, false);
assert.sameValue(-0x10000000000000000n > 0n, false);
assert.sameValue(0n > -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000000n > 1n, false);
assert.sameValue(1n > -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000000n > -1n, false);
assert.sameValue(-1n > -0x10000000000000000n, true);
assert.sameValue(-0x10000000000000001n > 0n, false);
assert.sameValue(0n > -0x10000000000000001n, true);
assert.sameValue(0x10000000000000000n > 0x100000000n, true);
assert.sameValue(0x100000000n > 0x10000000000000000n, false);
assert.sameValue(0n > 0n, false, "0n > 0n");
assert.sameValue(1n > 1n, false, "1n > 1n");
assert.sameValue(-1n > -1n, false, "-1n > -1n");
assert.sameValue(0n > -0n, false, "0n > -0n");
assert.sameValue(-0n > 0n, false, "-0n > 0n");
assert.sameValue(0n > 1n, false, "0n > 1n");
assert.sameValue(1n > 0n, true, "1n > 0n");
assert.sameValue(0n > -1n, true, "0n > -1n");
assert.sameValue(-1n > 0n, false, "-1n > 0n");
assert.sameValue(1n > -1n, true, "1n > -1n");
assert.sameValue(-1n > 1n, false, "-1n > 1n");
assert.sameValue(0x1fffffffffffff01n > 0x1fffffffffffff02n, false, "0x1fffffffffffff01n > 0x1fffffffffffff02n");
assert.sameValue(0x1fffffffffffff02n > 0x1fffffffffffff01n, true, "0x1fffffffffffff02n > 0x1fffffffffffff01n");
assert.sameValue(-0x1fffffffffffff01n > -0x1fffffffffffff02n, true, "-0x1fffffffffffff01n > -0x1fffffffffffff02n");
assert.sameValue(-0x1fffffffffffff02n > -0x1fffffffffffff01n, false, "-0x1fffffffffffff02n > -0x1fffffffffffff01n");
assert.sameValue(0x10000000000000000n > 0n, true, "0x10000000000000000n > 0n");
assert.sameValue(0n > 0x10000000000000000n, false, "0n > 0x10000000000000000n");
assert.sameValue(0x10000000000000000n > 1n, true, "0x10000000000000000n > 1n");
assert.sameValue(1n > 0x10000000000000000n, false, "1n > 0x10000000000000000n");
assert.sameValue(0x10000000000000000n > -1n, true, "0x10000000000000000n > -1n");
assert.sameValue(-1n > 0x10000000000000000n, false, "-1n > 0x10000000000000000n");
assert.sameValue(0x10000000000000001n > 0n, true, "0x10000000000000001n > 0n");
assert.sameValue(0n > 0x10000000000000001n, false, "0n > 0x10000000000000001n");
assert.sameValue(-0x10000000000000000n > 0n, false, "-0x10000000000000000n > 0n");
assert.sameValue(0n > -0x10000000000000000n, true, "0n > -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n > 1n, false, "-0x10000000000000000n > 1n");
assert.sameValue(1n > -0x10000000000000000n, true, "1n > -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n > -1n, false, "-0x10000000000000000n > -1n");
assert.sameValue(-1n > -0x10000000000000000n, true, "-1n > -0x10000000000000000n");
assert.sameValue(-0x10000000000000001n > 0n, false, "-0x10000000000000001n > 0n");
assert.sameValue(0n > -0x10000000000000001n, true, "0n > -0x10000000000000001n");
assert.sameValue(0x10000000000000000n > 0x100000000n, true, "0x10000000000000000n > 0x100000000n");
assert.sameValue(0x100000000n > 0x10000000000000000n, false, "0x100000000n > 0x10000000000000000n");

20
test/language/expressions/greater-than/bigint-and-non-finite.js
View File

@ -19,13 +19,13 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n > Infinity, false);
assert.sameValue(Infinity > 1n, true);
assert.sameValue(-1n > Infinity, false);
assert.sameValue(Infinity > -1n, true);
assert.sameValue(1n > -Infinity, true);
assert.sameValue(-Infinity > 1n, false);
assert.sameValue(-1n > -Infinity, true);
assert.sameValue(-Infinity > -1n, false);
assert.sameValue(0n > NaN, false);
assert.sameValue(NaN > 0n, false);
assert.sameValue(1n > Infinity, false, "1n > Infinity");
assert.sameValue(Infinity > 1n, true, "Infinity > 1n");
assert.sameValue(-1n > Infinity, false, "-1n > Infinity");
assert.sameValue(Infinity > -1n, true, "Infinity > -1n");
assert.sameValue(1n > -Infinity, true, "1n > -Infinity");
assert.sameValue(-Infinity > 1n, false, "-Infinity > 1n");
assert.sameValue(-1n > -Infinity, true, "-1n > -Infinity");
assert.sameValue(-Infinity > -1n, false, "-Infinity > -1n");
assert.sameValue(0n > NaN, false, "0n > NaN");
assert.sameValue(NaN > 0n, false, "NaN > 0n");

20
test/language/expressions/greater-than/bigint-and-number-extremes.js
View File

@ -20,19 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n > Number.MAX_VALUE, false);
assert.sameValue(Number.MAX_VALUE > 1n, true);
assert.sameValue(1n > -Number.MAX_VALUE, true);
assert.sameValue(-Number.MAX_VALUE > 1n, false);
assert.sameValue(1n > Number.MAX_VALUE, false, "1n > Number.MAX_VALUE");
assert.sameValue(Number.MAX_VALUE > 1n, true, "Number.MAX_VALUE > 1n");
assert.sameValue(1n > -Number.MAX_VALUE, true, "1n > -Number.MAX_VALUE");
assert.sameValue(-Number.MAX_VALUE > 1n, false, "-Number.MAX_VALUE > 1n");
assert.sameValue(
0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn > Number.MAX_VALUE,
false);
false,
"0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn > Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE > 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
true);
true,
"Number.MAX_VALUE > 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn");
assert.sameValue(
0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n > Number.MAX_VALUE,
true);
true,
"0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n > Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE > 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n,
false);
false,
"Number.MAX_VALUE > 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n");

40
test/language/expressions/greater-than/bigint-and-number.js
View File

@ -20,23 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n > 0, false);
assert.sameValue(0 > 0n, false);
assert.sameValue(0n > -0, false);
assert.sameValue(-0 > 0n, false);
assert.sameValue(0n > 0.000000000001, false);
assert.sameValue(0.000000000001 > 0n, true);
assert.sameValue(0n > 1, false);
assert.sameValue(1 > 0n, true);
assert.sameValue(1n > 0, true);
assert.sameValue(0 > 1n, false);
assert.sameValue(1n > 0.999999999999, true);
assert.sameValue(0.999999999999 > 1n, false);
assert.sameValue(1n > 1, false);
assert.sameValue(1 > 1n, false);
assert.sameValue(0n > Number.MIN_VALUE, false);
assert.sameValue(Number.MIN_VALUE > 0n, true);
assert.sameValue(0n > -Number.MIN_VALUE, true);
assert.sameValue(-Number.MIN_VALUE > 0n, false);
assert.sameValue(-10n > Number.MIN_VALUE, false);
assert.sameValue(Number.MIN_VALUE > -10n, true);
assert.sameValue(0n > 0, false, "0n > 0");
assert.sameValue(0 > 0n, false, "0 > 0n");
assert.sameValue(0n > -0, false, "0n > -0");
assert.sameValue(-0 > 0n, false, "-0 > 0n");
assert.sameValue(0n > 0.000000000001, false, "0n > 0.000000000001");
assert.sameValue(0.000000000001 > 0n, true, "0.000000000001 > 0n");
assert.sameValue(0n > 1, false, "0n > 1");
assert.sameValue(1 > 0n, true, "1 > 0n");
assert.sameValue(1n > 0, true, "1n > 0");
assert.sameValue(0 > 1n, false, "0 > 1n");
assert.sameValue(1n > 0.999999999999, true, "1n > 0.999999999999");
assert.sameValue(0.999999999999 > 1n, false, "0.999999999999 > 1n");
assert.sameValue(1n > 1, false, "1n > 1");
assert.sameValue(1 > 1n, false, "1 > 1n");
assert.sameValue(0n > Number.MIN_VALUE, false, "0n > Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE > 0n, true, "Number.MIN_VALUE > 0n");
assert.sameValue(0n > -Number.MIN_VALUE, true, "0n > -Number.MIN_VALUE");
assert.sameValue(-Number.MIN_VALUE > 0n, false, "-Number.MIN_VALUE > 0n");
assert.sameValue(-10n > Number.MIN_VALUE, false, "-10n > Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE > -10n, true, "Number.MIN_VALUE > -10n");

66
test/language/expressions/less-than-or-equal/bigint-and-bigint.js
View File

@ -21,36 +21,36 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n <= 0n, true);
assert.sameValue(1n <= 1n, true);
assert.sameValue(-1n <= -1n, true);
assert.sameValue(0n <= -0n, true);
assert.sameValue(-0n <= 0n, true);
assert.sameValue(0n <= 1n, true);
assert.sameValue(1n <= 0n, false);
assert.sameValue(0n <= -1n, false);
assert.sameValue(-1n <= 0n, true);
assert.sameValue(1n <= -1n, false);
assert.sameValue(-1n <= 1n, true);
assert.sameValue(0x1fffffffffffff01n <= 0x1fffffffffffff02n, true);
assert.sameValue(0x1fffffffffffff02n <= 0x1fffffffffffff01n, false);
assert.sameValue(-0x1fffffffffffff01n <= -0x1fffffffffffff02n, false);
assert.sameValue(-0x1fffffffffffff02n <= -0x1fffffffffffff01n, true);
assert.sameValue(0x10000000000000000n <= 0n, false);
assert.sameValue(0n <= 0x10000000000000000n, true);
assert.sameValue(0x10000000000000000n <= 1n, false);
assert.sameValue(1n <= 0x10000000000000000n, true);
assert.sameValue(0x10000000000000000n <= -1n, false);
assert.sameValue(-1n <= 0x10000000000000000n, true);
assert.sameValue(0x10000000000000001n <= 0n, false);
assert.sameValue(0n <= 0x10000000000000001n, true);
assert.sameValue(-0x10000000000000000n <= 0n, true);
assert.sameValue(0n <= -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000000n <= 1n, true);
assert.sameValue(1n <= -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000000n <= -1n, true);
assert.sameValue(-1n <= -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000001n <= 0n, true);
assert.sameValue(0n <= -0x10000000000000001n, false);
assert.sameValue(0x10000000000000000n <= 0x100000000n, false);
assert.sameValue(0x100000000n <= 0x10000000000000000n, true);
assert.sameValue(0n <= 0n, true, "0n <= 0n");
assert.sameValue(1n <= 1n, true, "1n <= 1n");
assert.sameValue(-1n <= -1n, true, "-1n <= -1n");
assert.sameValue(0n <= -0n, true, "0n <= -0n");
assert.sameValue(-0n <= 0n, true, "-0n <= 0n");
assert.sameValue(0n <= 1n, true, "0n <= 1n");
assert.sameValue(1n <= 0n, false, "1n <= 0n");
assert.sameValue(0n <= -1n, false, "0n <= -1n");
assert.sameValue(-1n <= 0n, true, "-1n <= 0n");
assert.sameValue(1n <= -1n, false, "1n <= -1n");
assert.sameValue(-1n <= 1n, true, "-1n <= 1n");
assert.sameValue(0x1fffffffffffff01n <= 0x1fffffffffffff02n, true, "0x1fffffffffffff01n <= 0x1fffffffffffff02n");
assert.sameValue(0x1fffffffffffff02n <= 0x1fffffffffffff01n, false, "0x1fffffffffffff02n <= 0x1fffffffffffff01n");
assert.sameValue(-0x1fffffffffffff01n <= -0x1fffffffffffff02n, false, "-0x1fffffffffffff01n <= -0x1fffffffffffff02n");
assert.sameValue(-0x1fffffffffffff02n <= -0x1fffffffffffff01n, true, "-0x1fffffffffffff02n <= -0x1fffffffffffff01n");
assert.sameValue(0x10000000000000000n <= 0n, false, "0x10000000000000000n <= 0n");
assert.sameValue(0n <= 0x10000000000000000n, true, "0n <= 0x10000000000000000n");
assert.sameValue(0x10000000000000000n <= 1n, false, "0x10000000000000000n <= 1n");
assert.sameValue(1n <= 0x10000000000000000n, true, "1n <= 0x10000000000000000n");
assert.sameValue(0x10000000000000000n <= -1n, false, "0x10000000000000000n <= -1n");
assert.sameValue(-1n <= 0x10000000000000000n, true, "-1n <= 0x10000000000000000n");
assert.sameValue(0x10000000000000001n <= 0n, false, "0x10000000000000001n <= 0n");
assert.sameValue(0n <= 0x10000000000000001n, true, "0n <= 0x10000000000000001n");
assert.sameValue(-0x10000000000000000n <= 0n, true, "-0x10000000000000000n <= 0n");
assert.sameValue(0n <= -0x10000000000000000n, false, "0n <= -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n <= 1n, true, "-0x10000000000000000n <= 1n");
assert.sameValue(1n <= -0x10000000000000000n, false, "1n <= -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n <= -1n, true, "-0x10000000000000000n <= -1n");
assert.sameValue(-1n <= -0x10000000000000000n, false, "-1n <= -0x10000000000000000n");
assert.sameValue(-0x10000000000000001n <= 0n, true, "-0x10000000000000001n <= 0n");
assert.sameValue(0n <= -0x10000000000000001n, false, "0n <= -0x10000000000000001n");
assert.sameValue(0x10000000000000000n <= 0x100000000n, false, "0x10000000000000000n <= 0x100000000n");
assert.sameValue(0x100000000n <= 0x10000000000000000n, true, "0x100000000n <= 0x10000000000000000n");

20
test/language/expressions/less-than-or-equal/bigint-and-non-finite.js
View File

@ -19,13 +19,13 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n <= Infinity, true);
assert.sameValue(Infinity <= 1n, false);
assert.sameValue(-1n <= Infinity, true);
assert.sameValue(Infinity <= -1n, false);
assert.sameValue(1n <= -Infinity, false);
assert.sameValue(-Infinity <= 1n, true);
assert.sameValue(-1n <= -Infinity, false);
assert.sameValue(-Infinity <= -1n, true);
assert.sameValue(0n <= NaN, false);
assert.sameValue(NaN <= 0n, false);
assert.sameValue(1n <= Infinity, true, "1n <= Infinity");
assert.sameValue(Infinity <= 1n, false, "Infinity <= 1n");
assert.sameValue(-1n <= Infinity, true, "-1n <= Infinity");
assert.sameValue(Infinity <= -1n, false, "Infinity <= -1n");
assert.sameValue(1n <= -Infinity, false, "1n <= -Infinity");
assert.sameValue(-Infinity <= 1n, true, "-Infinity <= 1n");
assert.sameValue(-1n <= -Infinity, false, "-1n <= -Infinity");
assert.sameValue(-Infinity <= -1n, true, "-Infinity <= -1n");
assert.sameValue(0n <= NaN, false, "0n <= NaN");
assert.sameValue(NaN <= 0n, false, "NaN <= 0n");

20
test/language/expressions/less-than-or-equal/bigint-and-number-extremes.js
View File

@ -20,19 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n <= Number.MAX_VALUE, true);
assert.sameValue(Number.MAX_VALUE <= 1n, false);
assert.sameValue(1n <= -Number.MAX_VALUE, false);
assert.sameValue(-Number.MAX_VALUE <= 1n, true);
assert.sameValue(1n <= Number.MAX_VALUE, true, "1n <= Number.MAX_VALUE");
assert.sameValue(Number.MAX_VALUE <= 1n, false, "Number.MAX_VALUE <= 1n");
assert.sameValue(1n <= -Number.MAX_VALUE, false, "1n <= -Number.MAX_VALUE");
assert.sameValue(-Number.MAX_VALUE <= 1n, true, "-Number.MAX_VALUE <= 1n");
assert.sameValue(
0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn <= Number.MAX_VALUE,
true);
true,
"0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn <= Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE <= 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
false);
false,
"Number.MAX_VALUE <= 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn");
assert.sameValue(
0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n <= Number.MAX_VALUE,
false);
false,
"0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n <= Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE <= 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n,
true);
true,
"Number.MAX_VALUE <= 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n");

40
test/language/expressions/less-than-or-equal/bigint-and-number.js
View File

@ -20,23 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n <= 0, true);
assert.sameValue(0 <= 0n, true);
assert.sameValue(0n <= -0, true);
assert.sameValue(-0 <= 0n, true);
assert.sameValue(0n <= 0.000000000001, true);
assert.sameValue(0.000000000001 <= 0n, false);
assert.sameValue(0n <= 1, true);
assert.sameValue(1 <= 0n, false);
assert.sameValue(1n <= 0, false);
assert.sameValue(0 <= 1n, true);
assert.sameValue(1n <= 0.999999999999, false);
assert.sameValue(0.999999999999 <= 1n, true);
assert.sameValue(1n <= 1, true);
assert.sameValue(1 <= 1n, true);
assert.sameValue(0n <= Number.MIN_VALUE, true);
assert.sameValue(Number.MIN_VALUE <= 0n, false);
assert.sameValue(0n <= -Number.MIN_VALUE, false);
assert.sameValue(-Number.MIN_VALUE <= 0n, true);
assert.sameValue(-10n <= Number.MIN_VALUE, true);
assert.sameValue(Number.MIN_VALUE <= -10n, false);
assert.sameValue(0n <= 0, true, "0n <= 0");
assert.sameValue(0 <= 0n, true, "0 <= 0n");
assert.sameValue(0n <= -0, true, "0n <= -0");
assert.sameValue(-0 <= 0n, true, "-0 <= 0n");
assert.sameValue(0n <= 0.000000000001, true, "0n <= 0.000000000001");
assert.sameValue(0.000000000001 <= 0n, false, "0.000000000001 <= 0n");
assert.sameValue(0n <= 1, true, "0n <= 1");
assert.sameValue(1 <= 0n, false, "1 <= 0n");
assert.sameValue(1n <= 0, false, "1n <= 0");
assert.sameValue(0 <= 1n, true, "0 <= 1n");
assert.sameValue(1n <= 0.999999999999, false, "1n <= 0.999999999999");
assert.sameValue(0.999999999999 <= 1n, true, "0.999999999999 <= 1n");
assert.sameValue(1n <= 1, true, "1n <= 1");
assert.sameValue(1 <= 1n, true, "1 <= 1n");
assert.sameValue(0n <= Number.MIN_VALUE, true, "0n <= Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE <= 0n, false, "Number.MIN_VALUE <= 0n");
assert.sameValue(0n <= -Number.MIN_VALUE, false, "0n <= -Number.MIN_VALUE");
assert.sameValue(-Number.MIN_VALUE <= 0n, true, "-Number.MIN_VALUE <= 0n");
assert.sameValue(-10n <= Number.MIN_VALUE, true, "-10n <= Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE <= -10n, false, "Number.MIN_VALUE <= -10n");

66
test/language/expressions/less-than/bigint-and-bigint.js
View File

@ -21,36 +21,36 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n < 0n, false);
assert.sameValue(1n < 1n, false);
assert.sameValue(-1n < -1n, false);
assert.sameValue(0n < -0n, false);
assert.sameValue(-0n < 0n, false);
assert.sameValue(0n < 1n, true);
assert.sameValue(1n < 0n, false);
assert.sameValue(0n < -1n, false);
assert.sameValue(-1n < 0n, true);
assert.sameValue(1n < -1n, false);
assert.sameValue(-1n < 1n, true);
assert.sameValue(0x1fffffffffffff01n < 0x1fffffffffffff02n, true);
assert.sameValue(0x1fffffffffffff02n < 0x1fffffffffffff01n, false);
assert.sameValue(-0x1fffffffffffff01n < -0x1fffffffffffff02n, false);
assert.sameValue(-0x1fffffffffffff02n < -0x1fffffffffffff01n, true);
assert.sameValue(0x10000000000000000n < 0n, false);
assert.sameValue(0n < 0x10000000000000000n, true);
assert.sameValue(0x10000000000000000n < 1n, false);
assert.sameValue(1n < 0x10000000000000000n, true);
assert.sameValue(0x10000000000000000n < -1n, false);
assert.sameValue(-1n < 0x10000000000000000n, true);
assert.sameValue(0x10000000000000001n < 0n, false);
assert.sameValue(0n < 0x10000000000000001n, true);
assert.sameValue(-0x10000000000000000n < 0n, true);
assert.sameValue(0n < -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000000n < 1n, true);
assert.sameValue(1n < -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000000n < -1n, true);
assert.sameValue(-1n < -0x10000000000000000n, false);
assert.sameValue(-0x10000000000000001n < 0n, true);
assert.sameValue(0n < -0x10000000000000001n, false);
assert.sameValue(0x10000000000000000n < 0x100000000n, false);
assert.sameValue(0x100000000n < 0x10000000000000000n, true);
assert.sameValue(0n < 0n, false, "0n < 0n");
assert.sameValue(1n < 1n, false, "1n < 1n");
assert.sameValue(-1n < -1n, false, "-1n < -1n");
assert.sameValue(0n < -0n, false, "0n < -0n");
assert.sameValue(-0n < 0n, false, "-0n < 0n");
assert.sameValue(0n < 1n, true, "0n < 1n");
assert.sameValue(1n < 0n, false, "1n < 0n");
assert.sameValue(0n < -1n, false, "0n < -1n");
assert.sameValue(-1n < 0n, true, "-1n < 0n");
assert.sameValue(1n < -1n, false, "1n < -1n");
assert.sameValue(-1n < 1n, true, "-1n < 1n");
assert.sameValue(0x1fffffffffffff01n < 0x1fffffffffffff02n, true, "0x1fffffffffffff01n < 0x1fffffffffffff02n");
assert.sameValue(0x1fffffffffffff02n < 0x1fffffffffffff01n, false, "0x1fffffffffffff02n < 0x1fffffffffffff01n");
assert.sameValue(-0x1fffffffffffff01n < -0x1fffffffffffff02n, false, "-0x1fffffffffffff01n < -0x1fffffffffffff02n");
assert.sameValue(-0x1fffffffffffff02n < -0x1fffffffffffff01n, true, "-0x1fffffffffffff02n < -0x1fffffffffffff01n");
assert.sameValue(0x10000000000000000n < 0n, false, "0x10000000000000000n < 0n");
assert.sameValue(0n < 0x10000000000000000n, true, "0n < 0x10000000000000000n");
assert.sameValue(0x10000000000000000n < 1n, false, "0x10000000000000000n < 1n");
assert.sameValue(1n < 0x10000000000000000n, true, "1n < 0x10000000000000000n");
assert.sameValue(0x10000000000000000n < -1n, false, "0x10000000000000000n < -1n");
assert.sameValue(-1n < 0x10000000000000000n, true, "-1n < 0x10000000000000000n");
assert.sameValue(0x10000000000000001n < 0n, false, "0x10000000000000001n < 0n");
assert.sameValue(0n < 0x10000000000000001n, true, "0n < 0x10000000000000001n");
assert.sameValue(-0x10000000000000000n < 0n, true, "-0x10000000000000000n < 0n");
assert.sameValue(0n < -0x10000000000000000n, false, "0n < -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n < 1n, true, "-0x10000000000000000n < 1n");
assert.sameValue(1n < -0x10000000000000000n, false, "1n < -0x10000000000000000n");
assert.sameValue(-0x10000000000000000n < -1n, true, "-0x10000000000000000n < -1n");
assert.sameValue(-1n < -0x10000000000000000n, false, "-1n < -0x10000000000000000n");
assert.sameValue(-0x10000000000000001n < 0n, true, "-0x10000000000000001n < 0n");
assert.sameValue(0n < -0x10000000000000001n, false, "0n < -0x10000000000000001n");
assert.sameValue(0x10000000000000000n < 0x100000000n, false, "0x10000000000000000n < 0x100000000n");
assert.sameValue(0x100000000n < 0x10000000000000000n, true, "0x100000000n < 0x10000000000000000n");

20
test/language/expressions/less-than/bigint-and-non-finite.js
View File

@ -19,13 +19,13 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n < Infinity, true);
assert.sameValue(Infinity < 1n, false);
assert.sameValue(-1n < Infinity, true);
assert.sameValue(Infinity < -1n, false);
assert.sameValue(1n < -Infinity, false);
assert.sameValue(-Infinity < 1n, true);
assert.sameValue(-1n < -Infinity, false);
assert.sameValue(-Infinity < -1n, true);
assert.sameValue(0n < NaN, false);
assert.sameValue(NaN < 0n, false);
assert.sameValue(1n < Infinity, true, "1n < Infinity");
assert.sameValue(Infinity < 1n, false, "Infinity < 1n");
assert.sameValue(-1n < Infinity, true, "-1n < Infinity");
assert.sameValue(Infinity < -1n, false, "Infinity < -1n");
assert.sameValue(1n < -Infinity, false, "1n < -Infinity");
assert.sameValue(-Infinity < 1n, true, "-Infinity < 1n");
assert.sameValue(-1n < -Infinity, false, "-1n < -Infinity");
assert.sameValue(-Infinity < -1n, true, "-Infinity < -1n");
assert.sameValue(0n < NaN, false, "0n < NaN");
assert.sameValue(NaN < 0n, false, "NaN < 0n");

20
test/language/expressions/less-than/bigint-and-number-extremes.js
View File

@ -20,19 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(1n < Number.MAX_VALUE, true);
assert.sameValue(Number.MAX_VALUE < 1n, false);
assert.sameValue(1n < -Number.MAX_VALUE, false);
assert.sameValue(-Number.MAX_VALUE < 1n, true);
assert.sameValue(1n < Number.MAX_VALUE, true, "1n < Number.MAX_VALUE");
assert.sameValue(Number.MAX_VALUE < 1n, false, "Number.MAX_VALUE < 1n");
assert.sameValue(1n < -Number.MAX_VALUE, false, "1n < -Number.MAX_VALUE");
assert.sameValue(-Number.MAX_VALUE < 1n, true, "-Number.MAX_VALUE < 1n");
assert.sameValue(
0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn < Number.MAX_VALUE,
true);
true,
"0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn < Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE < 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
false);
false,
"Number.MAX_VALUE < 0xfffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn");
assert.sameValue(
0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n < Number.MAX_VALUE,
false);
false,
"0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n < Number.MAX_VALUE");
assert.sameValue(
Number.MAX_VALUE < 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n,
true);
true,
"Number.MAX_VALUE < 0xfffffffffffff800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001n");

40
test/language/expressions/less-than/bigint-and-number.js
View File

@ -20,23 +20,23 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n < 0, false);
assert.sameValue(0 < 0n, false);
assert.sameValue(0n < -0, false);
assert.sameValue(-0 < 0n, false);
assert.sameValue(0n < 0.000000000001, true);
assert.sameValue(0.000000000001 < 0n, false);
assert.sameValue(0n < 1, true);
assert.sameValue(1 < 0n, false);
assert.sameValue(1n < 0, false);
assert.sameValue(0 < 1n, true);
assert.sameValue(1n < 0.999999999999, false);
assert.sameValue(0.999999999999 < 1n, true);
assert.sameValue(1n < 1, false);
assert.sameValue(1 < 1n, false);
assert.sameValue(0n < Number.MIN_VALUE, true);
assert.sameValue(Number.MIN_VALUE < 0n, false);
assert.sameValue(0n < -Number.MIN_VALUE, false);
assert.sameValue(-Number.MIN_VALUE < 0n, true);
assert.sameValue(-10n < Number.MIN_VALUE, true);
assert.sameValue(Number.MIN_VALUE < -10n, false);
assert.sameValue(0n < 0, false, "0n < 0");
assert.sameValue(0 < 0n, false, "0 < 0n");
assert.sameValue(0n < -0, false, "0n < -0");
assert.sameValue(-0 < 0n, false, "-0 < 0n");
assert.sameValue(0n < 0.000000000001, true, "0n < 0.000000000001");
assert.sameValue(0.000000000001 < 0n, false, "0.000000000001 < 0n");
assert.sameValue(0n < 1, true, "0n < 1");
assert.sameValue(1 < 0n, false, "1 < 0n");
assert.sameValue(1n < 0, false, "1n < 0");
assert.sameValue(0 < 1n, true, "0 < 1n");
assert.sameValue(1n < 0.999999999999, false, "1n < 0.999999999999");
assert.sameValue(0.999999999999 < 1n, true, "0.999999999999 < 1n");
assert.sameValue(1n < 1, false, "1n < 1");
assert.sameValue(1 < 1n, false, "1 < 1n");
assert.sameValue(0n < Number.MIN_VALUE, true, "0n < Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE < 0n, false, "Number.MIN_VALUE < 0n");
assert.sameValue(0n < -Number.MIN_VALUE, false, "0n < -Number.MIN_VALUE");
assert.sameValue(-Number.MIN_VALUE < 0n, true, "-Number.MIN_VALUE < 0n");
assert.sameValue(-10n < Number.MIN_VALUE, true, "-10n < Number.MIN_VALUE");
assert.sameValue(Number.MIN_VALUE < -10n, false, "Number.MIN_VALUE < -10n");