LibJS: Reorganize tests into subfolders

Libraries/LibJS/Tests/builtins/Number/Number-constants.js

@@ -0,0 +1,17 @@
+load("test-common.js");
+
+try {
+    assert(Number.EPSILON === 2 ** -52);
+    assert(Number.EPSILON > 0);
+    assert(Number.MAX_SAFE_INTEGER === 2 ** 53 - 1);
+    assert(Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2);
+    assert(Number.MIN_SAFE_INTEGER === -(2 ** 53 - 1));
+    assert(Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2);
+    assert(Number.POSITIVE_INFINITY === Infinity);
+    assert(Number.NEGATIVE_INFINITY === -Infinity);
+    assert(isNaN(Number.NaN));
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/builtins/Number/Number.isFinite.js

@@ -0,0 +1,30 @@
+load("test-common.js");
+
+try {
+    assert(Number.isFinite !== isFinite);
+    assert(Number.isFinite.length === 1);
+
+    assert(Number.isFinite(0) === true);
+    assert(Number.isFinite(1.23) === true);
+    assert(Number.isFinite(42) === true);
+
+    assert(Number.isFinite("") === false);
+    assert(Number.isFinite("0") === false);
+    assert(Number.isFinite("42") === false);
+    assert(Number.isFinite(true) === false);
+    assert(Number.isFinite(false) === false);
+    assert(Number.isFinite(null) === false);
+    assert(Number.isFinite([]) === false);
+    assert(Number.isFinite() === false);
+    assert(Number.isFinite(NaN) === false);
+    assert(Number.isFinite(undefined) === false);
+    assert(Number.isFinite(Infinity) === false);
+    assert(Number.isFinite(-Infinity) === false);
+    assert(Number.isFinite("foo") === false);
+    assert(Number.isFinite({}) === false);
+    assert(Number.isFinite([1, 2, 3]) === false);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e.message);
+}

Libraries/LibJS/Tests/builtins/Number/Number.isInteger.js

@@ -0,0 +1,38 @@
+load("test-common.js");
+
+try {
+    assert(Number.isInteger.length === 1);
+
+    assert(Number.isInteger(0) === true);
+    assert(Number.isInteger(42) === true);
+    assert(Number.isInteger(-10000) === true);
+    assert(Number.isInteger(5) === true);
+    assert(Number.isInteger(5.0) === true);
+    assert(Number.isInteger(5 + 1/10000000000000000) === true);
+    // FIXME: values outside of i32's range should still return true
+    // assert(Number.isInteger(+2147483647 + 1) === true);
+    // assert(Number.isInteger(-2147483648 - 1) === true);
+    // assert(Number.isInteger(99999999999999999999999999999999999) === true);
+
+    assert(Number.isInteger(5 + 1/1000000000000000) === false);
+    assert(Number.isInteger(1.23) === false);
+    assert(Number.isInteger("") === false);
+    assert(Number.isInteger("0") === false);
+    assert(Number.isInteger("42") === false);
+    assert(Number.isInteger(true) === false);
+    assert(Number.isInteger(false) === false);
+    assert(Number.isInteger(null) === false);
+    assert(Number.isInteger([]) === false);
+    assert(Number.isInteger(Infinity) === false);
+    assert(Number.isInteger(-Infinity) === false);
+    assert(Number.isInteger(NaN) === false);
+    assert(Number.isInteger() === false);
+    assert(Number.isInteger(undefined) === false);
+    assert(Number.isInteger("foo") === false);
+    assert(Number.isInteger({}) === false);
+    assert(Number.isInteger([1, 2, 3]) === false);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e.message);
+}

Libraries/LibJS/Tests/builtins/Number/Number.isNaN.js

@@ -0,0 +1,31 @@
+load("test-common.js");
+
+try {
+    assert(Number.isNaN !== isNaN);
+    assert(Number.isNaN.length === 1);
+
+    assert(Number.isNaN(0) === false);
+    assert(Number.isNaN(42) === false);
+    assert(Number.isNaN("") === false);
+    assert(Number.isNaN("0") === false);
+    assert(Number.isNaN("42") === false);
+    assert(Number.isNaN(true) === false);
+    assert(Number.isNaN(false) === false);
+    assert(Number.isNaN(null) === false);
+    assert(Number.isNaN([]) === false);
+    assert(Number.isNaN(Infinity) === false);
+    assert(Number.isNaN(-Infinity) === false);
+    assert(Number.isNaN() === false);
+    assert(Number.isNaN(undefined) === false);
+    assert(Number.isNaN("foo") === false);
+    assert(Number.isNaN({}) === false);
+    assert(Number.isNaN([1, 2, 3]) === false);
+
+    assert(Number.isNaN(NaN) === true);
+    assert(Number.isNaN(Number.NaN) === true);
+    assert(Number.isNaN(0 / 0) === true);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e.message);
+}

Libraries/LibJS/Tests/builtins/Number/Number.isSafeInteger.js

@@ -0,0 +1,30 @@
+load("test-common.js");
+
+try {
+    assert(Number.isSafeInteger.length === 1);
+
+    assert(Number.isSafeInteger(0) === true);
+    assert(Number.isSafeInteger(1) === true);
+    assert(Number.isSafeInteger(2.0) === true);
+    assert(Number.isSafeInteger(42) === true);
+    assert(Number.isSafeInteger(Number.MAX_SAFE_INTEGER) === true);
+    assert(Number.isSafeInteger(Number.MIN_SAFE_INTEGER) === true);
+
+    assert(Number.isSafeInteger() === false);
+    assert(Number.isSafeInteger("1") === false);
+    assert(Number.isSafeInteger(2.1) === false);
+    assert(Number.isSafeInteger(42.42) === false);
+    assert(Number.isSafeInteger("") === false);
+    assert(Number.isSafeInteger([]) === false);
+    assert(Number.isSafeInteger(null) === false);
+    assert(Number.isSafeInteger(undefined) === false);
+    assert(Number.isSafeInteger(NaN) === false);
+    assert(Number.isSafeInteger(Infinity) === false);
+    assert(Number.isSafeInteger(-Infinity) === false);
+    assert(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) === false);
+    assert(Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) === false);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e.message);
+}

Libraries/LibJS/Tests/builtins/Number/Number.js

@@ -0,0 +1,39 @@
+load("test-common.js");
+
+try {
+    assert(Number.length === 1);
+    assert(Number.name === "Number");
+    assert(Number.prototype.length === undefined);
+
+    assert(typeof Number() === "number");
+    assert(typeof new Number() === "object");
+
+    assert(Number() === 0);
+    assert(new Number().valueOf() === 0);
+    assert(Number("42") === 42);
+    assert(new Number("42").valueOf() === 42);
+    assert(Number(null) === 0);
+    assert(new Number(null).valueOf() === 0);
+    assert(Number(true) === 1);
+    assert(new Number(true).valueOf() === 1);
+    assert(Number("Infinity") === Infinity);
+    assert(new Number("Infinity").valueOf() === Infinity);
+    assert(Number("+Infinity") === Infinity);
+    assert(new Number("+Infinity").valueOf() === Infinity);
+    assert(Number("-Infinity") === -Infinity);
+    assert(new Number("-Infinity").valueOf() === -Infinity);
+    assert(isNaN(Number(undefined)));
+    assert(isNaN(new Number(undefined).valueOf()));
+    assert(isNaN(Number({})));
+    assert(isNaN(new Number({}).valueOf()));
+    assert(isNaN(Number({a: 1})));
+    assert(isNaN(new Number({a: 1}).valueOf()));
+    assert(isNaN(Number([1, 2, 3])));
+    assert(isNaN(new Number([1, 2, 3]).valueOf()));
+    assert(isNaN(Number("foo")));
+    assert(isNaN(new Number("foo").valueOf()));
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e.message);
+}

Libraries/LibJS/Tests/builtins/Number/Number.parseFloat.js

@@ -0,0 +1,11 @@
+load("test-common.js");
+
+try {
+    // Ensuring it's the same function as the global
+    // parseFloat() is enough as that already has tests :^)
+    assert(Number.parseFloat === parseFloat);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

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

@@ -0,0 +1,10 @@
+load("test-common.js");
+
+try {
+  assert(typeof Number.prototype === "object");
+  assert(Number.prototype.valueOf() === 0);
+
+  console.log("PASS");
+} catch (err) {
+  console.log("FAIL: " + err);
+}