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

Merge pull request #1263 from thejoshwolfe/messages 

Add messages to asserts and use mixed quotes instead of escapes
This commit is contained in:
Leo Balter 2017-10-06 12:34:04 -04:00 committed by GitHub
parent b8abd71305 5cffebca94
commit 9915c713c6
28 changed files with 492 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
test/language/expressions/does-not-equals/bigint-and-incomparable-primitive.js
View File

@ -21,7 +21,7 @@ assert.sameValue(0n != null, true, "0n != null");
assert.sameValue(null != 0n, true, "null != 0n");
assert.sameValue(1n != null, true, "1n != null");
assert.sameValue(null != 1n, true, "null != 1n");
assert.sameValue(0n != Symbol("1"), true, "0n != Symbol(\"1\")");
assert.sameValue(Symbol("1") != 0n, true, "Symbol(\"1\") != 0n");
assert.sameValue(1n != Symbol("1"), true, "1n != Symbol(\"1\")");
assert.sameValue(Symbol("1") != 1n, true, "Symbol(\"1\") != 1n");
assert.sameValue(0n != Symbol("1"), true, '0n != Symbol("1")');
assert.sameValue(Symbol("1") != 0n, true, 'Symbol("1") != 0n');
assert.sameValue(1n != Symbol("1"), true, '1n != Symbol("1")');
assert.sameValue(Symbol("1") != 1n, true, 'Symbol("1") != 1n');

16
test/language/expressions/does-not-equals/bigint-and-object.js
View File

@ -42,15 +42,15 @@ assert.sameValue(0n != {valueOf: function() { return 0n; }}, false, "0n != {valu
assert.sameValue({valueOf: function() { return 0n; }} != 0n, false, "{valueOf: function() { return 0n; }} != 0n");
assert.sameValue(0n != {valueOf: function() { return 1n; }}, true, "0n != {valueOf: function() { return 1n; }}");
assert.sameValue({valueOf: function() { return 1n; }} != 0n, true, "{valueOf: function() { return 1n; }} != 0n");
assert.sameValue(0n != {toString: function() { return "0"; }}, false, "0n != {toString: function() { return \"0\"; }}");
assert.sameValue({toString: function() { return "0"; }} != 0n, false, "{toString: function() { return \"0\"; }} != 0n");
assert.sameValue(0n != {toString: function() { return "1"; }}, true, "0n != {toString: function() { return \"1\"; }}");
assert.sameValue({toString: function() { return "1"; }} != 0n, true, "{toString: function() { return \"1\"; }} != 0n");
assert.sameValue(0n != {toString: function() { return "0"; }}, false, '0n != {toString: function() { return "0"; }}');
assert.sameValue({toString: function() { return "0"; }} != 0n, false, '{toString: function() { return "0"; }} != 0n');
assert.sameValue(0n != {toString: function() { return "1"; }}, true, '0n != {toString: function() { return "1"; }}');
assert.sameValue({toString: function() { return "1"; }} != 0n, true, '{toString: function() { return "1"; }} != 0n');
assert.sameValue(900719925474099101n != {valueOf: function() { return 900719925474099101n; }}, false, "900719925474099101n != {valueOf: function() { return 900719925474099101n; }}");
assert.sameValue({valueOf: function() { return 900719925474099101n; }} != 900719925474099101n, false, "{valueOf: function() { return 900719925474099101n; }} != 900719925474099101n");
assert.sameValue(900719925474099101n != {valueOf: function() { return 900719925474099102n; }}, true, "900719925474099101n != {valueOf: function() { return 900719925474099102n; }}");
assert.sameValue({valueOf: function() { return 900719925474099102n; }} != 900719925474099101n, true, "{valueOf: function() { return 900719925474099102n; }} != 900719925474099101n");
assert.sameValue(900719925474099101n != {toString: function() { return "900719925474099101"; }}, false, "900719925474099101n != {toString: function() { return \"900719925474099101\"; }}");
assert.sameValue({toString: function() { return "900719925474099101"; }} != 900719925474099101n, false, "{toString: function() { return \"900719925474099101\"; }} != 900719925474099101n");
assert.sameValue(900719925474099101n != {toString: function() { return "900719925474099102"; }}, true, "900719925474099101n != {toString: function() { return \"900719925474099102\"; }}");
assert.sameValue({toString: function() { return "900719925474099102"; }} != 900719925474099101n, true, "{toString: function() { return \"900719925474099102\"; }} != 900719925474099101n");
assert.sameValue(900719925474099101n != {toString: function() { return "900719925474099101"; }}, false, '900719925474099101n != {toString: function() { return "900719925474099101"; }}');
assert.sameValue({toString: function() { return "900719925474099101"; }} != 900719925474099101n, false, '{toString: function() { return "900719925474099101"; }} != 900719925474099101n');
assert.sameValue(900719925474099101n != {toString: function() { return "900719925474099102"; }}, true, '900719925474099101n != {toString: function() { return "900719925474099102"; }}');
assert.sameValue({toString: function() { return "900719925474099102"; }} != 900719925474099101n, true, '{toString: function() { return "900719925474099102"; }} != 900719925474099101n');

72
test/language/expressions/does-not-equals/bigint-and-string.js
View File

@ -10,39 +10,39 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n != "", false, "0n != \"\"");
assert.sameValue("" != 0n, false, "\"\" != 0n");
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 != "-1", true, "0n != \"-1\"");
assert.sameValue("-1" != 0n, true, "\"-1\" != 0n");
assert.sameValue(0n != "1", true, "0n != \"1\"");
assert.sameValue("1" != 0n, true, "\"1\" != 0n");
assert.sameValue(0n != "foo", true, "0n != \"foo\"");
assert.sameValue("foo" != 0n, true, "\"foo\" != 0n");
assert.sameValue(1n != "", true, "1n != \"\"");
assert.sameValue("" != 1n, true, "\"\" != 1n");
assert.sameValue(1n != "-0", true, "1n != \"-0\"");
assert.sameValue("-0" != 1n, true, "\"-0\" != 1n");
assert.sameValue(1n != "0", true, "1n != \"0\"");
assert.sameValue("0" != 1n, true, "\"0\" != 1n");
assert.sameValue(1n != "-1", true, "1n != \"-1\"");
assert.sameValue("-1" != 1n, true, "\"-1\" != 1n");
assert.sameValue(1n != "1", false, "1n != \"1\"");
assert.sameValue("1" != 1n, false, "\"1\" != 1n");
assert.sameValue(1n != "foo", true, "1n != \"foo\"");
assert.sameValue("foo" != 1n, true, "\"foo\" != 1n");
assert.sameValue(-1n != "-", true, "-1n != \"-\"");
assert.sameValue("-" != -1n, true, "\"-\" != -1n");
assert.sameValue(-1n != "-0", true, "-1n != \"-0\"");
assert.sameValue("-0" != -1n, true, "\"-0\" != -1n");
assert.sameValue(-1n != "-1", false, "-1n != \"-1\"");
assert.sameValue("-1" != -1n, false, "\"-1\" != -1n");
assert.sameValue(-1n != "-foo", true, "-1n != \"-foo\"");
assert.sameValue("-foo" != -1n, true, "\"-foo\" != -1n");
assert.sameValue(900719925474099101n != "900719925474099101", false, "900719925474099101n != \"900719925474099101\"");
assert.sameValue("900719925474099101" != 900719925474099101n, false, "\"900719925474099101\" != 900719925474099101n");
assert.sameValue(900719925474099102n != "900719925474099101", true, "900719925474099102n != \"900719925474099101\"");
assert.sameValue("900719925474099101" != 900719925474099102n, true, "\"900719925474099101\" != 900719925474099102n");
assert.sameValue(0n != "", false, '0n != ""');
assert.sameValue("" != 0n, false, '"" != 0n');
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 != "-1", true, '0n != "-1"');
assert.sameValue("-1" != 0n, true, '"-1" != 0n');
assert.sameValue(0n != "1", true, '0n != "1"');
assert.sameValue("1" != 0n, true, '"1" != 0n');
assert.sameValue(0n != "foo", true, '0n != "foo"');
assert.sameValue("foo" != 0n, true, '"foo" != 0n');
assert.sameValue(1n != "", true, '1n != ""');
assert.sameValue("" != 1n, true, '"" != 1n');
assert.sameValue(1n != "-0", true, '1n != "-0"');
assert.sameValue("-0" != 1n, true, '"-0" != 1n');
assert.sameValue(1n != "0", true, '1n != "0"');
assert.sameValue("0" != 1n, true, '"0" != 1n');
assert.sameValue(1n != "-1", true, '1n != "-1"');
assert.sameValue("-1" != 1n, true, '"-1" != 1n');
assert.sameValue(1n != "1", false, '1n != "1"');
assert.sameValue("1" != 1n, false, '"1" != 1n');
assert.sameValue(1n != "foo", true, '1n != "foo"');
assert.sameValue("foo" != 1n, true, '"foo" != 1n');
assert.sameValue(-1n != "-", true, '-1n != "-"');
assert.sameValue("-" != -1n, true, '"-" != -1n');
assert.sameValue(-1n != "-0", true, '-1n != "-0"');
assert.sameValue("-0" != -1n, true, '"-0" != -1n');
assert.sameValue(-1n != "-1", false, '-1n != "-1"');
assert.sameValue("-1" != -1n, false, '"-1" != -1n');
assert.sameValue(-1n != "-foo", true, '-1n != "-foo"');
assert.sameValue("-foo" != -1n, true, '"-foo" != -1n');
assert.sameValue(900719925474099101n != "900719925474099101", false, '900719925474099101n != "900719925474099101"');
assert.sameValue("900719925474099101" != 900719925474099101n, false, '"900719925474099101" != 900719925474099101n');
assert.sameValue(900719925474099102n != "900719925474099101", true, '900719925474099102n != "900719925474099101"');
assert.sameValue("900719925474099101" != 900719925474099102n, true, '"900719925474099101" != 900719925474099102n');

8
test/language/expressions/equals/bigint-and-incomparable-primitive.js
View File

@ -20,7 +20,7 @@ assert.sameValue(0n == null, false, "0n == null");
assert.sameValue(null == 0n, false, "null == 0n");
assert.sameValue(1n == null, false, "1n == null");
assert.sameValue(null == 1n, false, "null == 1n");
assert.sameValue(0n == Symbol("1"), false, "0n == Symbol(\"1\")");
assert.sameValue(Symbol("1") == 0n, false, "Symbol(\"1\") == 0n");
assert.sameValue(1n == Symbol("1"), false, "1n == Symbol(\"1\")");
assert.sameValue(Symbol("1") == 1n, false, "Symbol(\"1\") == 1n");
assert.sameValue(0n == Symbol("1"), false, '0n == Symbol("1")');
assert.sameValue(Symbol("1") == 0n, false, 'Symbol("1") == 0n');
assert.sameValue(1n == Symbol("1"), false, '1n == Symbol("1")');
assert.sameValue(Symbol("1") == 1n, false, 'Symbol("1") == 1n');

16
test/language/expressions/equals/bigint-and-object.js
View File

@ -42,15 +42,15 @@ assert.sameValue(0n == {valueOf: function() { return 0n; }}, true, "0n == {value
assert.sameValue({valueOf: function() { return 0n; }} == 0n, true, "{valueOf: function() { return 0n; }} == 0n");
assert.sameValue(0n == {valueOf: function() { return 1n; }}, false, "0n == {valueOf: function() { return 1n; }}");
assert.sameValue({valueOf: function() { return 1n; }} == 0n, false, "{valueOf: function() { return 1n; }} == 0n");
assert.sameValue(0n == {toString: function() { return "0"; }}, true, "0n == {toString: function() { return \"0\"; }}");
assert.sameValue({toString: function() { return "0"; }} == 0n, true, "{toString: function() { return \"0\"; }} == 0n");
assert.sameValue(0n == {toString: function() { return "1"; }}, false, "0n == {toString: function() { return \"1\"; }}");
assert.sameValue({toString: function() { return "1"; }} == 0n, false, "{toString: function() { return \"1\"; }} == 0n");
assert.sameValue(0n == {toString: function() { return "0"; }}, true, '0n == {toString: function() { return "0"; }}');
assert.sameValue({toString: function() { return "0"; }} == 0n, true, '{toString: function() { return "0"; }} == 0n');
assert.sameValue(0n == {toString: function() { return "1"; }}, false, '0n == {toString: function() { return "1"; }}');
assert.sameValue({toString: function() { return "1"; }} == 0n, false, '{toString: function() { return "1"; }} == 0n');
assert.sameValue(900719925474099101n == {valueOf: function() { return 900719925474099101n; }}, true, "900719925474099101n == {valueOf: function() { return 900719925474099101n; }}");
assert.sameValue({valueOf: function() { return 900719925474099101n; }} == 900719925474099101n, true, "{valueOf: function() { return 900719925474099101n; }} == 900719925474099101n");
assert.sameValue(900719925474099101n == {valueOf: function() { return 900719925474099102n; }}, false, "900719925474099101n == {valueOf: function() { return 900719925474099102n; }}");
assert.sameValue({valueOf: function() { return 900719925474099102n; }} == 900719925474099101n, false, "{valueOf: function() { return 900719925474099102n; }} == 900719925474099101n");
assert.sameValue(900719925474099101n == {toString: function() { return "900719925474099101"; }}, true, "900719925474099101n == {toString: function() { return \"900719925474099101\"; }}");
assert.sameValue({toString: function() { return "900719925474099101"; }} == 900719925474099101n, true, "{toString: function() { return \"900719925474099101\"; }} == 900719925474099101n");
assert.sameValue(900719925474099101n == {toString: function() { return "900719925474099102"; }}, false, "900719925474099101n == {toString: function() { return \"900719925474099102\"; }}");
assert.sameValue({toString: function() { return "900719925474099102"; }} == 900719925474099101n, false, "{toString: function() { return \"900719925474099102\"; }} == 900719925474099101n");
assert.sameValue(900719925474099101n == {toString: function() { return "900719925474099101"; }}, true, '900719925474099101n == {toString: function() { return "900719925474099101"; }}');
assert.sameValue({toString: function() { return "900719925474099101"; }} == 900719925474099101n, true, '{toString: function() { return "900719925474099101"; }} == 900719925474099101n');
assert.sameValue(900719925474099101n == {toString: function() { return "900719925474099102"; }}, false, '900719925474099101n == {toString: function() { return "900719925474099102"; }}');
assert.sameValue({toString: function() { return "900719925474099102"; }} == 900719925474099101n, false, '{toString: function() { return "900719925474099102"; }} == 900719925474099101n');

72
test/language/expressions/equals/bigint-and-string.js
View File

@ -10,39 +10,39 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n == "", true, "0n == \"\"");
assert.sameValue("" == 0n, true, "\"\" == 0n");
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 == "-1", false, "0n == \"-1\"");
assert.sameValue("-1" == 0n, false, "\"-1\" == 0n");
assert.sameValue(0n == "1", false, "0n == \"1\"");
assert.sameValue("1" == 0n, false, "\"1\" == 0n");
assert.sameValue(0n == "foo", false, "0n == \"foo\"");
assert.sameValue("foo" == 0n, false, "\"foo\" == 0n");
assert.sameValue(1n == "", false, "1n == \"\"");
assert.sameValue("" == 1n, false, "\"\" == 1n");
assert.sameValue(1n == "-0", false, "1n == \"-0\"");
assert.sameValue("-0" == 1n, false, "\"-0\" == 1n");
assert.sameValue(1n == "0", false, "1n == \"0\"");
assert.sameValue("0" == 1n, false, "\"0\" == 1n");
assert.sameValue(1n == "-1", false, "1n == \"-1\"");
assert.sameValue("-1" == 1n, false, "\"-1\" == 1n");
assert.sameValue(1n == "1", true, "1n == \"1\"");
assert.sameValue("1" == 1n, true, "\"1\" == 1n");
assert.sameValue(1n == "foo", false, "1n == \"foo\"");
assert.sameValue("foo" == 1n, false, "\"foo\" == 1n");
assert.sameValue(-1n == "-", false, "-1n == \"-\"");
assert.sameValue("-" == -1n, false, "\"-\" == -1n");
assert.sameValue(-1n == "-0", false, "-1n == \"-0\"");
assert.sameValue("-0" == -1n, false, "\"-0\" == -1n");
assert.sameValue(-1n == "-1", true, "-1n == \"-1\"");
assert.sameValue("-1" == -1n, true, "\"-1\" == -1n");
assert.sameValue(-1n == "-foo", false, "-1n == \"-foo\"");
assert.sameValue("-foo" == -1n, false, "\"-foo\" == -1n");
assert.sameValue(900719925474099101n == "900719925474099101", true, "900719925474099101n == \"900719925474099101\"");
assert.sameValue("900719925474099101" == 900719925474099101n, true, "\"900719925474099101\" == 900719925474099101n");
assert.sameValue(900719925474099102n == "900719925474099101", false, "900719925474099102n == \"900719925474099101\"");
assert.sameValue("900719925474099101" == 900719925474099102n, false, "\"900719925474099101\" == 900719925474099102n");
assert.sameValue(0n == "", true, '0n == ""');
assert.sameValue("" == 0n, true, '"" == 0n');
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 == "-1", false, '0n == "-1"');
assert.sameValue("-1" == 0n, false, '"-1" == 0n');
assert.sameValue(0n == "1", false, '0n == "1"');
assert.sameValue("1" == 0n, false, '"1" == 0n');
assert.sameValue(0n == "foo", false, '0n == "foo"');
assert.sameValue("foo" == 0n, false, '"foo" == 0n');
assert.sameValue(1n == "", false, '1n == ""');
assert.sameValue("" == 1n, false, '"" == 1n');
assert.sameValue(1n == "-0", false, '1n == "-0"');
assert.sameValue("-0" == 1n, false, '"-0" == 1n');
assert.sameValue(1n == "0", false, '1n == "0"');
assert.sameValue("0" == 1n, false, '"0" == 1n');
assert.sameValue(1n == "-1", false, '1n == "-1"');
assert.sameValue("-1" == 1n, false, '"-1" == 1n');
assert.sameValue(1n == "1", true, '1n == "1"');
assert.sameValue("1" == 1n, true, '"1" == 1n');
assert.sameValue(1n == "foo", false, '1n == "foo"');
assert.sameValue("foo" == 1n, false, '"foo" == 1n');
assert.sameValue(-1n == "-", false, '-1n == "-"');
assert.sameValue("-" == -1n, false, '"-" == -1n');
assert.sameValue(-1n == "-0", false, '-1n == "-0"');
assert.sameValue("-0" == -1n, false, '"-0" == -1n');
assert.sameValue(-1n == "-1", true, '-1n == "-1"');
assert.sameValue("-1" == -1n, true, '"-1" == -1n');
assert.sameValue(-1n == "-foo", false, '-1n == "-foo"');
assert.sameValue("-foo" == -1n, false, '"-foo" == -1n');
assert.sameValue(900719925474099101n == "900719925474099101", true, '900719925474099101n == "900719925474099101"');
assert.sameValue("900719925474099101" == 900719925474099101n, true, '"900719925474099101" == 900719925474099101n');
assert.sameValue(900719925474099102n == "900719925474099101", false, '900719925474099102n == "900719925474099101"');
assert.sameValue("900719925474099101" == 900719925474099102n, false, '"900719925474099101" == 900719925474099102n');

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");

8
test/language/expressions/strict-does-not-equals/bigint-and-incomparable-primitive.js
View File

@ -18,7 +18,7 @@ assert.sameValue(0n !== null, true, "0n !== null");
assert.sameValue(null !== 0n, true, "null !== 0n");
assert.sameValue(1n !== null, true, "1n !== null");
assert.sameValue(null !== 1n, true, "null !== 1n");
assert.sameValue(0n !== Symbol("1"), true, "0n !== Symbol(\"1\")");
assert.sameValue(Symbol("1") !== 0n, true, "Symbol(\"1\") !== 0n");
assert.sameValue(1n !== Symbol("1"), true, "1n !== Symbol(\"1\")");
assert.sameValue(Symbol("1") !== 1n, true, "Symbol(\"1\") !== 1n");
assert.sameValue(0n !== Symbol("1"), true, '0n !== Symbol("1")');
assert.sameValue(Symbol("1") !== 0n, true, 'Symbol("1") !== 0n');
assert.sameValue(1n !== Symbol("1"), true, '1n !== Symbol("1")');
assert.sameValue(Symbol("1") !== 1n, true, 'Symbol("1") !== 1n');

16
test/language/expressions/strict-does-not-equals/bigint-and-object.js
View File

@ -30,15 +30,15 @@ assert.sameValue(0n !== {valueOf: function() { return 0n; }}, true, "0n !== {val
assert.sameValue({valueOf: function() { return 0n; }} !== 0n, true, "{valueOf: function() { return 0n; }} !== 0n");
assert.sameValue(0n !== {valueOf: function() { return 1n; }}, true, "0n !== {valueOf: function() { return 1n; }}");
assert.sameValue({valueOf: function() { return 1n; }} !== 0n, true, "{valueOf: function() { return 1n; }} !== 0n");
assert.sameValue(0n !== {toString: function() { return "0"; }}, true, "0n !== {toString: function() { return \"0\"; }}");
assert.sameValue({toString: function() { return "0"; }} !== 0n, true, "{toString: function() { return \"0\"; }} !== 0n");
assert.sameValue(0n !== {toString: function() { return "1"; }}, true, "0n !== {toString: function() { return \"1\"; }}");
assert.sameValue({toString: function() { return "1"; }} !== 0n, true, "{toString: function() { return \"1\"; }} !== 0n");
assert.sameValue(0n !== {toString: function() { return "0"; }}, true, '0n !== {toString: function() { return "0"; }}');
assert.sameValue({toString: function() { return "0"; }} !== 0n, true, '{toString: function() { return "0"; }} !== 0n');
assert.sameValue(0n !== {toString: function() { return "1"; }}, true, '0n !== {toString: function() { return "1"; }}');
assert.sameValue({toString: function() { return "1"; }} !== 0n, true, '{toString: function() { return "1"; }} !== 0n');
assert.sameValue(900719925474099101n !== {valueOf: function() { return 900719925474099101n; }}, true, "900719925474099101n !== {valueOf: function() { return 900719925474099101n; }}");
assert.sameValue({valueOf: function() { return 900719925474099101n; }} !== 900719925474099101n, true, "{valueOf: function() { return 900719925474099101n; }} !== 900719925474099101n");
assert.sameValue(900719925474099101n !== {valueOf: function() { return 900719925474099102n; }}, true, "900719925474099101n !== {valueOf: function() { return 900719925474099102n; }}");
assert.sameValue({valueOf: function() { return 900719925474099102n; }} !== 900719925474099101n, true, "{valueOf: function() { return 900719925474099102n; }} !== 900719925474099101n");
assert.sameValue(900719925474099101n !== {toString: function() { return "900719925474099101"; }}, true, "900719925474099101n !== {toString: function() { return \"900719925474099101\"; }}");
assert.sameValue({toString: function() { return "900719925474099101"; }} !== 900719925474099101n, true, "{toString: function() { return \"900719925474099101\"; }} !== 900719925474099101n");
assert.sameValue(900719925474099101n !== {toString: function() { return "900719925474099102"; }}, true, "900719925474099101n !== {toString: function() { return \"900719925474099102\"; }}");
assert.sameValue({toString: function() { return "900719925474099102"; }} !== 900719925474099101n, true, "{toString: function() { return \"900719925474099102\"; }} !== 900719925474099101n");
assert.sameValue(900719925474099101n !== {toString: function() { return "900719925474099101"; }}, true, '900719925474099101n !== {toString: function() { return "900719925474099101"; }}');
assert.sameValue({toString: function() { return "900719925474099101"; }} !== 900719925474099101n, true, '{toString: function() { return "900719925474099101"; }} !== 900719925474099101n');
assert.sameValue(900719925474099101n !== {toString: function() { return "900719925474099102"; }}, true, '900719925474099101n !== {toString: function() { return "900719925474099102"; }}');
assert.sameValue({toString: function() { return "900719925474099102"; }} !== 900719925474099101n, true, '{toString: function() { return "900719925474099102"; }} !== 900719925474099101n');

72
test/language/expressions/strict-does-not-equals/bigint-and-string.js
View File

@ -10,39 +10,39 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n !== "", true, "0n !== \"\"");
assert.sameValue("" !== 0n, true, "\"\" !== 0n");
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 !== "-1", true, "0n !== \"-1\"");
assert.sameValue("-1" !== 0n, true, "\"-1\" !== 0n");
assert.sameValue(0n !== "1", true, "0n !== \"1\"");
assert.sameValue("1" !== 0n, true, "\"1\" !== 0n");
assert.sameValue(0n !== "foo", true, "0n !== \"foo\"");
assert.sameValue("foo" !== 0n, true, "\"foo\" !== 0n");
assert.sameValue(1n !== "", true, "1n !== \"\"");
assert.sameValue("" !== 1n, true, "\"\" !== 1n");
assert.sameValue(1n !== "-0", true, "1n !== \"-0\"");
assert.sameValue("-0" !== 1n, true, "\"-0\" !== 1n");
assert.sameValue(1n !== "0", true, "1n !== \"0\"");
assert.sameValue("0" !== 1n, true, "\"0\" !== 1n");
assert.sameValue(1n !== "-1", true, "1n !== \"-1\"");
assert.sameValue("-1" !== 1n, true, "\"-1\" !== 1n");
assert.sameValue(1n !== "1", true, "1n !== \"1\"");
assert.sameValue("1" !== 1n, true, "\"1\" !== 1n");
assert.sameValue(1n !== "foo", true, "1n !== \"foo\"");
assert.sameValue("foo" !== 1n, true, "\"foo\" !== 1n");
assert.sameValue(-1n !== "-", true, "-1n !== \"-\"");
assert.sameValue("-" !== -1n, true, "\"-\" !== -1n");
assert.sameValue(-1n !== "-0", true, "-1n !== \"-0\"");
assert.sameValue("-0" !== -1n, true, "\"-0\" !== -1n");
assert.sameValue(-1n !== "-1", true, "-1n !== \"-1\"");
assert.sameValue("-1" !== -1n, true, "\"-1\" !== -1n");
assert.sameValue(-1n !== "-foo", true, "-1n !== \"-foo\"");
assert.sameValue("-foo" !== -1n, true, "\"-foo\" !== -1n");
assert.sameValue(900719925474099101n !== "900719925474099101", true, "900719925474099101n !== \"900719925474099101\"");
assert.sameValue("900719925474099101" !== 900719925474099101n, true, "\"900719925474099101\" !== 900719925474099101n");
assert.sameValue(900719925474099102n !== "900719925474099101", true, "900719925474099102n !== \"900719925474099101\"");
assert.sameValue("900719925474099101" !== 900719925474099102n, true, "\"900719925474099101\" !== 900719925474099102n");
assert.sameValue(0n !== "", true, '0n !== ""');
assert.sameValue("" !== 0n, true, '"" !== 0n');
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 !== "-1", true, '0n !== "-1"');
assert.sameValue("-1" !== 0n, true, '"-1" !== 0n');
assert.sameValue(0n !== "1", true, '0n !== "1"');
assert.sameValue("1" !== 0n, true, '"1" !== 0n');
assert.sameValue(0n !== "foo", true, '0n !== "foo"');
assert.sameValue("foo" !== 0n, true, '"foo" !== 0n');
assert.sameValue(1n !== "", true, '1n !== ""');
assert.sameValue("" !== 1n, true, '"" !== 1n');
assert.sameValue(1n !== "-0", true, '1n !== "-0"');
assert.sameValue("-0" !== 1n, true, '"-0" !== 1n');
assert.sameValue(1n !== "0", true, '1n !== "0"');
assert.sameValue("0" !== 1n, true, '"0" !== 1n');
assert.sameValue(1n !== "-1", true, '1n !== "-1"');
assert.sameValue("-1" !== 1n, true, '"-1" !== 1n');
assert.sameValue(1n !== "1", true, '1n !== "1"');
assert.sameValue("1" !== 1n, true, '"1" !== 1n');
assert.sameValue(1n !== "foo", true, '1n !== "foo"');
assert.sameValue("foo" !== 1n, true, '"foo" !== 1n');
assert.sameValue(-1n !== "-", true, '-1n !== "-"');
assert.sameValue("-" !== -1n, true, '"-" !== -1n');
assert.sameValue(-1n !== "-0", true, '-1n !== "-0"');
assert.sameValue("-0" !== -1n, true, '"-0" !== -1n');
assert.sameValue(-1n !== "-1", true, '-1n !== "-1"');
assert.sameValue("-1" !== -1n, true, '"-1" !== -1n');
assert.sameValue(-1n !== "-foo", true, '-1n !== "-foo"');
assert.sameValue("-foo" !== -1n, true, '"-foo" !== -1n');
assert.sameValue(900719925474099101n !== "900719925474099101", true, '900719925474099101n !== "900719925474099101"');
assert.sameValue("900719925474099101" !== 900719925474099101n, true, '"900719925474099101" !== 900719925474099101n');
assert.sameValue(900719925474099102n !== "900719925474099101", true, '900719925474099102n !== "900719925474099101"');
assert.sameValue("900719925474099101" !== 900719925474099102n, true, '"900719925474099101" !== 900719925474099102n');

8
test/language/expressions/strict-equals/bigint-and-incomparable-primitive.js
View File

@ -18,7 +18,7 @@ assert.sameValue(0n === null, false, "0n === null");
assert.sameValue(null === 0n, false, "null === 0n");
assert.sameValue(1n === null, false, "1n === null");
assert.sameValue(null === 1n, false, "null === 1n");
assert.sameValue(0n === Symbol("1"), false, "0n === Symbol(\"1\")");
assert.sameValue(Symbol("1") === 0n, false, "Symbol(\"1\") === 0n");
assert.sameValue(1n === Symbol("1"), false, "1n === Symbol(\"1\")");
assert.sameValue(Symbol("1") === 1n, false, "Symbol(\"1\") === 1n");
assert.sameValue(0n === Symbol("1"), false, '0n === Symbol("1")');
assert.sameValue(Symbol("1") === 0n, false, 'Symbol("1") === 0n');
assert.sameValue(1n === Symbol("1"), false, '1n === Symbol("1")');
assert.sameValue(Symbol("1") === 1n, false, 'Symbol("1") === 1n');

16
test/language/expressions/strict-equals/bigint-and-object.js
View File

@ -30,15 +30,15 @@ assert.sameValue(0n === {valueOf: function() { return 0n; }}, false, "0n === {va
assert.sameValue({valueOf: function() { return 0n; }} === 0n, false, "{valueOf: function() { return 0n; }} === 0n");
assert.sameValue(0n === {valueOf: function() { return 1n; }}, false, "0n === {valueOf: function() { return 1n; }}");
assert.sameValue({valueOf: function() { return 1n; }} === 0n, false, "{valueOf: function() { return 1n; }} === 0n");
assert.sameValue(0n === {toString: function() { return "0"; }}, false, "0n === {toString: function() { return \"0\"; }}");
assert.sameValue({toString: function() { return "0"; }} === 0n, false, "{toString: function() { return \"0\"; }} === 0n");
assert.sameValue(0n === {toString: function() { return "1"; }}, false, "0n === {toString: function() { return \"1\"; }}");
assert.sameValue({toString: function() { return "1"; }} === 0n, false, "{toString: function() { return \"1\"; }} === 0n");
assert.sameValue(0n === {toString: function() { return "0"; }}, false, '0n === {toString: function() { return "0"; }}');
assert.sameValue({toString: function() { return "0"; }} === 0n, false, '{toString: function() { return "0"; }} === 0n');
assert.sameValue(0n === {toString: function() { return "1"; }}, false, '0n === {toString: function() { return "1"; }}');
assert.sameValue({toString: function() { return "1"; }} === 0n, false, '{toString: function() { return "1"; }} === 0n');
assert.sameValue(900719925474099101n === {valueOf: function() { return 900719925474099101n; }}, false, "900719925474099101n === {valueOf: function() { return 900719925474099101n; }}");
assert.sameValue({valueOf: function() { return 900719925474099101n; }} === 900719925474099101n, false, "{valueOf: function() { return 900719925474099101n; }} === 900719925474099101n");
assert.sameValue(900719925474099101n === {valueOf: function() { return 900719925474099102n; }}, false, "900719925474099101n === {valueOf: function() { return 900719925474099102n; }}");
assert.sameValue({valueOf: function() { return 900719925474099102n; }} === 900719925474099101n, false, "{valueOf: function() { return 900719925474099102n; }} === 900719925474099101n");
assert.sameValue(900719925474099101n === {toString: function() { return "900719925474099101"; }}, false, "900719925474099101n === {toString: function() { return \"900719925474099101\"; }}");
assert.sameValue({toString: function() { return "900719925474099101"; }} === 900719925474099101n, false, "{toString: function() { return \"900719925474099101\"; }} === 900719925474099101n");
assert.sameValue(900719925474099101n === {toString: function() { return "900719925474099102"; }}, false, "900719925474099101n === {toString: function() { return \"900719925474099102\"; }}");
assert.sameValue({toString: function() { return "900719925474099102"; }} === 900719925474099101n, false, "{toString: function() { return \"900719925474099102\"; }} === 900719925474099101n");
assert.sameValue(900719925474099101n === {toString: function() { return "900719925474099101"; }}, false, '900719925474099101n === {toString: function() { return "900719925474099101"; }}');
assert.sameValue({toString: function() { return "900719925474099101"; }} === 900719925474099101n, false, '{toString: function() { return "900719925474099101"; }} === 900719925474099101n');
assert.sameValue(900719925474099101n === {toString: function() { return "900719925474099102"; }}, false, '900719925474099101n === {toString: function() { return "900719925474099102"; }}');
assert.sameValue({toString: function() { return "900719925474099102"; }} === 900719925474099101n, false, '{toString: function() { return "900719925474099102"; }} === 900719925474099101n');

72
test/language/expressions/strict-equals/bigint-and-string.js
View File

@ -10,39 +10,39 @@ info: |
features: [BigInt]
---*/
assert.sameValue(0n === "", false, "0n === \"\"");
assert.sameValue("" === 0n, false, "\"\" === 0n");
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 === "-1", false, "0n === \"-1\"");
assert.sameValue("-1" === 0n, false, "\"-1\" === 0n");
assert.sameValue(0n === "1", false, "0n === \"1\"");
assert.sameValue("1" === 0n, false, "\"1\" === 0n");
assert.sameValue(0n === "foo", false, "0n === \"foo\"");
assert.sameValue("foo" === 0n, false, "\"foo\" === 0n");
assert.sameValue(1n === "", false, "1n === \"\"");
assert.sameValue("" === 1n, false, "\"\" === 1n");
assert.sameValue(1n === "-0", false, "1n === \"-0\"");
assert.sameValue("-0" === 1n, false, "\"-0\" === 1n");
assert.sameValue(1n === "0", false, "1n === \"0\"");
assert.sameValue("0" === 1n, false, "\"0\" === 1n");
assert.sameValue(1n === "-1", false, "1n === \"-1\"");
assert.sameValue("-1" === 1n, false, "\"-1\" === 1n");
assert.sameValue(1n === "1", false, "1n === \"1\"");
assert.sameValue("1" === 1n, false, "\"1\" === 1n");
assert.sameValue(1n === "foo", false, "1n === \"foo\"");
assert.sameValue("foo" === 1n, false, "\"foo\" === 1n");
assert.sameValue(-1n === "-", false, "-1n === \"-\"");
assert.sameValue("-" === -1n, false, "\"-\" === -1n");
assert.sameValue(-1n === "-0", false, "-1n === \"-0\"");
assert.sameValue("-0" === -1n, false, "\"-0\" === -1n");
assert.sameValue(-1n === "-1", false, "-1n === \"-1\"");
assert.sameValue("-1" === -1n, false, "\"-1\" === -1n");
assert.sameValue(-1n === "-foo", false, "-1n === \"-foo\"");
assert.sameValue("-foo" === -1n, false, "\"-foo\" === -1n");
assert.sameValue(900719925474099101n === "900719925474099101", false, "900719925474099101n === \"900719925474099101\"");
assert.sameValue("900719925474099101" === 900719925474099101n, false, "\"900719925474099101\" === 900719925474099101n");
assert.sameValue(900719925474099102n === "900719925474099101", false, "900719925474099102n === \"900719925474099101\"");
assert.sameValue("900719925474099101" === 900719925474099102n, false, "\"900719925474099101\" === 900719925474099102n");
assert.sameValue(0n === "", false, '0n === ""');
assert.sameValue("" === 0n, false, '"" === 0n');
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 === "-1", false, '0n === "-1"');
assert.sameValue("-1" === 0n, false, '"-1" === 0n');
assert.sameValue(0n === "1", false, '0n === "1"');
assert.sameValue("1" === 0n, false, '"1" === 0n');
assert.sameValue(0n === "foo", false, '0n === "foo"');
assert.sameValue("foo" === 0n, false, '"foo" === 0n');
assert.sameValue(1n === "", false, '1n === ""');
assert.sameValue("" === 1n, false, '"" === 1n');
assert.sameValue(1n === "-0", false, '1n === "-0"');
assert.sameValue("-0" === 1n, false, '"-0" === 1n');
assert.sameValue(1n === "0", false, '1n === "0"');
assert.sameValue("0" === 1n, false, '"0" === 1n');
assert.sameValue(1n === "-1", false, '1n === "-1"');
assert.sameValue("-1" === 1n, false, '"-1" === 1n');
assert.sameValue(1n === "1", false, '1n === "1"');
assert.sameValue("1" === 1n, false, '"1" === 1n');
assert.sameValue(1n === "foo", false, '1n === "foo"');
assert.sameValue("foo" === 1n, false, '"foo" === 1n');
assert.sameValue(-1n === "-", false, '-1n === "-"');
assert.sameValue("-" === -1n, false, '"-" === -1n');
assert.sameValue(-1n === "-0", false, '-1n === "-0"');
assert.sameValue("-0" === -1n, false, '"-0" === -1n');
assert.sameValue(-1n === "-1", false, '-1n === "-1"');
assert.sameValue("-1" === -1n, false, '"-1" === -1n');
assert.sameValue(-1n === "-foo", false, '-1n === "-foo"');
assert.sameValue("-foo" === -1n, false, '"-foo" === -1n');
assert.sameValue(900719925474099101n === "900719925474099101", false, '900719925474099101n === "900719925474099101"');
assert.sameValue("900719925474099101" === 900719925474099101n, false, '"900719925474099101" === 900719925474099101n');
assert.sameValue(900719925474099102n === "900719925474099101", false, '900719925474099102n === "900719925474099101"');
assert.sameValue("900719925474099101" === 900719925474099102n, false, '"900719925474099101" === 900719925474099102n');