Use strict asserts in value.test.js

diff --git a/value.test.js b/value.test.js
index df8677801934ecb7a09b878e36fe3fe6c2a155be..747b18e39087d18010414158a3b661a6443802da 100644 (file)
--- a/value.test.js
+++ b/value.test.js
@@ -8,7 +8,6 @@
 // file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
 
 import {
-  assert,
   assertStrictEquals,
   assertThrows,
   describe,
@@ -206,79 +205,82 @@ describe("ordinaryToPrimitive", () => {
 
 describe("sameValue", () => {
   it("[[Call]] returns false for null 🆚 undefined", () => {
-    assert(!sameValue(null, void {}));
+    assertStrictEquals(sameValue(null, undefined), false);
   });
 
   it("[[Call]] returns false for null 🆚 an object", () => {
-    assert(!sameValue(null, {}));
+    assertStrictEquals(sameValue(null, {}), false);
   });
 
   it("[[Call]] returns true for null 🆚 null", () => {
-    assert(sameValue(null, null));
+    assertStrictEquals(sameValue(null, null), true);
   });
 
   it("[[Call]] returns false for two different objects", () => {
-    assert(!sameValue({}, {}));
+    assertStrictEquals(sameValue({}, {}), false);
   });
 
   it("[[Call]] returns true for the same object", () => {
     const obj = {};
-    assert(sameValue(obj, obj));
+    assertStrictEquals(sameValue(obj, obj), true);
   });
 
   it("[[Call]] returns false for ±0", () => {
-    assert(!sameValue(0, -0));
+    assertStrictEquals(sameValue(0, -0), false);
   });
 
   it("[[Call]] returns true for -0", () => {
-    assert(sameValue(-0, -0));
+    assertStrictEquals(sameValue(-0, -0), true);
   });
 
   it("[[Call]] returns true for nan", () => {
-    assert(sameValue(0 / 0, 0 / 0));
+    assertStrictEquals(sameValue(0 / 0, 0 / 0), true);
   });
 
   it("[[Call]] returns false for a primitive and its wrapped object", () => {
-    assert(!sameValue(false, new Boolean(false)));
+    assertStrictEquals(sameValue(false, new Boolean(false)), false);
   });
 });
 
 describe("sameValueZero", () => {
   it("[[Call]] returns false for null 🆚 undefined", () => {
-    assert(!sameValueZero(null, void {}));
+    assertStrictEquals(sameValueZero(null, undefined), false);
   });
 
   it("[[Call]] returns false for null 🆚 an object", () => {
-    assert(!sameValueZero(null, {}));
+    assertStrictEquals(sameValueZero(null, {}), false);
   });
 
   it("[[Call]] returns true for null 🆚 null", () => {
-    assert(sameValueZero(null, null));
+    assertStrictEquals(sameValueZero(null, null), true);
   });
 
   it("[[Call]] returns false for two different objects", () => {
-    assert(!sameValueZero({}, {}));
+    assertStrictEquals(sameValueZero({}, {}), false);
   });
 
   it("[[Call]] returns true for the same object", () => {
     const obj = {};
-    assert(sameValueZero(obj, obj));
+    assertStrictEquals(sameValueZero(obj, obj), true);
   });
 
   it("[[Call]] returns true for ±0", () => {
-    assert(sameValueZero(0, -0));
+    assertStrictEquals(sameValueZero(0, -0), true);
   });
 
   it("[[Call]] returns true for -0", () => {
-    assert(sameValueZero(-0, -0));
+    assertStrictEquals(sameValueZero(-0, -0), true);
   });
 
   it("[[Call]] returns true for nan", () => {
-    assert(sameValueZero(0 / 0, 0 / 0));
+    assertStrictEquals(sameValueZero(0 / 0, 0 / 0), true);
   });
 
   it("[[Call]] returns false for a primitive and its wrapped object", () => {
-    assert(!sameValueZero(false, new Boolean(false)));
+    assertStrictEquals(
+      sameValueZero(false, new Boolean(false)),
+      false,
+    );
   });
 });