diff --git a/test/language/expressions/greater-than-or-equal/bigint-and-bigint.js b/test/language/expressions/greater-than-or-equal/bigint-and-bigint.js
index 01e8a9cb7253ce28f1ce89b38a12c0fc21fd840a..6ce429669a1906d8017a817e165642751ffdc246 100644
--- a/test/language/expressions/greater-than-or-equal/bigint-and-bigint.js
+++ b/test/language/expressions/greater-than-or-equal/bigint-and-bigint.js
@@ -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");
diff --git a/test/language/expressions/greater-than-or-equal/bigint-and-non-finite.js b/test/language/expressions/greater-than-or-equal/bigint-and-non-finite.js
index a3f84924f064137c5e7f34b34006a5f094680c8b..f3af1b04ecbd6d6bf39cbdd00da436f40016c834 100644
--- a/test/language/expressions/greater-than-or-equal/bigint-and-non-finite.js
+++ b/test/language/expressions/greater-than-or-equal/bigint-and-non-finite.js
@@ -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");
diff --git a/test/language/expressions/greater-than-or-equal/bigint-and-number-extremes.js b/test/language/expressions/greater-than-or-equal/bigint-and-number-extremes.js
index ea0a725c78942de5d5b215d8775c840d1c4261cf..64657ac9e036ea51fd0593c0ef75f0282c2418ce 100644
--- a/test/language/expressions/greater-than-or-equal/bigint-and-number-extremes.js
+++ b/test/language/expressions/greater-than-or-equal/bigint-and-number-extremes.js
@@ -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");
diff --git a/test/language/expressions/greater-than-or-equal/bigint-and-number.js b/test/language/expressions/greater-than-or-equal/bigint-and-number.js
index 63890b9e3fd5c1921d230cd62ea4fb2a63d81eed..c2cd2949a6beeb8a325e646b52c7c23ccc3e6ce7 100644
--- a/test/language/expressions/greater-than-or-equal/bigint-and-number.js
+++ b/test/language/expressions/greater-than-or-equal/bigint-and-number.js
@@ -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");
diff --git a/test/language/expressions/greater-than/bigint-and-bigint.js b/test/language/expressions/greater-than/bigint-and-bigint.js
index fb627431876601239607ef581078839c5ca2357a..c9f06fb44d784dc7beb0677a1acf8163a63525a0 100644
--- a/test/language/expressions/greater-than/bigint-and-bigint.js
+++ b/test/language/expressions/greater-than/bigint-and-bigint.js
@@ -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");
diff --git a/test/language/expressions/greater-than/bigint-and-non-finite.js b/test/language/expressions/greater-than/bigint-and-non-finite.js
index f1efc83dacac4d2e0b9fa35d98c6f1f98abb1804..71b88c6647ac91e583e637b64a1ff3ee0c5578e1 100644
--- a/test/language/expressions/greater-than/bigint-and-non-finite.js
+++ b/test/language/expressions/greater-than/bigint-and-non-finite.js
@@ -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");
diff --git a/test/language/expressions/greater-than/bigint-and-number-extremes.js b/test/language/expressions/greater-than/bigint-and-number-extremes.js
index de79976069ff8f19857a08410b47200e6837ab6a..1d1107d3324dc6ba4cf5b236b8e339b70f8a2857 100644
--- a/test/language/expressions/greater-than/bigint-and-number-extremes.js
+++ b/test/language/expressions/greater-than/bigint-and-number-extremes.js
@@ -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");
diff --git a/test/language/expressions/greater-than/bigint-and-number.js b/test/language/expressions/greater-than/bigint-and-number.js
index 10b2ac3f133d3e6ae4b6fead1e25c28edd7203af..0d02c4923247bb45972c7e77001e9c19732931b8 100644
--- a/test/language/expressions/greater-than/bigint-and-number.js
+++ b/test/language/expressions/greater-than/bigint-and-number.js
@@ -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");
diff --git a/test/language/expressions/less-than-or-equal/bigint-and-bigint.js b/test/language/expressions/less-than-or-equal/bigint-and-bigint.js
index 04f628a61bf3b3cfa787b5cf6b02043db837c59f..c667c60c644d0340f0cbd7ae10b3efb1c267c634 100644
--- a/test/language/expressions/less-than-or-equal/bigint-and-bigint.js
+++ b/test/language/expressions/less-than-or-equal/bigint-and-bigint.js
@@ -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");
diff --git a/test/language/expressions/less-than-or-equal/bigint-and-non-finite.js b/test/language/expressions/less-than-or-equal/bigint-and-non-finite.js
index 7dcaf917841680ed2f1fafd9a797e11c80fd73ee..e7053f218c44afdbf434464c82e5fda71a5fd512 100644
--- a/test/language/expressions/less-than-or-equal/bigint-and-non-finite.js
+++ b/test/language/expressions/less-than-or-equal/bigint-and-non-finite.js
@@ -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");
diff --git a/test/language/expressions/less-than-or-equal/bigint-and-number-extremes.js b/test/language/expressions/less-than-or-equal/bigint-and-number-extremes.js
index 20b563ad9d6c892342e7f2a879efb31b705f0380..5b502b07c65a98ed6d6dfa66d187fca63555f6be 100644
--- a/test/language/expressions/less-than-or-equal/bigint-and-number-extremes.js
+++ b/test/language/expressions/less-than-or-equal/bigint-and-number-extremes.js
@@ -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");
diff --git a/test/language/expressions/less-than-or-equal/bigint-and-number.js b/test/language/expressions/less-than-or-equal/bigint-and-number.js
index c57c5a213f49064c360a82c9779afa7e46b308d3..cef45145961dee5c76cf0b1edfdb24a59eb35235 100644
--- a/test/language/expressions/less-than-or-equal/bigint-and-number.js
+++ b/test/language/expressions/less-than-or-equal/bigint-and-number.js
@@ -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");
diff --git a/test/language/expressions/less-than/bigint-and-bigint.js b/test/language/expressions/less-than/bigint-and-bigint.js
index 55c232d7c976bf67d33f1c83fd6f8cd5d2aae6ea..b3b37d76d79bcfcdc91901700ce6d7559810f53c 100644
--- a/test/language/expressions/less-than/bigint-and-bigint.js
+++ b/test/language/expressions/less-than/bigint-and-bigint.js
@@ -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");
diff --git a/test/language/expressions/less-than/bigint-and-non-finite.js b/test/language/expressions/less-than/bigint-and-non-finite.js
index 07e93fd7eb9cd1cc1e8b699797160d08731807c4..7ad15a7c19d8ba83e25fa74928e881f858401bbd 100644
--- a/test/language/expressions/less-than/bigint-and-non-finite.js
+++ b/test/language/expressions/less-than/bigint-and-non-finite.js
@@ -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");
diff --git a/test/language/expressions/less-than/bigint-and-number-extremes.js b/test/language/expressions/less-than/bigint-and-number-extremes.js
index 2819c99a3c70ef2a773ddaed0cfc67526604b17e..c367b02d2af6de776c68529b21fc0b7223cd7fc2 100644
--- a/test/language/expressions/less-than/bigint-and-number-extremes.js
+++ b/test/language/expressions/less-than/bigint-and-number-extremes.js
@@ -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");
diff --git a/test/language/expressions/less-than/bigint-and-number.js b/test/language/expressions/less-than/bigint-and-number.js
index 4af7764fd9ecd68ca83dceabdabe7c145179020f..1478baf8c6a88951b8268d58626aff1164ab7d4c 100644
--- a/test/language/expressions/less-than/bigint-and-number.js
+++ b/test/language/expressions/less-than/bigint-and-number.js
@@ -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");