tests/runner.mjs: Add missing await in t.test("", () => {})

1 files changed, 30 insertions, 30 deletions

diff --git a/tests/js/utils.mjs b/tests/js/utils.mjs
index ea5f4eb..425a09f 100644
--- a/tests/js/utils.mjs
+++ b/tests/js/utils.mjs
@@ -13,16 +13,16 @@ import {
 } from "../../src/utils.mjs";
 
 
-const test_keys = t => {
+const test_keys = async t => {
 	t.start("keys()");
-	t.test("happy paths", () => {
+	await t.test("happy paths", () => {
 		assert.deepEqual(
 			{ a: 1, b: 2 },
 			keys(["a", "b"], { a: 1, b: 2, c: 3 }),
 		);
 	});
 
-	t.test("stress scenarios", () => {
+	await t.test("stress scenarios", () => {
 		assert.deepEqual(
 			{},
 			keys([], {}),
@@ -49,10 +49,10 @@ const test_keys = t => {
 	});
 };
 
-const test_difference = t => {
+const test_difference = async t => {
 	t.start("difference()");
 
-	t.test("empty values", () => {
+	await t.test("empty values", () => {
 		assert.deepEqual(
 			difference(new Set(), new Set()),
 			new Set(),
@@ -69,7 +69,7 @@ const test_difference = t => {
 		);
 	});
 
-	t.test("different subsets", () => {
+	await t.test("different subsets", () => {
 		assert.deepEqual(
 			difference(new Set([1, 2]), new Set([3, 4])),
 			new Set([1, 2]),
@@ -92,22 +92,22 @@ const test_difference = t => {
 	});
 };
 
-const test_assocIn = t => {
+const test_assocIn = async t => {
 	t.start("assocIn()");
 
-	t.test("empty values", () => {
+	await t.test("empty values", () => {
 		assert.deepEqual(assocIn({}, [], null), {});
 		assert.deepEqual(assocIn({ k: "v" }, [], null), { k: "v" });
 	});
 
-	t.test("adding values", () => {
+	await t.test("adding values", () => {
 		assert.deepEqual(assocIn({}, ["k"], "v"), { k: "v" });
 		assert.deepEqual(assocIn({}, ["k1", "k2"], "v"), { k1: { k2: "v" }});
 		assert.deepEqual(assocIn({}, ["k1", "k2", "k3"], "v"), { k1: { k2: { k3: "v" }}});
 		assert.deepEqual(assocIn({ k: "v" }, ["k1", "k2"], "v"), { k: "v",  k1: { k2: "v" }});
 	});
 
-	t.test("replacing values", () => {
+	await t.test("replacing values", () => {
 		assert.deepEqual(
 			assocIn(
 				{ k1: { k2: { k3: "before" }}},
@@ -119,34 +119,34 @@ const test_assocIn = t => {
 	});
 };
 
-const test_getIn = t => {
+const test_getIn = async t => {
 	t.start("getIn()");
 
-	t.test("empty values", () => {
+	await t.test("empty values", () => {
 		assert.deepEqual(getIn({}, []), {});
 		assert.deepEqual(getIn({ k: "v" }, []), { k: "v" });
 	});
 
-	t.test("missing values", () => {
+	await t.test("missing values", () => {
 		assert.deepEqual(getIn({}, ["a", "b", "c"]), undefined);
 		assert.deepEqual(getIn({ a: {}}, ["a", "b", "c"]), undefined);
 		assert.deepEqual(getIn({ a: { b: {}}}, ["a", "b", "c"]), undefined);
 		assert.deepEqual(getIn({ a: { b: {}, c: {}}}, ["a", "b", "c"]), undefined);
 	});
 
-	t.test("nested valeues", () => {
+	await t.test("nested valeues", () => {
 		assert.deepEqual(getIn({ a: { b: { c: { d: "e" }}}}, ["a", "b", "c", "d"]), "e");
 	});
 };
 
-const test_findFirst = t => {
+const test_findFirst = async t => {
 	t.start("findFirst()");
 
-	t.test("empty values", () => {
+	await t.test("empty values", () => {
 		assert.equal(findFirst([], () => {}), null);
 	});
 
-	t.test("when function doesn't transform, it behaves similarly to [].find()", () => {
+	await t.test("when function doesn't transform, it behaves similarly to [].find()", () => {
 		const arr1 = [ 0, null, undefined, "", 1, 2 ];
 		assert.equal(findFirst(arr1, x => x), 1);
 		assert.equal(arr1.find(x => x),   1);
@@ -156,7 +156,7 @@ const test_findFirst = t => {
 		assert.equal(arr2.find(x => x),   undefined);
 	});
 
-	t.test("when it does transform, we return the transformed value", () => {
+	await t.test("when it does transform, we return the transformed value", () => {
 		const arr = [ 1, 3, 5, 6 ];
 
 		assert.equal(
@@ -166,10 +166,10 @@ const test_findFirst = t => {
 	});
 };
 
-const test_partial = t => {
+const test_partial = async t => {
 	t.start("partial()");
 
-	t.test("empty values", () => {
+	await t.test("empty values", () => {
 		const adder = (a, b, c) => a + b + c;
 
 		const adder1 = partial(adder);
@@ -182,7 +182,7 @@ const test_partial = t => {
 		assert.equal(partial(noargs)(), noargs());
 	});
 
-	t.test("too few arguments", () => {
+	await t.test("too few arguments", () => {
 		const threeArgs = (a, b, c) => {
 			assert.notEqual(c, undefined);
 			return a + b + c
@@ -207,14 +207,14 @@ const test_partial = t => {
 		);
 	});
 
-	t.test("too many arguments", () => {
+	await t.test("too many arguments", () => {
 		const twoArgs = (a, b) => a + b;
 
 		assert.equal(partial(twoArgs, 1)(2, 3), 3);
 		assert.equal(partial(twoArgs, 1, 2)(3), 3);
 	});
 
-	t.test("daily usage", () => {
+	await t.test("daily usage", () => {
 		const twoArg = (a, b) => a + b;
 
 		const numbers = [ 1, 2, 3, 4, 5 ];
@@ -224,7 +224,7 @@ const test_partial = t => {
 		);
 	});
 
-	t.test("nested partials", () => {
+	await t.test("nested partials", () => {
 		const threeArgs = (a, b, c) => a + b + c;
 
 		const add1     = partial(threeArgs, 1);
@@ -234,14 +234,14 @@ const test_partial = t => {
 	});
 };
 
-const test_strSortFn = t => {
+const test_strSortFn = async t => {
 	t.start("strSortFn()");
 
-	t.test("empty value", () => {
+	await t.test("empty value", () => {
 		assert.equal(strSortFn("", ""), 0);
 	});
 
-	t.test("default sort", () => {
+	await t.test("default sort", () => {
 		const arr = [ "a", "Z" ];
 		assert.deepEqual(
 			[...arr].sort(strSortFn),
@@ -250,15 +250,15 @@ const test_strSortFn = t => {
 	});
 };
 
-const test_undefinedAsNull = t => {
+const test_undefinedAsNull = async t => {
 	t.start("undefinedAsNull()");
 
-	t.test("null for undefined or null", () => {
+	await t.test("null for undefined or null", () => {
 		assert.equal(undefinedAsNull(undefined), null);
 		assert.equal(undefinedAsNull(null),      null);
 	});
 
-	t.test("identity otherwise", () => {
+	await t.test("identity otherwise", () => {
 		const expected = [
 			" ", "", 0, 1, -1.1, true, false,
 			[], [ "" ], {}, { k: "v" },