LibJS: Add all of the WeakMap.prototype methods (delete, get, has, set)

Userland/Libraries/LibJS/Tests/builtins/WeakMap/WeakMap.js

@@ -0,0 +1,34 @@
+test("constructor properties", () => {
+    expect(WeakMap).toHaveLength(0);
+    expect(WeakMap.name).toBe("WeakMap");
+});
+
+describe("errors", () => {
+    test("invalid array iterators", () => {
+        [-100, Infinity, NaN, {}, 152n].forEach(value => {
+            expect(() => {
+                new WeakMap(value);
+            }).toThrowWithMessage(TypeError, "is not iterable");
+        });
+    });
+    test("called without new", () => {
+        expect(() => {
+            WeakMap();
+        }).toThrowWithMessage(TypeError, "WeakMap constructor must be called with 'new'");
+    });
+});
+
+describe("normal behavior", () => {
+    test("typeof", () => {
+        expect(typeof new WeakMap()).toBe("object");
+    });
+
+    test("constructor with single array of entries argument", () => {
+        var a = new WeakMap([
+            [{ a: 1 }, 1],
+            [{ a: 2 }, 2],
+            [{ a: 3 }, 3],
+        ]);
+        expect(a instanceof WeakMap).toBeTrue();
+    });
+});

Userland/Libraries/LibJS/Tests/builtins/WeakMap/WeakMap.prototype.delete.js

@@ -0,0 +1,13 @@
+test("basic functionality", () => {
+    expect(WeakMap.prototype.delete).toHaveLength(1);
+
+    var original = [
+        [{ a: 1 }, 1],
+        [{ a: 2 }, 2],
+        [{ a: 3 }, 3],
+    ];
+    const weakMap = new WeakMap(original);
+    expect(weakMap.delete(original[0][0])).toBeTrue();
+    expect(weakMap.delete(original[0][0])).toBeFalse();
+    expect(weakMap.delete(null)).toBeFalse();
+});

Userland/Libraries/LibJS/Tests/builtins/WeakMap/WeakMap.prototype.get.js

@@ -0,0 +1,12 @@
+test("basic functionality", () => {
+    expect(WeakMap.prototype.get).toHaveLength(1);
+
+    var original = [
+        [{ a: 1 }, 1],
+        [{ a: 2 }, 2],
+        [{ a: 3 }, 3],
+    ];
+    const weakMap = new WeakMap(original);
+    expect(weakMap.get(original[0][0])).toBe(original[0][1]);
+    expect(weakMap.get(null)).toBe(undefined);
+});

Userland/Libraries/LibJS/Tests/builtins/WeakMap/WeakMap.prototype.has.js

@@ -0,0 +1,16 @@
+test("length is 1", () => {
+    expect(WeakMap.prototype.has).toHaveLength(1);
+});
+
+test("basic functionality", () => {
+    var original = [
+        [{ a: 1 }, 1],
+        [{ a: 2 }, 2],
+        [{ a: 3 }, 3],
+    ];
+    var weakMap = new WeakMap(original);
+
+    expect(new WeakMap().has()).toBeFalse();
+    expect(weakMap.has(original[0][0])).toBeTrue();
+    expect(weakMap.has({ a: 1 })).toBeFalse();
+});

Userland/Libraries/LibJS/Tests/builtins/WeakMap/WeakMap.prototype.set.js

@@ -0,0 +1,30 @@
+test("basic functionality", () => {
+    expect(WeakMap.prototype.set).toHaveLength(2);
+
+    const weakMap = new WeakMap([
+        [{ a: 1 }, 1],
+        [{ a: 2 }, 2],
+        [{ a: 3 }, 3],
+    ]);
+    expect(weakMap.set({ a: 4 }, 4)).toBe(weakMap);
+    expect(weakMap.set({ a: 1 }, 2)).toBe(weakMap);
+});
+
+test("invalid values", () => {
+    const weakMap = new WeakMap();
+    [-100, Infinity, NaN, "hello", 152n].forEach(value => {
+        expect(() => {
+            weakMap.set(value, value);
+        }).toThrowWithMessage(TypeError, "is not an object");
+    });
+});
+
+test("automatic removal of garbage-collected values", () => {
+    const weakMap = new WeakMap();
+    {
+        expect(weakMap.set({ a: 1 }, 1)).toBe(weakMap);
+        expect(getWeakMapSize(weakMap)).toBe(1);
+    }
+    gc();
+    expect(getWeakMapSize(weakMap)).toBe(0);
+});