From 30e192da5765a7ba16575e27c04a42f9a12d3543 Mon Sep 17 00:00:00 2001
From: Josh Wolfe <jwolfe@igalia.com>
Date: Fri, 6 Oct 2017 02:25:58 -0700
Subject: [PATCH] add messages to relational comparison tests

---
 .../bigint-and-bigint.js                      | 66 +++++++++----------
 .../bigint-and-non-finite.js                  | 20 +++---
 .../bigint-and-number-extremes.js             | 20 +++---
 .../bigint-and-number.js                      | 40 +++++------
 .../greater-than/bigint-and-bigint.js         | 66 +++++++++----------
 .../greater-than/bigint-and-non-finite.js     | 20 +++---
 .../bigint-and-number-extremes.js             | 20 +++---
 .../greater-than/bigint-and-number.js         | 40 +++++------
 .../less-than-or-equal/bigint-and-bigint.js   | 66 +++++++++----------
 .../bigint-and-non-finite.js                  | 20 +++---
 .../bigint-and-number-extremes.js             | 20 +++---
 .../less-than-or-equal/bigint-and-number.js   | 40 +++++------
 .../less-than/bigint-and-bigint.js            | 66 +++++++++----------
 .../less-than/bigint-and-non-finite.js        | 20 +++---
 .../less-than/bigint-and-number-extremes.js   | 20 +++---
 .../less-than/bigint-and-number.js            | 40 +++++------
 16 files changed, 300 insertions(+), 284 deletions(-)

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 01e8a9cb72..6ce429669a 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 a3f84924f0..f3af1b04ec 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 ea0a725c78..64657ac9e0 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 63890b9e3f..c2cd2949a6 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 fb62743187..c9f06fb44d 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 f1efc83dac..71b88c6647 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 de79976069..1d1107d332 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 10b2ac3f13..0d02c49232 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 04f628a61b..c667c60c64 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 7dcaf91784..e7053f218c 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 20b563ad9d..5b502b07c6 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 c57c5a213f..cef4514596 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 55c232d7c9..b3b37d76d7 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 07e93fd7eb..7ad15a7c19 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 2819c99a3c..c367b02d2a 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 4af7764fd9..1478baf8c6 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");
-- 
GitLab