LibJS: Convert Reflect object tests to new testing framework

Libraries/LibJS/Tests/builtins/Reflect/Reflect.apply.js

@@ -1,37 +1,39 @@
-load("test-common.js");
+test("length is 3", () => {
+    expect(Reflect.apply).toHaveLength(3);
+});
 
-try {
-    assert(Reflect.apply.length === 3);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.apply(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.apply() must be a function"
+describe("errors", () => {
+    test("target must be a function", () => {
+        [null, undefined, "foo", 123, NaN, Infinity, {}].forEach(value => {
+            expect(() => {
+                Reflect.apply(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.apply() must be a function");
         });
+    });
 
-        assertThrowsError(() => {
-            Reflect.apply(() => {}, undefined, value);
-        }, {
-            error: TypeError,
-            message: "Arguments list must be an object"
+    test("arguments list must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.apply(() => {}, undefined, value);
+            }).toThrowWithMessage(TypeError, "Arguments list must be an object");
         });
     });
+});
 
-    assert(Reflect.apply(String.prototype.charAt, "foo", [0]) === "f");
-    assert(Reflect.apply(Array.prototype.indexOf, ["hello", 123, "foo", "bar"], ["foo"]) === 2);
-
-    function Foo(foo) {
-        this.foo = foo;
-    }
+describe("normal behavior", () => {
+    test("calling built-in functions", () => {
+        expect(Reflect.apply(String.prototype.charAt, "foo", [0])).toBe("f");
+        expect(Reflect.apply(Array.prototype.indexOf, ["hello", 123, "foo", "bar"], ["foo"])).toBe(2);
+    });
 
-    var o = {};
-    assert(o.foo === undefined);
-    assert(Reflect.apply(Foo, o, ["bar"]) === undefined);
-    assert(o.foo === "bar");
+    test("|this| argument is forwarded to called function", () => {
+        function Foo(foo) {
+            this.foo = foo;
+        }
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+        var o = {};
+        expect(o.foo).toBeUndefined();
+        Reflect.apply(Foo, o, ["bar"]);
+        expect(o.foo).toBe("bar");
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.construct.js

@@ -1,54 +1,69 @@
-load("test-common.js");
+test("length is 2", () => {
+    expect(Reflect.construct).toHaveLength(2);
+});
 
-try {
-    assert(Reflect.construct.length === 2);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.construct(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.construct() must be a function"
+describe("errors", () => {
+    test("target must be a function", () => {
+        [null, undefined, "foo", 123, NaN, Infinity, {}].forEach(value => {
+            expect(() => {
+                Reflect.construct(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.construct() must be a function");
         });
+    });
 
-        assertThrowsError(() => {
-            Reflect.construct(() => {}, value);
-        }, {
-            error: TypeError,
-            message: "Arguments list must be an object"
+    test("arguments list must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.construct(() => {}, value);
+            }).toThrowWithMessage(TypeError, "Arguments list must be an object");
         });
+    });
 
-        assertThrowsError(() => {
-            Reflect.construct(() => {}, [], value);
-        }, {
-            error: TypeError,
-            message: "Optional third argument of Reflect.construct() must be a constructor"
+    test("new target must be a function", () => {
+        [null, undefined, "foo", 123, NaN, Infinity, {}].forEach(value => {
+            expect(() => {
+                Reflect.construct(() => {}, [], value);
+            }).toThrowWithMessage(TypeError, "Optional third argument of Reflect.construct() must be a constructor");
         });
     });
+});
+
+describe("normal behavior", () => {
+    test("built-in Array function", () => {
+        var a = Reflect.construct(Array, [5]);
+        expect(a instanceof Array).toBeTrue();
+        expect(a).toHaveLength(5);
+    });
+
+    test("built-in String function", () => {
+        var s = Reflect.construct(String, [123]);
+        expect(s instanceof String).toBeTrue();
+        expect(s).toHaveLength(3);
+        expect(s.toString()).toBe("123");
+    });
+
+    test("user-defined function", () => {
+        function Foo() {
+            this.name = "foo";
+        }
+
+        var o = Reflect.construct(Foo, []);
+        expect(o.name).toBe("foo");
+        expect(o instanceof Foo).toBeTrue();
+    });
+
+    test("user-defined function with different new target", () => {
+        function Foo() {
+            this.name = "foo";
+        }
+        
+        function Bar() {
+            this.name = "bar";
+        }
 
-    var a = Reflect.construct(Array, [5]);
-    assert(a instanceof Array);
-    assert(a.length === 5);
-
-    var s = Reflect.construct(String, [123]);
-    assert(s instanceof String);
-    assert(s.length === 3);
-    assert(s.toString() === "123");
-
-    function Foo() {
-        this.name = "foo";
-    }
-    
-    function Bar() {
-        this.name = "bar";
-    }
-
-    var o = Reflect.construct(Foo, [], Bar);
-    assert(o.name === "foo");
-    assert(o instanceof Foo === false);
-    assert(o instanceof Bar === true);
-
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+        var o = Reflect.construct(Foo, [], Bar);
+        expect(o.name).toBe("foo");
+        expect(o instanceof Foo).toBeFalse();
+        expect(o instanceof Bar).toBeTrue();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.defineProperty.js

@@ -1,59 +1,74 @@
-load("test-common.js");
+test("length is 3", () => {
+    expect(Reflect.defineProperty).toHaveLength(3);
+});
 
-try {
-    assert(Reflect.defineProperty.length === 3);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.defineProperty(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.defineProperty() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.defineProperty(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.defineProperty() must be an object");
         });
+    });
 
-        assertThrowsError(() => {
-            Reflect.defineProperty({}, "foo", value);
-        }, {
-            error: TypeError,
-            message: "Descriptor argument is not an object"
+    test("descriptor must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.defineProperty({}, "foo", value);
+            }).toThrowWithMessage(TypeError, "Descriptor argument is not an object");
         });
     });
+});
 
-    var o = {};
 
-    assert(Reflect.defineProperty(o, "foo", { value: 1, writable: false, enumerable: false }) === true);
-    assert(o.foo === 1);
-    o.foo = 2;
-    assert(o.foo === 1);
+describe("normal behavior", () => {
+    test("initial value and non-writable", () => {
+        var o = {};
 
-    assert(Reflect.defineProperty(o, "bar", { value: "hi", writable: true, enumerable: true }) === true);
-    assert(o.bar === "hi");
-    o.bar = "ho";
-    assert(o.bar === "ho");
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.defineProperty(o, "foo", { value: 1, writable: false })).toBeTrue();
+        expect(o.foo).toBe(1);
+        o.foo = 2;
+        expect(o.foo).toBe(1);
+    });
 
-    assert(Reflect.defineProperty(o, "bar", { value: "xx", enumerable: false }) === false);
+    test("initial value and writable", () => {
+        var o = {};
 
-    var d = Reflect.getOwnPropertyDescriptor(o, "foo");
-    assert(d.configurable === false);
-    assert(d.enumerable === false);
-    assert(d.writable === false);
-    assert(d.value === 1);
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.defineProperty(o, "foo", { value: 1, writable: true })).toBeTrue();
+        expect(o.foo).toBe(1);
+        o.foo = 2;
+        expect(o.foo).toBe(2);
+    });
 
-    d = Reflect.getOwnPropertyDescriptor(o, "bar");
-    assert(d.configurable === false);
-    assert(d.enumerable === true);
-    assert(d.writable === true);
-    assert(d.value === "ho");
+    test("can redefine value of configurable, writable property", () => {
+        var o = {};
 
-    assert(Reflect.defineProperty(o, "baz", { value: 9, configurable: true, writable: false }) === true);
-    assert(Reflect.defineProperty(o, "baz", { configurable: true, writable: true }) === true);
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.defineProperty(o, "foo", { value: 1, configurable: true, writable: true })).toBeTrue();
+        expect(o.foo).toBe(1);
+        expect(Reflect.defineProperty(o, "foo", { value: 2 })).toBeTrue();
+        expect(o.foo).toBe(2);
+    });
 
-    d = Reflect.getOwnPropertyDescriptor(o, "baz");
-    assert(d.configurable === true);
-    assert(d.writable === true);
-    assert(d.value === 9);
+    test("can redefine value of configurable, non-writable property", () => {
+        var o = {};
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.defineProperty(o, "foo", { value: 1, configurable: true, writable: false })).toBeTrue();
+        expect(o.foo).toBe(1);
+        expect(Reflect.defineProperty(o, "foo", { value: 2 })).toBeTrue();
+        expect(o.foo).toBe(2);
+    });
+
+    test("cannot redefine value of non-configurable, non-writable property", () => {
+        var o = {};
+
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.defineProperty(o, "foo", { value: 1, configurable: false, writable: false })).toBeTrue();
+        expect(o.foo).toBe(1);
+        expect(Reflect.defineProperty(o, "foo", { value: 2 })).toBeFalse();
+        expect(o.foo).toBe(1);
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.deleteProperty.js

@@ -1,47 +1,63 @@
-load("test-common.js");
-
-try {
-    assert(Reflect.deleteProperty.length === 2);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.deleteProperty(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.deleteProperty() must be an object"
+test("length is 2", () => {
+    expect(Reflect.deleteProperty).toHaveLength(2);
+});
+
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.deleteProperty(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.deleteProperty() must be an object");
         });
     });
+});
 
-    assert(Reflect.deleteProperty({}) === true);
-    assert(Reflect.deleteProperty({}, "foo") === true);
+describe("normal behavior", () => {
+    test("deleting non-existent property", () => {
+        expect(Reflect.deleteProperty({})).toBeTrue();
+        expect(Reflect.deleteProperty({}, "foo")).toBeTrue();
+    });
 
-    var o = { foo: 1 };
-    assert(o.foo === 1);
-    assert(Reflect.deleteProperty(o, "foo") === true);
-    assert(o.foo === undefined);
-    assert(Reflect.deleteProperty(o, "foo") === true);
-    assert(o.foo === undefined);
+    test("deleting existent property", () => {
+        var o = { foo: 1 };
+        expect(o.foo).toBe(1);
+        expect(Reflect.deleteProperty(o, "foo")).toBeTrue();
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.deleteProperty(o, "foo")).toBeTrue();
+        expect(o.foo).toBeUndefined();
+    });
 
-    Object.defineProperty(o, "bar", { value: 2, configurable: true, writable: false });
-    assert(Reflect.deleteProperty(o, "bar") === true);
-    assert(o.bar === undefined);
+    test("deleting existent, configurable, non-writable property", () => {
+        var o = {};
+        Object.defineProperty(o, "foo", { value: 1, configurable: true, writable: false });
+        expect(Reflect.deleteProperty(o, "foo")).toBeTrue();
+        expect(o.foo).toBeUndefined();
+    });
 
-    Object.defineProperty(o, "baz", { value: 3, configurable: false, writable: true });
-    assert(Reflect.deleteProperty(o, "baz") === false);
-    assert(o.baz === 3);
+    test("deleting existent, non-configurable, writable property", () => {
+        var o = {};
+        Object.defineProperty(o, "foo", { value: 1, configurable: false, writable: true });
+        expect(Reflect.deleteProperty(o, "foo")).toBeFalse();
+        expect(o.foo).toBe(1);
+    });
 
-    var a = [1, 2, 3];
-    assert(a.length === 3);
-    assert(a[0] === 1);
-    assert(a[1] === 2);
-    assert(a[2] === 3);
-    assert(Reflect.deleteProperty(a, 1) === true);
-    assert(a.length === 3);
-    assert(a[0] === 1);
-    assert(a[1] === undefined);
-    assert(a[2] === 3);
+    test("deleting existent, non-configurable, non-writable property", () => {
+        var o = {};
+        Object.defineProperty(o, "foo", { value: 1, configurable: false, writable: false });
+        expect(Reflect.deleteProperty(o, "foo")).toBeFalse();
+        expect(o.foo).toBe(1);
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("deleting array index", () => {
+        var a = [1, 2, 3];
+        expect(a).toHaveLength(3);
+        expect(a[0]).toBe(1);
+        expect(a[1]).toBe(2);
+        expect(a[2]).toBe(3);
+        expect(Reflect.deleteProperty(a, 1)).toBeTrue();
+        expect(a).toHaveLength(3);
+        expect(a[0]).toBe(1);
+        expect(a[1]).toBeUndefined();
+        expect(a[2]).toBe(3);
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.get.js

@@ -1,56 +1,63 @@
-load("test-common.js");
+test("length is 2", () => {
+    expect(Reflect.get).toHaveLength(2);
+});
+
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.get(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.get() must be an object");
+        });
+    });
+});
+
+describe("normal behavior", () => {
+    test("regular object", () => {
+        expect(Reflect.get({})).toBeUndefined();
+        expect(Reflect.get({ undefined: 1 })).toBe(1);
+        expect(Reflect.get({ foo: 1 })).toBeUndefined();
+        expect(Reflect.get({ foo: 1 }, "foo")).toBe(1);
+    });
 
-try {
-    assert(Reflect.get.length === 2);
+    test("array", () => {
+        expect(Reflect.get([])).toBeUndefined();
+        expect(Reflect.get([1, 2, 3])).toBeUndefined();
+        expect(Reflect.get([1, 2, 3], "0")).toBe(1);
+        expect(Reflect.get([1, 2, 3], 0)).toBe(1);
+        expect(Reflect.get([1, 2, 3], 1)).toBe(2);
+        expect(Reflect.get([1, 2, 3], 2)).toBe(3);
+        expect(Reflect.get([1, 2, 3], 4)).toBeUndefined();
+    });
 
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.get(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.get() must be an object"
-        });
+    test("string object", () => {
+        expect(Reflect.get(new String())).toBeUndefined();
+        expect(Reflect.get(new String(), 0)).toBeUndefined();
+        expect(Reflect.get(new String("foo"), "0")).toBe("f");
+        expect(Reflect.get(new String("foo"), 0)).toBe("f");
+        expect(Reflect.get(new String("foo"), 1)).toBe("o");
+        expect(Reflect.get(new String("foo"), 2)).toBe("o");
+        expect(Reflect.get(new String("foo"), 3)).toBeUndefined();
     });
 
-    assert(Reflect.get({}) === undefined);
-    assert(Reflect.get({ undefined: 1 }) === 1);
-    assert(Reflect.get({ foo: 1 }) === undefined);
-    assert(Reflect.get({ foo: 1 }, "foo") === 1);
-
-    assert(Reflect.get([]) === undefined);
-    assert(Reflect.get([1, 2, 3]) === undefined);
-    assert(Reflect.get([1, 2, 3], "0") === 1);
-    assert(Reflect.get([1, 2, 3], 0) === 1);
-    assert(Reflect.get([1, 2, 3], 1) === 2);
-    assert(Reflect.get([1, 2, 3], 2) === 3);
-    assert(Reflect.get([1, 2, 3], 4) === undefined);
-
-    assert(Reflect.get(new String()) === undefined);
-    assert(Reflect.get(new String(), 0) === undefined);
-    assert(Reflect.get(new String("foo"), "0") === "f");
-    assert(Reflect.get(new String("foo"), 0) === "f");
-    assert(Reflect.get(new String("foo"), 1) === "o");
-    assert(Reflect.get(new String("foo"), 2) === "o");
-    assert(Reflect.get(new String("foo"), 3) === undefined);
-
-    const foo = {
-        get prop() {
-            this.getPropCalled = true;
-        }
-    };
-    const bar = {};
-    Object.setPrototypeOf(bar, foo);
-
-    assert(foo.getPropCalled === undefined);
-    assert(bar.getPropCalled === undefined);
-    Reflect.get(bar, "prop");
-    assert(foo.getPropCalled === undefined);
-    assert(bar.getPropCalled === true);
-    Reflect.get(bar, "prop", foo);
-    assert(foo.getPropCalled === true);
-    assert(bar.getPropCalled === true);
-
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("getter function", () => {
+        const foo = {
+            get prop() {
+                this.getPropCalled = true;
+            }
+        };
+        const bar = {};
+        Object.setPrototypeOf(bar, foo);
+
+        expect(foo.getPropCalled).toBeUndefined();
+        expect(bar.getPropCalled).toBeUndefined();
+
+        Reflect.get(bar, "prop");
+        expect(foo.getPropCalled).toBeUndefined();
+        expect(bar.getPropCalled).toBeTrue();
+
+        Reflect.get(bar, "prop", foo);
+        expect(foo.getPropCalled).toBeTrue();
+        expect(bar.getPropCalled).toBeTrue();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.getOwnPropertyDescriptor.js

@@ -1,35 +1,38 @@
-load("test-common.js");
+test("length is 2", () => {
+    expect(Reflect.getOwnPropertyDescriptor).toHaveLength(2);
+});
 
-try {
-    assert(Reflect.getOwnPropertyDescriptor.length === 2);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.getOwnPropertyDescriptor(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.getOwnPropertyDescriptor() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.getOwnPropertyDescriptor(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.getOwnPropertyDescriptor() must be an object");
         });
     });
+});
 
-    assert(Reflect.getOwnPropertyDescriptor({}) === undefined);
-    assert(Reflect.getOwnPropertyDescriptor({}, "foo") === undefined);
-
-    var o = { foo: "bar" };
-    var d = Reflect.getOwnPropertyDescriptor(o, "foo");
-    assert(d.value === "bar");
-    assert(d.writable === true);
-    assert(d.enumerable === true);
-    assert(d.configurable === true);
+describe("normal behavior", () => {
+    test("get descriptor of undefined object property", () => {
+        expect(Reflect.getOwnPropertyDescriptor({})).toBeUndefined();
+        expect(Reflect.getOwnPropertyDescriptor({}, "foo")).toBeUndefined();
+    });
 
-    var a = [];
-    d = Reflect.getOwnPropertyDescriptor(a, "length");
-    assert(d.value === 0);
-    assert(d.writable === true);
-    assert(d.enumerable === false);
-    assert(d.configurable === false);
+    test("get descriptor of defined object property", () => {
+        var o = { foo: "bar" };
+        var d = Reflect.getOwnPropertyDescriptor(o, "foo");
+        expect(d.value).toBe("bar");
+        expect(d.writable).toBeTrue();
+        expect(d.enumerable).toBeTrue();
+        expect(d.configurable).toBeTrue();
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("get descriptor of array length property", () => {
+        var a = [];
+        d = Reflect.getOwnPropertyDescriptor(a, "length");
+        expect(d.value).toBe(0);
+        expect(d.writable).toBeTrue();
+        expect(d.enumerable).toBeFalse();
+        expect(d.configurable).toBeFalse();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.getPrototypeOf.js

@@ -1,26 +1,34 @@
-load("test-common.js");
+test("length is 1", () => {
+    expect(Reflect.getPrototypeOf).toHaveLength(1);
+});
 
-try {
-    assert(Reflect.getPrototypeOf.length === 1);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.getPrototypeOf(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.getPrototypeOf() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.getPrototypeOf(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.getPrototypeOf() must be an object");
         });
     });
+});
+
+describe("normal behavior", () => {
+    test("get prototype of regular object", () => {
+        expect(Reflect.getPrototypeOf({})).toBe(Object.prototype);
+    });
 
-    assert(Reflect.getPrototypeOf({}) === Object.prototype);
-    assert(Reflect.getPrototypeOf([]) === Array.prototype);
-    assert(Reflect.getPrototypeOf(new String()) === String.prototype);
+    test("get prototype of array", () => {
+        expect(Reflect.getPrototypeOf([])).toBe(Array.prototype);
+    });
 
-    var o = {};
-    Reflect.setPrototypeOf(o, { foo: "bar" });
-    assert(Reflect.getPrototypeOf(o).foo === "bar");
+    test("get prototype of string object", () => {
+        expect(Reflect.getPrototypeOf(new String())).toBe(String.prototype);
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("get user-defined prototype of regular object", () => {
+        var o = {};
+        var p = { foo: "bar" };
+        Reflect.setPrototypeOf(o, p);
+        expect(Reflect.getPrototypeOf(o)).toBe(p);
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.has.js

@@ -1,42 +1,45 @@
-load("test-common.js");
+test("length is 2", () => {
+    expect(Reflect.has).toHaveLength(2);
+});
 
-try {
-    assert(Reflect.has.length === 2);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.has(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.has() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.has(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.has() must be an object");
         });
     });
+});
 
-    assert(Reflect.has({}) === false);
-    assert(Reflect.has({ undefined }) === true);
-    assert(Reflect.has({ 0: "1" }, "0") === true);
-    assert(Reflect.has({ foo: "bar" }, "foo") === true);
-    assert(Reflect.has({ bar: "baz" }, "foo") === false);
-    assert(Reflect.has({}, "toString") === true);
-
-    assert(Reflect.has([]) === false);
-    assert(Reflect.has([], 0) === false);
-    assert(Reflect.has([1, 2, 3], "0") === true);
-    assert(Reflect.has([1, 2, 3], 0) === true);
-    assert(Reflect.has([1, 2, 3], 1) === true);
-    assert(Reflect.has([1, 2, 3], 2) === true);
-    assert(Reflect.has([1, 2, 3], 3) === false);
-    assert(Reflect.has([], "pop") === true);
+describe("normal behavior", () => {
+    test("regular object has property", () => {
+        expect(Reflect.has({})).toBeFalse();
+        expect(Reflect.has({ undefined })).toBeTrue();
+        expect(Reflect.has({ 0: "1" }, "0")).toBeTrue();
+        expect(Reflect.has({ foo: "bar" }, "foo")).toBeTrue();
+        expect(Reflect.has({ bar: "baz" }, "foo")).toBeFalse();
+        expect(Reflect.has({}, "toString")).toBeTrue();
+    });
 
-    assert(Reflect.has(new String()) === false);
-    assert(Reflect.has(new String("foo"), "0") === true);
-    assert(Reflect.has(new String("foo"), 0) === true);
-    assert(Reflect.has(new String("foo"), 1) === true);
-    assert(Reflect.has(new String("foo"), 2) === true);
-    assert(Reflect.has(new String("foo"), 3) === false);
-    assert(Reflect.has(new String("foo"), "charAt") === true);
+    test("array has property", () => {
+        expect(Reflect.has([])).toBeFalse();
+        expect(Reflect.has([], 0)).toBeFalse();
+        expect(Reflect.has([1, 2, 3], "0")).toBeTrue();
+        expect(Reflect.has([1, 2, 3], 0)).toBeTrue();
+        expect(Reflect.has([1, 2, 3], 1)).toBeTrue();
+        expect(Reflect.has([1, 2, 3], 2)).toBeTrue();
+        expect(Reflect.has([1, 2, 3], 3)).toBeFalse();
+        expect(Reflect.has([], "pop")).toBeTrue();
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("string object has property", () => {
+        expect(Reflect.has(new String())).toBeFalse();
+        expect(Reflect.has(new String("foo"), "0")).toBeTrue();
+        expect(Reflect.has(new String("foo"), 0)).toBeTrue();
+        expect(Reflect.has(new String("foo"), 1)).toBeTrue();
+        expect(Reflect.has(new String("foo"), 2)).toBeTrue();
+        expect(Reflect.has(new String("foo"), 3)).toBeFalse();
+        expect(Reflect.has(new String("foo"), "charAt")).toBeTrue();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.isExtensible.js

@@ -1,29 +1,30 @@
-load("test-common.js");
+test("length is 1", () => {
+    expect(Reflect.isExtensible).toHaveLength(1);
+});
 
-try {
-    assert(Reflect.isExtensible.length === 1);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.isExtensible(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.isExtensible() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.isExtensible(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.isExtensible() must be an object");
         });
     });
+});
 
-    assert(Reflect.isExtensible({}) === true);
+describe("normal behavior", () => {
+    test("regular object is extensible", () => {
+        expect(Reflect.isExtensible({})).toBeTrue();
+    });
 
-    var o = {};
-    o.foo = "foo";
-    assert(o.foo === "foo");
-    assert(Reflect.isExtensible(o) === true);
-    Reflect.preventExtensions(o);
-    o.bar = "bar";
-    assert(o.bar === undefined);
-    assert(Reflect.isExtensible(o) === false);
+    test("global object is extensible", () => {
+        expect(Reflect.isExtensible(globalThis)).toBeTrue();
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("regular object is not extensible after preventExtensions()", () => {
+        var o = {};
+        expect(Reflect.isExtensible(o)).toBeTrue();
+        Reflect.preventExtensions(o);
+        expect(Reflect.isExtensible(o)).toBeFalse();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.ownKeys.js

@@ -1,39 +1,48 @@
-load("test-common.js");
+test("length is 1", () => {
+    expect(Reflect.ownKeys).toHaveLength(1);
+});
 
-try {
-    assert(Reflect.ownKeys.length === 1);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.ownKeys(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.ownKeys() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.ownKeys(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.ownKeys() must be an object");
         });
     });
+});
 
-    var objectOwnKeys = Reflect.ownKeys({});
-    assert(objectOwnKeys.length === 0);
-
-    objectOwnKeys = Reflect.ownKeys({ foo: "bar", bar: "baz", 0: 42 });
-    assert(objectOwnKeys.length === 3);
-    assert(objectOwnKeys[0] === "0");
-    assert(objectOwnKeys[1] === "foo");
-    assert(objectOwnKeys[2] === "bar");
+describe("normal behavior", () => {
+    test("regular empty object has no own keys", () => {
+        var objectOwnKeys = Reflect.ownKeys({});
+        expect(objectOwnKeys instanceof Array).toBeTrue();
+        expect(objectOwnKeys).toHaveLength(0);
+    });
 
-    var arrayOwnKeys = Reflect.ownKeys([]);
-    assert(arrayOwnKeys.length === 1);
-    assert(arrayOwnKeys[0] === "length");
+    test("regular object with some properties has own keys", () => {
+        var objectOwnKeys = Reflect.ownKeys({ foo: "bar", bar: "baz", 0: 42 });
+        expect(objectOwnKeys instanceof Array).toBeTrue();
+        expect(objectOwnKeys).toHaveLength(3);
+        expect(objectOwnKeys[0]).toBe("0");
+        expect(objectOwnKeys[1]).toBe("foo");
+        expect(objectOwnKeys[2]).toBe("bar");
+    });
 
-    arrayOwnKeys = Reflect.ownKeys(["foo", [], 123, undefined]);
-    assert(arrayOwnKeys.length === 5);
-    assert(arrayOwnKeys[0] === "0");
-    assert(arrayOwnKeys[1] === "1");
-    assert(arrayOwnKeys[2] === "2");
-    assert(arrayOwnKeys[3] === "3");
-    assert(arrayOwnKeys[4] === "length");
+    test("empty array has only 'length' own key", () => {
+        var arrayOwnKeys = Reflect.ownKeys([]);
+        expect(arrayOwnKeys instanceof Array).toBeTrue();
+        expect(arrayOwnKeys).toHaveLength(1);
+        expect(arrayOwnKeys[0]).toBe("length");
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("array with some values has 'lenght' and indices own keys", () => {
+        var arrayOwnKeys = Reflect.ownKeys(["foo", [], 123, undefined]);
+        expect(arrayOwnKeys instanceof Array).toBeTrue();
+        expect(arrayOwnKeys).toHaveLength(5);
+        expect(arrayOwnKeys[0]).toBe("0");
+        expect(arrayOwnKeys[1]).toBe("1");
+        expect(arrayOwnKeys[2]).toBe("2");
+        expect(arrayOwnKeys[3]).toBe("3");
+        expect(arrayOwnKeys[4]).toBe("length");
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.preventExtensions.js

@@ -1,23 +1,33 @@
-load("test-common.js");
+test("length is 1", () => {
+    expect(Reflect.preventExtensions).toHaveLength(1);
+});
 
-try {
-    assert(Reflect.preventExtensions.length === 1);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.preventExtensions(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.preventExtensions() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.preventExtensions(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.preventExtensions() must be an object");
         });
     });
+});
 
-    var o = {};
-    assert(Reflect.isExtensible(o) === true);
-    assert(Reflect.preventExtensions(o) === true);
-    assert(Reflect.isExtensible(o) === false);
+describe("normal behavior", () => {
+    test("properties cannot be added", () => {
+        var o = {};
+        o.foo = "foo";
+        expect(Reflect.preventExtensions(o)).toBeTrue();
+        o.bar = "bar";
+        expect(o.foo).toBe("foo");
+        expect(o.bar).toBeUndefined();
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("property values can still be changed", () => {
+        // FIXME: This doesn't work even though it should (the value remains unchanged)
+        // var o = {};
+        // o.foo = "foo";
+        // expect(Reflect.preventExtensions(o)).toBeTrue();
+        // o.foo = "bar";
+        // expect(o.foo).toBe("bar");
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.set.js

@@ -1,72 +1,96 @@
-load("test-common.js");
+test("length is 3", () => {
+    expect(Reflect.set).toHaveLength(3);
+});
 
-try {
-    assert(Reflect.set.length === 3);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.set(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.set() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.set(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.set() must be an object");
         });
     });
+});
+
+describe("normal behavior", () => {
+    test("setting properties of regular object", () => {
+        var o = {};
+
+        expect(Reflect.set(o)).toBeTrue();
+        expect(o.undefined).toBeUndefined();
 
-    assert(Reflect.set({}) === true);
-    assert(Reflect.set({}, "foo") === true);
-    assert(Reflect.set({}, "foo", "bar") === true);
+        expect(Reflect.set(o, "foo")).toBeTrue();
+        expect(o.foo).toBeUndefined();
 
-    var o = {};
-    assert(o.foo === undefined);
-    assert(Reflect.set(o, "foo", 1) === true);
-    assert(o.foo === 1);
-    assert(Reflect.set(o, "foo", 2) === true);
-    assert(o.foo === 2);
+        expect(Reflect.set(o, "foo", "bar")).toBeTrue();
+        expect(o.foo).toBe("bar");
+
+        expect(Reflect.set(o, "foo", 42)).toBeTrue();
+        expect(o.foo).toBe(42);
+    });
 
-    Object.defineProperty(o, "bar", { value: 2, configurable: true, writable: false });
-    assert(Reflect.set(o, "bar") === false);
-    assert(o.bar === 2);
+    test("setting configurable, non-writable property of regular object", () => {
+        var o = {};
+        Object.defineProperty(o, "foo", { value: 1, configurable: true, writable: false });
+        expect(Reflect.set(o, "foo", 2)).toBeFalse();
+        expect(o.foo).toBe(1);
+    });
 
-    Object.defineProperty(o, "baz", { value: 3, configurable: false, writable: true });
-    assert(Reflect.set(o, "baz") === true);
-    assert(o.baz === undefined);
+    test("setting non-configurable, writable property of regular object", () => {
+        var o = {};
+        Object.defineProperty(o, "foo", { value: 1, configurable: false, writable: true });
+        expect(Reflect.set(o, "foo", 2)).toBeTrue();
+        expect(o.foo).toBe(2);
+    });
 
-    var a = [];
-    assert(a.length === 0);
-    assert(Reflect.set(a, "0") === true);
-    assert(a.length === 1);
-    assert(a[0] === undefined);
-    assert(Reflect.set(a, 1, "foo") === true);
-    assert(a.length === 2);
-    assert(a[0] === undefined);
-    assert(a[1] === "foo");
-    assert(Reflect.set(a, 4, "bar") === true);
-    assert(a.length === 5);
-    assert(a[0] === undefined);
-    assert(a[1] === "foo");
-    assert(a[2] === undefined);
-    assert(a[3] === undefined);
-    assert(a[4] === "bar");
+    test("", () => {
+        var a = [];
+        expect(a.length === 0);
+        expect(Reflect.set(a, "0")).toBeTrue();
+        expect(a.length === 1);
+        expect(a[0]).toBeUndefined();
+        expect(Reflect.set(a, 1, "foo")).toBeTrue();
+        expect(a.length === 2);
+        expect(a[0]).toBeUndefined();
+        expect(a[1] === "foo");
+        expect(Reflect.set(a, 4, "bar")).toBeTrue();
+        expect(a.length === 5);
+        expect(a[0]).toBeUndefined();
+        expect(a[1] === "foo");
+        expect(a[2]).toBeUndefined();
+        expect(a[3]).toBeUndefined();
+        expect(a[4] === "bar");
+    });
 
+    test("setting setter property of regular object", () => {
+        const foo = {
+            set prop(value) {
+                this.setPropCalled = true;
+            }
+        };
+        expect(foo.setPropCalled).toBeUndefined();
+        Reflect.set(foo, "prop", 42);
+        expect(foo.setPropCalled).toBeTrue();
+    });
 
-    const foo = {
-        set prop(value) {
-            this.setPropCalled = true;
-        }
-    };
-    const bar = {};
-    Object.setPrototypeOf(bar, foo);
+    test("setting setter property of regular object with different receiver", () => {
+        const foo = {
+            set prop(value) {
+                this.setPropCalled = true;
+            }
+        };
+        const bar = {};
+        Object.setPrototypeOf(bar, foo);
+    
+        expect(foo.setPropCalled).toBeUndefined();
+        expect(bar.setPropCalled).toBeUndefined();
 
-    assert(foo.setPropCalled === undefined);
-    assert(bar.setPropCalled === undefined);
-    Reflect.set(bar, "prop", 42);
-    assert(foo.setPropCalled === undefined);
-    assert(bar.setPropCalled === true);
-    Reflect.set(bar, "prop", 42, foo);
-    assert(foo.setPropCalled === true);
-    assert(bar.setPropCalled === true);
+        Reflect.set(bar, "prop", 42);
+        expect(foo.setPropCalled).toBeUndefined();
+        expect(bar.setPropCalled).toBeTrue();
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+        Reflect.set(bar, "prop", 42, foo);
+        expect(foo.setPropCalled).toBeTrue();
+        expect(bar.setPropCalled).toBeTrue();
+    });
+});

Libraries/LibJS/Tests/builtins/Reflect/Reflect.setPrototypeOf.js

@@ -1,43 +1,54 @@
-load("test-common.js");
+test("length is 2", () => {
+    expect(Reflect.setPrototypeOf).toHaveLength(2);
+});
 
-try {
-    assert(Reflect.setPrototypeOf.length === 2);
-
-    [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
-        assertThrowsError(() => {
-            Reflect.setPrototypeOf(value);
-        }, {
-            error: TypeError,
-            message: "First argument of Reflect.setPrototypeOf() must be an object"
+describe("errors", () => {
+    test("target must be an object", () => {
+        [null, undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.setPrototypeOf(value);
+            }).toThrowWithMessage(TypeError, "First argument of Reflect.setPrototypeOf() must be an object");
         });
-        if (value === null)
-            return;
-        assertThrowsError(() => {
-            Reflect.setPrototypeOf({}, value);
-        }, {
-            error: TypeError,
-            message: "Prototype must be an object or null"
+    });
+
+    test("prototype must be an object or null", () => {
+        [undefined, "foo", 123, NaN, Infinity].forEach(value => {
+            expect(() => {
+                Reflect.setPrototypeOf({}, value);
+            }).toThrowWithMessage(TypeError, "Prototype must be an object or null");
         });
     });
+});
 
-    assert(Reflect.setPrototypeOf({}, null) === true);
-    assert(Reflect.setPrototypeOf({}, {}) === true);
-    assert(Reflect.setPrototypeOf({}, Object.prototype) === true);
-    assert(Reflect.setPrototypeOf({}, Array.prototype) === true);
-    assert(Reflect.setPrototypeOf({}, String.prototype) === true);
-    assert(Reflect.setPrototypeOf({}, Reflect.getPrototypeOf({})) === true);
+describe("normal behavior", () => {
+    test("setting prototype of regular object", () => {
+        expect(Reflect.setPrototypeOf({}, null)).toBeTrue();
+        expect(Reflect.setPrototypeOf({}, {})).toBeTrue();
+        expect(Reflect.setPrototypeOf({}, Object.prototype)).toBeTrue();
+        expect(Reflect.setPrototypeOf({}, Array.prototype)).toBeTrue();
+        expect(Reflect.setPrototypeOf({}, String.prototype)).toBeTrue();
+        expect(Reflect.setPrototypeOf({}, Reflect.getPrototypeOf({}))).toBeTrue();
+    });
 
-    var o = {};
-    var p = { foo: "bar" };
-    assert(o.foo === undefined);
-    assert(Reflect.setPrototypeOf(o, p) === true);
-    assert(o.foo === "bar");
+    test("setting user-defined prototype of regular object", () => {
+        var o = {};
+        var p = { foo: "bar" };
+        expect(o.foo).toBeUndefined();
+        expect(Reflect.setPrototypeOf(o, p)).toBeTrue();
+        expect(o.foo).toBe("bar");
+    });
 
-    Reflect.preventExtensions(o);
-    assert(Reflect.setPrototypeOf(o, {}) === false);
-    assert(Reflect.setPrototypeOf(o, p) === true);
+    test("setting prototype of non-extensible object", () => {
+        var o = {};
+        Reflect.preventExtensions(o);
+        expect(Reflect.setPrototypeOf(o, {})).toBeFalse();
+    });
 
-    console.log("PASS");
-} catch (e) {
-    console.log("FAIL: " + e);
-}
+    test("setting same prototype of non-extensible object", () => {
+        var o = {};
+        var p = { foo: "bar" };
+        expect(Reflect.setPrototypeOf(o, p)).toBeTrue();
+        Reflect.preventExtensions(o);
+        expect(Reflect.setPrototypeOf(o, p)).toBeTrue();
+    });
+});

Userland/test-js.cpp

@@ -55,6 +55,19 @@ Vector<String> tests_to_run = {
     "builtins/Proxy/Proxy.handler-preventExtensions.js",
     "builtins/Proxy/Proxy.handler-set.js",
     "builtins/Proxy/Proxy.handler-setPrototypeOf.js",
+    "builtins/Reflect/Reflect.apply.js",
+    "builtins/Reflect/Reflect.construct.js",
+    "builtins/Reflect/Reflect.defineProperty.js",
+    "builtins/Reflect/Reflect.deleteProperty.js",
+    "builtins/Reflect/Reflect.get.js",
+    "builtins/Reflect/Reflect.getOwnPropertyDescriptor.js",
+    "builtins/Reflect/Reflect.getPrototypeOf.js",
+    "builtins/Reflect/Reflect.has.js",
+    "builtins/Reflect/Reflect.isExtensible.js",
+    "builtins/Reflect/Reflect.ownKeys.js",
+    "builtins/Reflect/Reflect.preventExtensions.js",
+    "builtins/Reflect/Reflect.set.js",
+    "builtins/Reflect/Reflect.setPrototypeOf.js",
     "add-values-to-primitive.js",
     "automatic-semicolon-insertion.js",
     "comments-basic.js",