LibJS: Reorganize tests into subfolders

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

@@ -0,0 +1,123 @@
+load("test-common.js");
+
+try {
+    var o = {};
+    Object.defineProperty(o, "foo", { value: 1, writable: false, enumerable: false });
+
+    assert(o.foo === 1);
+    o.foo = 2;
+    assert(o.foo === 1);
+    Object.defineProperty(o, 2, { get() { return 10; } });
+    assert(o[2] === 10);
+
+    var d = Object.getOwnPropertyDescriptor(o, "foo");
+    assert(d.configurable === false);
+    assert(d.enumerable === false);
+    assert(d.writable === false);
+    assert(d.value === 1);
+
+    Object.defineProperty(o, "bar", { value: "hi", writable: true, enumerable: true });
+
+    assert(o.bar === "hi");
+    o.bar = "ho";
+    assert(o.bar === "ho");
+
+    d = Object.getOwnPropertyDescriptor(o, "bar");
+    assert(d.configurable === false);
+    assert(d.enumerable === true);
+    assert(d.writable === true);
+    assert(d.value === "ho");
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "bar", { value: "xx", enumerable: false });
+    }, {
+        error: TypeError
+    });
+
+    Object.defineProperty(o, "baz", { value: 9, configurable: true, writable: false });
+    Object.defineProperty(o, "baz", { configurable: true, writable: true });
+
+    d = Object.getOwnPropertyDescriptor(o, "baz");
+    assert(d.configurable === true);
+    assert(d.writable === true);
+    assert(d.value === 9);
+
+    Object.defineProperty(o, "qux", {
+        configurable: true,
+        get() {
+            return o.secret_qux + 1;
+        },
+        set(value) {
+            this.secret_qux = value + 1;
+        },
+    });
+
+    o.qux = 10;
+    assert(o.qux === 12);
+    o.qux = 20;
+    assert(o.qux = 22);
+
+    Object.defineProperty(o, "qux", { configurable: true, value: 4 });
+
+    assert(o.qux === 4);
+    o.qux = 5;
+    assert(o.qux = 4);
+
+    Object.defineProperty(o, "qux", {
+        configurable: false,
+        get() {
+            return this.secret_qux + 2;
+        },
+        set(value) {
+            o.secret_qux = value + 2;
+        },
+    });
+
+    o.qux = 10;
+    assert(o.qux === 14);
+    o.qux = 20;
+    assert(o.qux = 24);
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "qux", {
+            configurable: false,
+            get() {
+                return this.secret_qux + 2;
+            },
+        });
+    }, {
+        error: TypeError,
+        message: "Cannot change attributes of non-configurable property 'qux'",
+    });
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "qux", { value: 2 });
+    }, {
+        error: TypeError,
+        message: "Cannot change attributes of non-configurable property 'qux'",
+    });
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "a", {
+            get() {},
+            value: 9,
+        });
+    }, {
+        error: TypeError,
+        message: "Accessor property descriptor cannot specify a value or writable key",
+    });
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "a", {
+            set() {},
+            writable: true,
+        });
+    }, {
+        error: TypeError,
+        message: "Accessor property descriptor cannot specify a value or writable key",
+    });
+
+    console.log("PASS");
+} catch (e) {
+    console.log(e)
+}

Libraries/LibJS/Tests/builtins/Object/Object.entries.js

@@ -0,0 +1,54 @@
+load("test-common.js");
+
+try {
+    assert(Object.entries.length === 1);
+    assert(Object.entries(true).length === 0);
+    assert(Object.entries(45).length === 0);
+    assert(Object.entries(-998).length === 0);
+    assert(Object.entries("abcd").length === 4);
+    assert(Object.entries([1, 2, 3]).length === 3);
+    assert(Object.entries({ a: 1, b: 2, c: 3 }).length === 3);
+
+    assertThrowsError(() => {
+        Object.entries(null);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    assertThrowsError(() => {
+        Object.entries(undefined);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    let entries = Object.entries({ foo: 1, bar: 2, baz: 3 });
+    assert(
+        entries.length === 3 && entries[0].length === 2 && 
+        entries[1].length === 2 && entries[2].length === 2 &&
+        entries[0][0] === "foo" && entries[0][1] === 1 &&
+        entries[1][0] === "bar" && entries[1][1] === 2 &&
+        entries[2][0] === "baz" && entries[2][1] === 3
+    );
+
+    entries = Object.entries(["a", "b", "c"]);
+    assert(
+        entries.length === 3 && entries[0].length === 2 && 
+        entries[1].length === 2 && entries[2].length === 2 &&
+        entries[0][0] === "0" && entries[0][1] === "a" &&
+        entries[1][0] === "1" && entries[1][1] === "b" &&
+        entries[2][0] === "2" && entries[2][1] === "c"
+    );
+
+    let obj = { foo: 1 };
+    Object.defineProperty(obj, "getFoo", {
+        value: function() { return this.foo; },
+    });
+    let entries = Object.entries(obj);
+    assert(entries.length === 1 && entries[0][0] === "foo" && entries[0][1] === 1);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+} 

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

@@ -0,0 +1,51 @@
+load("test-common.js");
+
+try {
+    let o = {
+        foo: "bar",
+        get x() { },
+        set ["hi" + 1](_) { },
+    };
+
+    Object.defineProperty(o, "baz", {
+        enumerable: false,
+        writable: true,
+        value: 10,
+    });
+
+    let d = Object.getOwnPropertyDescriptor(o, "foo");
+    assert(d.enumerable === true);
+    assert(d.configurable === true);
+    assert(d.writable === true);
+    assert(d.value === "bar");
+    assert(d.get === undefined);
+    assert(d.set === undefined);
+
+    let d = Object.getOwnPropertyDescriptor(o, "x");
+    assert(d.enumerable === true);
+    assert(d.configurable === true);
+    assert(d.writable === undefined);
+    assert(d.value === undefined);
+    assert(typeof d.get === "function");
+    assert(d.set === undefined);
+
+    let d = Object.getOwnPropertyDescriptor(o, "hi1");
+    assert(d.enumerable === true);
+    assert(d.configurable === true);
+    assert(d.writable === undefined);
+    assert(d.value === undefined);
+    assert(d.get === undefined);
+    assert(typeof d.set === "function");
+
+    let d = Object.getOwnPropertyDescriptor(o, "baz");
+    assert(d.enumerable === false);
+    assert(d.configurable === false);
+    assert(d.writable === true);
+    assert(d.value === 10);
+    assert(d.get === undefined);
+    assert(d.set === undefined);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.getOwnPropertyNames.js

@@ -0,0 +1,21 @@
+load("test-common.js");
+
+try {
+    let names = Object.getOwnPropertyNames([1, 2, 3]);
+
+    assert(names.length === 4);
+    assert(names[0] === "0");
+    assert(names[1] === "1");
+    assert(names[2] === "2");
+    assert(names[3] === "length");
+
+    names = Object.getOwnPropertyNames({ foo: 1, bar: 2, baz: 3 });
+    assert(names.length === 3);
+    assert(names[0] === "foo");
+    assert(names[1] === "bar");
+    assert(names[2] === "baz");
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

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

@@ -0,0 +1,11 @@
+load("test-common.js");
+
+try {
+    var o1 = new Object();
+    var o2 = {};
+    assert(Object.getPrototypeOf(o1) === Object.getPrototypeOf(o2));
+    assert(Object.getPrototypeOf(Object.getPrototypeOf(o1)) === null);
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.is.js

@@ -0,0 +1,53 @@
+load("test-common.js");
+
+try {
+    assert(Object.is.length === 2);
+
+    var a = [1, 2, 3];
+    var o = {foo: "bar"};
+
+    assert(Object.is("", "") === true);
+    assert(Object.is("foo", "foo") === true);
+    assert(Object.is(0, 0) === true);
+    assert(Object.is(+0, +0) === true);
+    assert(Object.is(-0, -0) === true);
+    assert(Object.is(1.23, 1.23) === true);
+    assert(Object.is(42, 42) === true);
+    assert(Object.is(NaN, NaN) === true);
+    assert(Object.is(Infinity, Infinity) === true);
+    assert(Object.is(+Infinity, +Infinity) === true);
+    assert(Object.is(-Infinity, -Infinity) === true);
+    assert(Object.is(true, true) === true);
+    assert(Object.is(false, false) === true);
+    assert(Object.is(null, null) === true);
+    assert(Object.is(undefined, undefined) === true);
+    assert(Object.is(undefined) === true);
+    assert(Object.is() === true);
+    assert(Object.is(a, a) === true);
+    assert(Object.is(o, o) === true);
+
+    assert(Object.is("test") === false);
+    assert(Object.is("foo", "bar") === false);
+    assert(Object.is(1, "1") === false);
+    assert(Object.is(+0, -0) === false);
+    assert(Object.is(-0, +0) === false);
+    assert(Object.is(42, 24) === false);
+    assert(Object.is(Infinity, -Infinity) === false);
+    assert(Object.is(-Infinity, +Infinity) === false);
+    assert(Object.is(true, false) === false);
+    assert(Object.is(false, true) === false);
+    assert(Object.is(undefined, null) === false);
+    assert(Object.is(null, undefined) === false);
+    assert(Object.is([], []) === false);
+    assert(Object.is(a, [1, 2, 3]) === false);
+    assert(Object.is([1, 2, 3], a) === false);
+    assert(Object.is({}, {}) === false);
+    assert(Object.is(o, {foo: "bar"}) === false);
+    assert(Object.is({foo: "bar"}, o) === false);
+    assert(Object.is(a, o) === false);
+    assert(Object.is(o, a) === false);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

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

@@ -0,0 +1,22 @@
+load("test-common.js");
+
+try {
+    assert(Object.isExtensible() === false);
+    assert(Object.isExtensible(undefined) === false);
+    assert(Object.isExtensible(null) === false);
+    assert(Object.isExtensible(true) === false);
+    assert(Object.isExtensible(6) === false);
+    assert(Object.isExtensible("test") === false);
+
+    let s = Symbol();
+    assert(Object.isExtensible(s) === false);
+
+    let o = { foo: "foo" };
+    assert(Object.isExtensible(o) === true);
+    Object.preventExtensions(o);
+    assert(Object.isExtensible(o) === false);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.js

@@ -0,0 +1,14 @@
+load("test-common.js");
+
+try {
+    assert(Object.length === 1);
+    assert(Object.name === "Object");
+    assert(Object.prototype.length === undefined);
+
+    assert(typeof Object() === "object");
+    assert(typeof new Object() === "object");
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.keys.js

@@ -0,0 +1,42 @@
+load("test-common.js");
+
+try {
+    assert(Object.keys.length === 1);
+    assert(Object.keys(true).length === 0);
+    assert(Object.keys(45).length === 0);
+    assert(Object.keys(-998).length === 0);
+    assert(Object.keys("abcd").length === 4);
+    assert(Object.keys([1, 2, 3]).length === 3);
+    assert(Object.keys({ a: 1, b: 2, c: 3 }).length === 3);
+
+    assertThrowsError(() => {
+        Object.keys(null);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    assertThrowsError(() => {
+        Object.keys(undefined);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    let keys = Object.keys({ foo: 1, bar: 2, baz: 3 });
+    assert(keys[0] === "foo" && keys[1] === "bar" && keys[2] === "baz");
+
+    keys = Object.keys(["a", "b", "c"]);
+    assert(keys[0] === "0" && keys[1] === "1" && keys[2] === "2");
+
+    let obj = { foo: 1 };
+    Object.defineProperty(obj, 'getFoo', {
+        value: function() { return this.foo; },
+    });
+    keys = Object.keys(obj);
+    assert(keys.length === 1 && keys[0] === 'foo');
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+} 

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

@@ -0,0 +1,54 @@
+load("test-common.js");
+
+try {
+    assert(Object.preventExtensions() === undefined);
+    assert(Object.preventExtensions(undefined) === undefined);
+    assert(Object.preventExtensions(null) === null);
+    assert(Object.preventExtensions(true) === true);
+    assert(Object.preventExtensions(6) === 6);
+    assert(Object.preventExtensions("test") === "test");
+
+    let s = Symbol();
+    assert(Object.preventExtensions(s) === s);
+
+    let o = { foo: "foo" };
+    assert(o.foo === "foo");
+    o.bar = "bar";
+    assert(o.bar === "bar");
+
+    assert(Object.preventExtensions(o) === o);
+    assert(o.foo === "foo");
+    assert(o.bar === "bar");
+
+    o.baz = "baz";
+    assert(o.baz === undefined);
+
+    assertThrowsError(() => {
+        Object.defineProperty(o, "baz", { value: "baz" });
+    }, {
+        error: TypeError,
+        message: "Cannot define property baz on non-extensible object",
+    });
+
+    assert(o.baz === undefined);
+
+    assertThrowsError(() => {
+        "use strict";
+        o.baz = "baz";
+    }, {
+        error: TypeError,
+        message: "Cannot define property baz on non-extensible object",
+    });
+
+    assertThrowsError(() => {
+        "use strict";
+        Object.defineProperty(o, "baz", { value: "baz" });
+    }, {
+        error: TypeError,
+        message: "Cannot define property baz on non-extensible object",
+    });
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.prototype.constructor.js

@@ -0,0 +1,36 @@
+load("test-common.js");
+
+try {
+    assert(Array.prototype.constructor === Array);
+    assert(Boolean.prototype.constructor === Boolean);
+    assert(Date.prototype.constructor === Date);
+    assert(Error.prototype.constructor === Error);
+    assert(Function.prototype.constructor === Function);
+    assert(Number.prototype.constructor === Number);
+    assert(Object.prototype.constructor === Object);
+
+    o = {};
+    assert(o.constructor === Object);
+
+    o = new Object();
+    assert(o.constructor === Object);
+
+    a = [];
+    assert(a.constructor === Array);
+
+    a = new Array();
+    assert(a.constructor === Array);
+
+    n = new Number(3);
+    assert(n.constructor === Number);
+
+    d = Object.getOwnPropertyDescriptor(Object.prototype, "constructor");
+    assert(d.configurable === true);
+    assert(d.enumerable === false);
+    assert(d.writable === true);
+    assert(d.value === Object);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.prototype.hasOwnProperty.js

@@ -0,0 +1,17 @@
+load("test-common.js");
+
+try {
+    var o = {};
+    o.foo = 1;
+    assert(o.hasOwnProperty("foo") === true);
+    assert(o.hasOwnProperty("bar") === false);
+    assert(o.hasOwnProperty() === false);
+    assert(o.hasOwnProperty(undefined) === false);
+    o.undefined = 2;
+    assert(o.hasOwnProperty() === true);
+    assert(o.hasOwnProperty(undefined) === true);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.prototype.js

@@ -0,0 +1,10 @@
+load("test-common.js");
+
+try {
+    var o = new Object();
+    Object.prototype.foo = 123;
+    assert(o.foo === 123);
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.prototype.toLocaleString.js

@@ -0,0 +1,32 @@
+load("test-common.js");
+
+try {
+    assert(Object.prototype.toLocaleString.length === 0);
+
+    var o;
+
+    o = {};
+    assert(o.toString() === o.toLocaleString());
+
+    o = { toString: () => 42 };
+    assert(o.toString() === 42);
+
+    o = { toString: () => { throw Error(); } };
+    assertThrowsError(() => {
+        o.toLocaleString();
+    }, {
+        error: Error
+    });
+
+    o = { toString: "foo" };
+    assertThrowsError(() => {
+        o.toLocaleString();
+    }, {
+        error: TypeError,
+        message: "foo is not a function"
+    });
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.prototype.toString.js

@@ -0,0 +1,8 @@
+load("test-common.js");
+
+try {
+    assert(typeof Object.prototype.toString() === "string");
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

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

@@ -0,0 +1,36 @@
+load("test-common.js");
+
+try {
+    assert(Object.setPrototypeOf.length === 2);
+
+    assertThrowsError(() => {
+        Object.setPrototypeOf();
+    }, {
+        error: TypeError,
+        message: "Object.setPrototypeOf requires at least two arguments",
+    });
+
+    assertThrowsError(() => {
+        Object.setPrototypeOf({}, "foo");
+    }, {
+        error: TypeError,
+        message: "Prototype must be an object or null"
+    });
+
+    o = {};
+    p = {};
+    assert(Object.setPrototypeOf(o, p) === o);
+
+    Object.preventExtensions(o);
+    assertThrowsError(() => {
+        Object.setPrototypeOf(o, {});
+    }, {
+        error: TypeError,
+        message: "Object's [[SetPrototypeOf]] method returned false"
+    });
+    assert(Object.setPrototypeOf(o, p) === o);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Object/Object.values.js

@@ -0,0 +1,42 @@
+load("test-common.js");
+
+try {
+    assert(Object.values.length === 1);
+    assert(Object.values(true).length === 0);
+    assert(Object.values(45).length === 0);
+    assert(Object.values(-998).length === 0);
+    assert(Object.values("abcd").length === 4);
+    assert(Object.values([1, 2, 3]).length === 3);
+    assert(Object.values({ a: 1, b: 2, c: 3 }).length === 3);
+
+    assertThrowsError(() => {
+        Object.values(null);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    assertThrowsError(() => {
+        Object.values(undefined);
+    }, {
+        error: TypeError,
+        message: "ToObject on null or undefined",
+    });
+
+    let values = Object.values({ foo: 1, bar: 2, baz: 3 });
+    assert(values[0] === 1 && values[1] === 2 && values[2] === 3);
+
+    values = Object.values(["a", "b", "c"]);
+    assert(values[0] === "a" && values[1] === "b" && values[2] === "c");
+
+    let obj = { foo: 1 };
+    Object.defineProperty(obj, 'getFoo', {
+        value: function() { return this.foo; },
+    });
+    let values = Object.values(obj);
+    assert(values.length === 1 && values[0] === 1);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}