refactor: update all tests (packages A-S)

Author: postspectacular

packages/adapt-dpi/test/main.test.ts

@@ -1,4 +1,4 @@
 import { expect, test } from "bun:test";
 // import {} from "../src/index.js";
 
-test("adapt-dpi", () => {});
+test.todo("adapt-dpi", () => {});

packages/associative/test/multitrie.test.ts

@@ -1,9 +1,9 @@
-import { expect, test } from "bun:test";
+import { beforeEach, expect, test } from "bun:test";
 import { MultiTrie } from "../src/index.js";
 
 let root: MultiTrie<string, string>;
 
-const init = () => {
+beforeEach(() => {
 	root = new MultiTrie();
 	root.add("hey", "en");
 	root.add("hello", "en");
@@ -12,10 +12,9 @@ const init = () => {
 	root.add("hola", "es");
 	root.add("hold", "en");
 	root.add("hej", "se");
-};
+});
 
 test("keys", () => {
-	init();
 	expect(new Set(root.keys())).toEqual(
 		new Set(["hey", "hello", "hallo", "hallo", "hola", "hold", "hej"])
 	);
@@ -31,7 +30,6 @@ test("keys", () => {
 });
 
 test("keys (words)", () => {
-	init();
 	const t = new MultiTrie<string[], string>();
 	t.add("foo bar baz".split(" "), "a");
 	t.add("foo boo zoo".split(" "), "b");
@@ -41,15 +39,13 @@ test("keys (words)", () => {
 });
 
 test("values", () => {
-	init();
 	expect(new Set(root.values())).toEqual(
 		new Set(["en", "es", "de", "de-at", "se"])
 	);
 	expect(new Set(root.find("he")!.values())).toEqual(new Set(["en", "se"]));
 });
 
 test("delete", () => {
-	init();
 	expect(root.delete("he")).toBeTrue();
 	expect(new Set(root.keys())).toEqual(new Set(["hola", "hold", "hallo"]));
 	expect(root.delete("hallo", "de")).toBeTrue();
@@ -59,7 +55,6 @@ test("delete", () => {
 });
 
 test("known prefix", () => {
-	init();
 	expect(root.knownPrefix("hole")).toEqual(["h", "o", "l"]);
 	expect(root.knownPrefix("whole")).toEqual([]);
 });

packages/associative/test/sortedmap.test.ts

@@ -2,17 +2,16 @@ import { shuffle } from "@thi.ng/arrays";
 import { equiv } from "@thi.ng/equiv";
 import { XsAdd } from "@thi.ng/random";
 import { range, repeat, zip } from "@thi.ng/transducers";
-import { expect, test } from "bun:test";
+import { beforeEach, expect, test } from "bun:test";
 import { SortedMap, defSortedMap } from "../src/index.js";
 
 let m: SortedMap<any, any>;
 
-const init = () => {
+beforeEach(() => {
 	m = defSortedMap({ a: 1, b: 2, c: 3 });
-};
+});
 
 test("size", () => {
-	init();
 	expect(m.size).toBe(3);
 	m.set("a", 10);
 	expect(m.size).toBe(3);
@@ -25,7 +24,6 @@ test("size", () => {
 });
 
 test("clear", () => {
-	init();
 	m.clear();
 	expect(m.size).toBe(0);
 	expect([...m.entries()]).toEqual([]);
@@ -34,26 +32,22 @@ test("clear", () => {
 });
 
 test("empty", () => {
-	init();
 	const m2 = m.empty();
 	expect(m.size).toBe(3);
 	expect(m2.size).toBe(0);
 	expect([...m2.entries()]).toEqual([]);
 });
 
 test("copy", () => {
-	init();
 	expect(m.copy()).toEqual(m);
 });
 
 test("equiv", () => {
-	init();
 	expect(equiv(m.copy(), m)).toBeTrue();
 	expect(equiv(m, new SortedMap<any, any>())).toBeFalse();
 });
 
 test("has", () => {
-	init();
 	expect(m.has("a")).toBeTrue();
 	expect(m.has("b")).toBeTrue();
 	expect(m.has("c")).toBeTrue();
@@ -63,14 +57,12 @@ test("has", () => {
 });
 
 test("first", () => {
-	init();
 	expect(["a", 1]).toEqual(m.first()!);
 	m.set("A", 10);
 	expect(["A", 10]).toEqual(m.first()!);
 });
 
 test("get", () => {
-	init();
 	expect(m.get("a")).toBe(1);
 	expect(m.get("b")).toBe(2);
 	expect(m.get("c")).toBe(3);
@@ -80,7 +72,6 @@ test("get", () => {
 });
 
 test("entries", () => {
-	init();
 	expect([...m]).toEqual([
 		["a", 1],
 		["b", 2],
@@ -93,7 +84,6 @@ test("entries", () => {
 // },
 
 test("entries a", () => {
-	init();
 	expect([...m.entries("a")]).toEqual([
 		["a", 1],
 		["b", 2],
@@ -106,7 +96,6 @@ test("entries a", () => {
 // },
 
 test("entries aa", () => {
-	init();
 	expect([...m.entries("aa")]).toEqual([
 		["b", 2],
 		["c", 3],
@@ -118,7 +107,6 @@ test("entries aa", () => {
 // },
 
 test("entries bb", () => {
-	init();
 	expect([...m.entries("bb")]).toEqual([["c", 3]]);
 });
 
@@ -127,7 +115,6 @@ test("entries bb", () => {
 // },
 
 test("entries c", () => {
-	init();
 	expect([...m.entries("c")]).toEqual([["c", 3]]);
 });
 
@@ -136,7 +123,6 @@ test("entries c", () => {
 // },
 
 test("entries 0", () => {
-	init();
 	expect([...m.entries("0")]).toEqual([
 		["a", 1],
 		["b", 2],
@@ -149,7 +135,6 @@ test("entries 0", () => {
 // });
 
 test("entries d", () => {
-	init();
 	expect([...m.entries("d")]).toEqual([]);
 });
 
@@ -158,23 +143,20 @@ test("entries d", () => {
 // },
 
 test("keys", () => {
-	init();
 	expect([...m.keys()]).toEqual(["a", "b", "c"]);
 	m.set("aa", 0);
 	m.set("d", 0);
 	expect([...m.keys()]).toEqual(["a", "aa", "b", "c", "d"]);
 });
 
 test("values", () => {
-	init();
 	expect([...m.values()]).toEqual([1, 2, 3]);
 	m.set("aa", 0);
 	m.set("d", 0);
 	expect([...m.values()]).toEqual([1, 0, 2, 3, 0]);
 });
 
 test("comparator", () => {
-	init();
 	m = defSortedMap(
 		{ a: 1, b: 2, c: 3 },
 		{
@@ -189,7 +171,6 @@ test("comparator", () => {
 });
 
 test("fuzz", () => {
-	init();
 	const keys = [...range(32)];
 	for (let i = 0; i < 1000; i++) {
 		m = new SortedMap(zip(shuffle(keys.slice()), repeat(1)));
@@ -198,7 +179,6 @@ test("fuzz", () => {
 });
 
 test("fuzzSetDelete", () => {
-	init();
 	const s = defSortedMap<number, number>(null, {
 		compare: (a, b) => a - b,
 	});
@@ -211,7 +191,6 @@ test("fuzzSetDelete", () => {
 });
 
 test("updateValue", () => {
-	init();
 	m = defSortedMap(
 		[
 			["one", 1],

packages/associative/test/sparseset.test.ts

@@ -1,6 +1,6 @@
 import { isSet } from "@thi.ng/checks";
 import { equiv } from "@thi.ng/equiv";
-import { expect, test } from "bun:test";
+import { beforeEach, expect, test } from "bun:test";
 import {
 	SparseSet16,
 	SparseSet32,
@@ -10,12 +10,11 @@ import {
 
 let set: SparseSet8;
 
-const init = () => {
+beforeEach(() => {
 	set = new SparseSet8(8);
-};
+});
 
 test("factory / max value", () => {
-	init();
 	let a = defSparseSet(0x100);
 	a.into([0xff, 0x100]);
 	expect(a instanceof SparseSet8).toBeTrue();
@@ -33,14 +32,12 @@ test("factory / max value", () => {
 });
 
 test("ctor(n)", () => {
-	init();
 	expect(isSet(set)).toBeTrue();
 	expect(set.size).toBe(0);
 	expect(set.capacity).toBe(8);
 });
 
 test("ctor(arrays)", () => {
-	init();
 	const d = new Uint8Array(8);
 	const s = new Uint8Array(8);
 	set = new SparseSet8(d, s);
@@ -50,7 +47,6 @@ test("ctor(arrays)", () => {
 });
 
 test("add", () => {
-	init();
 	expect(
 		equiv(
 			set.into([1, 4, 3, 7, 9, 2, 0, 1, 2]),
@@ -60,7 +56,6 @@ test("add", () => {
 });
 
 test("delete", () => {
-	init();
 	set.into([1, 4, 3, 7, 9, 2, 0, 1, 2]);
 	expect(set.delete(4)).toBeTrue();
 	expect(equiv(set, new Set([0, 1, 2, 3, 7]))).toBeTrue();
@@ -75,7 +70,6 @@ test("delete", () => {
 });
 
 test("has", () => {
-	init();
 	expect(set.has(0)).toBeFalse();
 	set.add(0);
 	set.add(0);

packages/associative/test/triemap.test.ts

@@ -1,21 +1,22 @@
-import { expect, test } from "bun:test";
+import { beforeEach, expect, test } from "bun:test";
 import { TrieMap } from "../src/index.js";
 
 let root: TrieMap<string>;
 
-const init = () =>
-	(root = new TrieMap([
-		["hey", "en"],
-		["hello", "en"],
-		["hallo", "de"],
-		["hallo", "de-at"],
-		["hola", "es"],
-		["hold", "en"],
-		["hej", "se"],
-	]));
+beforeEach(
+	() =>
+		(root = new TrieMap([
+			["hey", "en"],
+			["hello", "en"],
+			["hallo", "de"],
+			["hallo", "de-at"],
+			["hola", "es"],
+			["hold", "en"],
+			["hej", "se"],
+		]))
+);
 
 test("keys", () => {
-	init();
 	expect(new Set(root.keys())).toEqual(
 		new Set(["hey", "hello", "hallo", "hallo", "hola", "hold", "hej"])
 	);
@@ -25,15 +26,13 @@ test("keys", () => {
 });
 
 test("values", () => {
-	init();
 	expect(new Set(root.values())).toEqual(
 		new Set(["en", "es", "de-at", "se"])
 	);
 	expect(new Set(root.find("he")!.values())).toEqual(new Set(["en", "se"]));
 });
 
 test("delete", () => {
-	init();
 	expect(root.delete("he")).toBeTrue();
 	expect(new Set(root.keys())).toEqual(new Set(["hola", "hold", "hallo"]));
 	expect(root.delete("hallo")).toBeTrue();
@@ -43,13 +42,11 @@ test("delete", () => {
 });
 
 test("known prefix", () => {
-	init();
 	expect(root.knownPrefix("hole")).toEqual("hol");
 	expect(root.knownPrefix("whole")).toBeUndefined();
 });
 
 test("suffixes", () => {
-	init();
 	expect([...root.suffixes("he")]).toEqual(["j", "llo", "y"]);
 	expect([...root.suffixes("he", true)]).toEqual(["hej", "hello", "hey"]);
 });