Skip to content

Commit d659ff1

Browse files
jeremy-codejeremy-code
committed
refactor: update BiMap test cases to use 'test' instead of 'it' and improve readability
1 parent 6e6aee0 commit d659ff1

2 files changed

Lines changed: 120 additions & 99 deletions

File tree

‎src/utils/BiMap.test.ts‎

Lines changed: 114 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -1,183 +1,201 @@
1-
import { describe, it, expect } from "vitest";
1+
import { describe, test, expect } from "vitest";
22

33
import { BiMap } from "./BiMap.ts";
44

55
describe("BiMap", () => {
66
describe("constructor", () => {
7-
it("creates an empty BiMap when no entries are provided", () => {
7+
test("creates an empty BiMap when no entries are provided", () => {
88
const map = new BiMap<string, number>();
99

1010
expect(map.size).toBe(0);
1111
expect(map.inverse.size).toBe(0);
1212
});
1313

14-
it("initializes with entries", () => {
15-
const map = new BiMap<string, number>([
14+
test("initializes with array entries", () => {
15+
const biMap = new BiMap([
1616
["a", 1],
1717
["b", 2],
1818
]);
1919

20-
expect(map.size).toBe(2);
21-
expect(map.get("a")).toBe(1);
22-
expect(map.get("b")).toBe(2);
23-
expect(map.inverse).not.toBe(undefined);
20+
expect(biMap).toHaveProperty("size", 2);
21+
expect(biMap.get("a")).toBe(1);
22+
expect(biMap.get("b")).toBe(2);
2423

25-
expect(map.getKey(1)).toBe("a");
26-
expect(map.getKey(2)).toBe("b");
24+
expect(biMap.getKey(1)).toBe("a");
25+
expect(biMap.getKey(2)).toBe("b");
2726
});
2827

29-
it("handles null or undefined entries", () => {
30-
const map1 = new BiMap<string, number>(null);
31-
const map2 = new BiMap<string, number>(undefined);
28+
test("initializes with iterable", () => {
29+
const biMap = new BiMap(
30+
(function* () {
31+
yield ["a", 1];
32+
yield ["b", 2];
33+
})(),
34+
);
35+
expect(biMap).toHaveProperty("size", 2);
36+
expect(biMap.get("a")).toBe(1);
37+
expect(biMap.get("b")).toBe(2);
3238

33-
expect(map1.size).toBe(0);
34-
expect(map2.size).toBe(0);
39+
expect(biMap.getKey(1)).toBe("a");
40+
expect(biMap.getKey(2)).toBe("b");
41+
});
42+
43+
test("handles null or undefined entries", () => {
44+
const biMap1 = new BiMap<string, number>(null);
45+
const biMap2 = new BiMap<string, number>(undefined);
46+
47+
expect(biMap1).toHaveProperty("size", 0);
48+
expect(biMap2).toHaveProperty("size", 0);
49+
});
50+
51+
test("throws on non-iterable entries", () => {
52+
// @ts-expect-error -- testing non-iterable entries
53+
expect(() => new BiMap({})).toThrow(TypeError);
3554
});
3655
});
3756

3857
describe("set", () => {
39-
it("sets key → value and value → key", () => {
40-
const map = new BiMap<string, number>();
58+
test("sets key → value and value → key", () => {
59+
const biMap = new BiMap<string, number>();
4160

42-
map.set("a", 1);
61+
biMap.set("a", 1);
4362

44-
expect(map.get("a")).toBe(1);
45-
expect(map.getKey(1)).toBe("a");
63+
expect(biMap.get("a")).toBe(1);
64+
expect(biMap.getKey(1)).toBe("a");
4665
});
4766

48-
it("overwrites existing key", () => {
49-
const map = new BiMap<string, number>();
67+
test("overwrites existing key", () => {
68+
const biMap = new BiMap<string, number>();
5069

51-
map.set("a", 1);
52-
map.set("a", 2);
70+
biMap.set("a", 1);
71+
biMap.set("a", 2);
5372

54-
expect(map.get("a")).toBe(2);
55-
expect(map.getKey(1)).toBeUndefined();
56-
expect(map.getKey(2)).toBe("a");
73+
expect(biMap.get("a")).toBe(2);
74+
expect(biMap.getKey(1)).toBeUndefined();
75+
expect(biMap.getKey(2)).toBe("a");
5776
});
5877

59-
it("removes previous key when value is reused", () => {
60-
const map = new BiMap<string, number>();
78+
test("removes previous key when value is reused", () => {
79+
const biMap = new BiMap<string, number>();
6180

62-
map.set("a", 1);
63-
map.set("b", 1);
81+
biMap.set("a", 1);
82+
biMap.set("b", 1);
6483

65-
expect(map.get("a")).toBeUndefined();
66-
expect(map.get("b")).toBe(1);
67-
expect(map.getKey(1)).toBe("b");
84+
expect(biMap.get("a")).toBeUndefined();
85+
expect(biMap.get("b")).toBe(1);
86+
expect(biMap.getKey(1)).toBe("b");
6887
});
6988
});
7089

71-
describe("get / getKey", () => {
72-
it("retrieves values by key", () => {
73-
const map = new BiMap<string, number>([["a", 1]]);
74-
expect(map.inverse).not.toBe(undefined);
90+
describe("get, getKey, getValue", () => {
91+
test("retrieves values by key", () => {
92+
const biMap = new BiMap<string, number>([["a", 1]]);
7593

76-
expect(map.getValue("a")).toBe(1);
94+
expect(biMap.get("a")).toBe(1);
95+
expect(biMap.getValue("a")).toBe(1);
7796
});
7897

79-
it("retrieves keys by value", () => {
80-
const map = new BiMap<string, number>([["a", 1]]);
98+
test("retrieves keys by value", () => {
99+
const biMap = new BiMap<string, number>([["a", 1]]);
81100

82-
expect(map.getKey(1)).toBe("a");
101+
expect(biMap.getKey(1)).toBe("a");
83102
});
84103

85-
it("returns undefined for missing entries", () => {
86-
const map = new BiMap<string, number>();
104+
test("returns undefined for missing entries", () => {
105+
const biMap = new BiMap<string, number>();
87106

88-
expect(map.get("missing")).toBeUndefined();
89-
expect(map.getKey(999)).toBeUndefined();
107+
expect(biMap.get("missing")).toBeUndefined();
108+
expect(biMap.getValue("missing")).toBeUndefined();
109+
expect(biMap.getKey(999)).toBeUndefined();
90110
});
91111
});
92112

93-
describe("hasKey / hasValue", () => {
94-
it("checks existence of keys", () => {
95-
const map = new BiMap<string, number>([["a", 1]]);
113+
describe("has, hasKey, hasValue", () => {
114+
test("checks existence of keys", () => {
115+
const biMap = new BiMap<string, number>([["a", 1]]);
96116

97-
expect(map.hasKey("a")).toBe(true);
98-
expect(map.hasKey("b")).toBe(false);
117+
expect(biMap.has("a")).toBe(true);
118+
expect(biMap.has("b")).toBe(false);
119+
expect(biMap.hasKey("a")).toBe(true);
120+
expect(biMap.hasKey("b")).toBe(false);
99121
});
100122

101-
it("checks existence of values", () => {
102-
const map = new BiMap<string, number>([["a", 1]]);
123+
test("checks existence of values", () => {
124+
const biMap = new BiMap<string, number>([["a", 1]]);
103125

104-
expect(map.hasValue(1)).toBe(true);
105-
expect(map.hasValue(2)).toBe(false);
126+
expect(biMap.hasValue(1)).toBe(true);
127+
expect(biMap.hasValue(2)).toBe(false);
106128
});
107129
});
108130

109131
describe("delete (by key)", () => {
110-
it("deletes key and corresponding value", () => {
111-
const map = new BiMap<string, number>([["a", 1]]);
132+
test("deletes key and corresponding value", () => {
133+
const biMap = new BiMap<string, number>([["a", 1]]);
112134

113-
const result = map.delete("a");
114-
115-
expect(result).toBe(true);
116-
expect(map.get("a")).toBeUndefined();
117-
expect(map.getKey(1)).toBeUndefined();
118-
expect(map.size).toBe(0);
135+
expect(biMap.delete("a")).toBe(true);
136+
expect(biMap.get("a")).toBeUndefined();
137+
expect(biMap.getKey(1)).toBeUndefined();
138+
expect(biMap).toHaveProperty("size", 0);
119139
});
120140

121-
it("returns false if key does not exist", () => {
122-
const map = new BiMap<string, number>();
141+
test("returns false if key does not exist", () => {
142+
const biMap = new BiMap<string, number>();
123143

124-
expect(map.delete("missing")).toBe(false);
144+
expect(biMap.delete("missing")).toBe(false);
125145
});
126146
});
127147

128148
describe("deleteValue", () => {
129-
it("deletes value and corresponding key", () => {
130-
const map = new BiMap<string, number>([["a", 1]]);
131-
132-
const result = map.deleteValue(1);
149+
test("deletes value and corresponding key", () => {
150+
const biMap = new BiMap<string, number>([["a", 1]]);
133151

134-
expect(result).toBe(true);
135-
expect(map.get("a")).toBeUndefined();
136-
expect(map.getKey(1)).toBeUndefined();
137-
expect(map.size).toBe(0);
152+
expect(biMap.deleteValue(1)).toBe(true);
153+
expect(biMap.get("a")).toBeUndefined();
154+
expect(biMap.getKey(1)).toBeUndefined();
155+
expect(biMap).toHaveProperty("size", 0);
138156
});
139157

140-
it("returns false if value does not exist", () => {
141-
const map = new BiMap<string, number>();
158+
test("returns false if value does not exist", () => {
159+
const biMap = new BiMap<string, number>();
142160

143-
expect(map.deleteValue(123)).toBe(false);
161+
expect(biMap.deleteValue(123)).toBe(false);
144162
});
145163
});
146164

147165
describe("clear", () => {
148-
it("removes all entries", () => {
149-
const map = new BiMap<string, number>([
166+
test("removes all entries", () => {
167+
const biMap = new BiMap<string, number>([
150168
["a", 1],
151169
["b", 2],
152170
]);
153171

154-
map.clear();
172+
biMap.clear();
155173

156-
expect(map.size).toBe(0);
157-
expect(map.get("a")).toBeUndefined();
158-
expect(map.getKey(1)).toBeUndefined();
174+
expect(biMap.size).toBe(0);
175+
expect(biMap.get("a")).toBeUndefined();
176+
expect(biMap.getKey(1)).toBeUndefined();
159177
});
160178
});
161179

162180
describe("consistency", () => {
163-
it("maintains bidirectional integrity across multiple operations", () => {
164-
const map = new BiMap<string, number>();
181+
test("maintains bidirectional integrity across multiple operations", () => {
182+
const biMap = new BiMap<string, number>();
165183

166-
map.set("a", 1);
167-
map.set("b", 2);
168-
map.set("c", 3);
184+
biMap.set("a", 1);
185+
biMap.set("b", 2);
186+
biMap.set("c", 3);
169187

170-
map.delete("b");
171-
map.set("d", 1); // should evict "a"
188+
biMap.delete("b");
189+
biMap.set("d", 1); // should evict "a"
172190

173-
expect(map.get("a")).toBeUndefined();
174-
expect(map.getKey(1)).toBe("d");
191+
expect(biMap.get("a")).toBeUndefined();
192+
expect(biMap.getKey(1)).toBe("d");
175193

176-
expect(map.get("c")).toBe(3);
177-
expect(map.getKey(3)).toBe("c");
194+
expect(biMap.get("c")).toBe(3);
195+
expect(biMap.getKey(3)).toBe("c");
178196

179-
expect(map.hasKey("b")).toBe(false);
180-
expect(map.hasValue(2)).toBe(false);
197+
expect(biMap.hasKey("b")).toBe(false);
198+
expect(biMap.hasValue(2)).toBe(false);
181199
});
182200
});
183201
});

‎src/utils/BiMap.ts‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,12 @@
11
/**
2-
* @borrows BiMap#get as BiMap#getValue
3-
* @borrows BiMap#has as BiMap#hasKey
2+
* @borrows BiMap#deleteKey as BiMap#delete
3+
* @borrows BiMap#getValue as BiMap#get
4+
* @borrows BiMap#hasKey as BiMap#has
5+
*
6+
* @see {@link https://en.wikipedia.org/wiki/Bidirectional_map}
47
*/
58
class BiMap<K, V> extends Map<K, V> {
6-
inverse: Map<V, K>;
9+
readonly inverse: Map<V, K>;
710

811
constructor(entries?: Iterable<readonly [K, V]> | null) {
912
/**

0 commit comments

Comments
 (0)