1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 01:07:36 +00:00

LibJS: Convert most builtin tests to new system

This commit is contained in:
Matthew Olsson 2020-07-04 10:09:48 -07:00 committed by Andreas Kling
parent 46581773c1
commit 3f97d75778
107 changed files with 2031 additions and 2243 deletions

View file

@ -1,17 +1,11 @@
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);
}
test("basic functionality", () => {
expect(Number.EPSILON).toBe(2 ** -52);
expect(Number.EPSILON).toBeGreaterThan(0);
expect(Number.MAX_SAFE_INTEGER).toBe(2 ** 53 - 1);
expect(Number.MAX_SAFE_INTEGER + 1).toBe(Number.MAX_SAFE_INTEGER + 2);
expect(Number.MIN_SAFE_INTEGER).toBe(-(2 ** 53 - 1));
expect(Number.MIN_SAFE_INTEGER - 1).toBe(Number.MIN_SAFE_INTEGER - 2);
expect(Number.POSITIVE_INFINITY).toBe(Infinity);
expect(Number.NEGATIVE_INFINITY).toBe(-Infinity);
expect(Number.NaN).toBeNaN();
});

View file

@ -1,30 +1,24 @@
load("test-common.js");
test("basic functionality", () => {
expect(Number.isFinite).toHaveLength(1);
expect(Number.isFinite).not.toBe(isFinite);
try {
assert(Number.isFinite !== isFinite);
assert(Number.isFinite.length === 1);
expect(Number.isFinite(0)).toBeTrue();
expect(Number.isFinite(1.23)).toBeTrue();
expect(Number.isFinite(42)).toBeTrue();
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);
}
expect(Number.isFinite("")).toBeFalse();
expect(Number.isFinite("0")).toBeFalse();
expect(Number.isFinite("42")).toBeFalse();
expect(Number.isFinite(true)).toBeFalse();
expect(Number.isFinite(false)).toBeFalse();
expect(Number.isFinite(null)).toBeFalse();
expect(Number.isFinite([])).toBeFalse();
expect(Number.isFinite()).toBeFalse();
expect(Number.isFinite(NaN)).toBeFalse();
expect(Number.isFinite(undefined)).toBeFalse();
expect(Number.isFinite(Infinity)).toBeFalse();
expect(Number.isFinite(-Infinity)).toBeFalse();
expect(Number.isFinite("foo")).toBeFalse();
expect(Number.isFinite({})).toBeFalse();
expect(Number.isFinite([1, 2, 3])).toBeFalse();
});

View file

@ -1,38 +1,32 @@
load("test-common.js");
test("basic functionality", () => {
expect(Number.isInteger).toHaveLength(1);
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);
expect(Number.isInteger(0)).toBeTrue();
expect(Number.isInteger(42)).toBeTrue();
expect(Number.isInteger(-10000)).toBeTrue();
expect(Number.isInteger(5)).toBeTrue();
expect(Number.isInteger(5.0)).toBeTrue();
expect(Number.isInteger(5 + 1/10000000000000000)).toBeTrue();
// 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);
// expect(Number.isInteger(+2147483647 + 1)).toBeTrue();
// expect(Number.isInteger(-2147483648 - 1)).toBeTrue();
// expect(Number.isInteger(99999999999999999999999999999999999)).toBeTrue();
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);
}
expect(Number.isInteger(5 + 1/1000000000000000)).toBeFalse();
expect(Number.isInteger(1.23)).toBeFalse();
expect(Number.isInteger("")).toBeFalse();
expect(Number.isInteger("0")).toBeFalse();
expect(Number.isInteger("42")).toBeFalse();
expect(Number.isInteger(true)).toBeFalse();
expect(Number.isInteger(false)).toBeFalse();
expect(Number.isInteger(null)).toBeFalse();
expect(Number.isInteger([])).toBeFalse();
expect(Number.isInteger(Infinity)).toBeFalse();
expect(Number.isInteger(-Infinity)).toBeFalse();
expect(Number.isInteger(NaN)).toBeFalse();
expect(Number.isInteger()).toBeFalse();
expect(Number.isInteger(undefined)).toBeFalse();
expect(Number.isInteger("foo")).toBeFalse();
expect(Number.isInteger({})).toBeFalse();
expect(Number.isInteger([1, 2, 3])).toBeFalse();
});

View file

@ -1,31 +1,25 @@
load("test-common.js");
test("basic functionality", () => {
expect(Number.isNaN).toHaveLength(1);
expect(Number.isNaN).not.toBe(isNaN);
try {
assert(Number.isNaN !== isNaN);
assert(Number.isNaN.length === 1);
expect(Number.isNaN(0)).toBeFalse();
expect(Number.isNaN(42)).toBeFalse();
expect(Number.isNaN("")).toBeFalse();
expect(Number.isNaN("0")).toBeFalse();
expect(Number.isNaN("42")).toBeFalse();
expect(Number.isNaN(true)).toBeFalse();
expect(Number.isNaN(false)).toBeFalse();
expect(Number.isNaN(null)).toBeFalse();
expect(Number.isNaN([])).toBeFalse();
expect(Number.isNaN(Infinity)).toBeFalse();
expect(Number.isNaN(-Infinity)).toBeFalse();
expect(Number.isNaN()).toBeFalse();
expect(Number.isNaN(undefined)).toBeFalse();
expect(Number.isNaN("foo")).toBeFalse();
expect(Number.isNaN({})).toBeFalse();
expect(Number.isNaN([1, 2, 3])).toBeFalse();
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);
}
expect(Number.isNaN(NaN)).toBeTrue();
expect(Number.isNaN(Number.NaN)).toBeTrue();
expect(Number.isNaN(0 / 0)).toBeTrue();
});

View file

@ -1,30 +1,24 @@
load("test-common.js");
test("basic functionality", () => {
expect(Number.isSafeInteger).toHaveLength(1);
try {
assert(Number.isSafeInteger.length === 1);
expect(Number.isSafeInteger(0)).toBeTrue();
expect(Number.isSafeInteger(1)).toBeTrue();
expect(Number.isSafeInteger(2.0)).toBeTrue();
expect(Number.isSafeInteger(42)).toBeTrue();
expect(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)).toBeTrue();
expect(Number.isSafeInteger(Number.MIN_SAFE_INTEGER)).toBeTrue();
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);
}
expect(Number.isSafeInteger()).toBeFalse();
expect(Number.isSafeInteger("1")).toBeFalse();
expect(Number.isSafeInteger(2.1)).toBeFalse();
expect(Number.isSafeInteger(42.42)).toBeFalse();
expect(Number.isSafeInteger("")).toBeFalse();
expect(Number.isSafeInteger([])).toBeFalse();
expect(Number.isSafeInteger(null)).toBeFalse();
expect(Number.isSafeInteger(undefined)).toBeFalse();
expect(Number.isSafeInteger(NaN)).toBeFalse();
expect(Number.isSafeInteger(Infinity)).toBeFalse();
expect(Number.isSafeInteger(-Infinity)).toBeFalse();
expect(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)).toBeFalse();
expect(Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1)).toBeFalse();
});

View file

@ -1,39 +1,33 @@
load("test-common.js");
test("basic functionality", () => {
expect(Number).toHaveLength(1);
expect(Number.name).toBe("Number");
expect(Number.prototype).not.toHaveProperty("length");
try {
assert(Number.length === 1);
assert(Number.name === "Number");
assert(Number.prototype.length === undefined);
expect(typeof Number()).toBe("number");
expect(typeof new Number()).toBe("object");
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);
}
expect(Number()).toBe(0);
expect(new Number().valueOf()).toBe(0);
expect(Number("42")).toBe(42);
expect(new Number("42").valueOf()).toBe(42);
expect(Number(null)).toBe(0);
expect(new Number(null).valueOf()).toBe(0);
expect(Number(true)).toBe(1);
expect(new Number(true).valueOf()).toBe(1);
expect(Number("Infinity")).toBe(Infinity);
expect(new Number("Infinity").valueOf()).toBe(Infinity);
expect(Number("+Infinity")).toBe(Infinity);
expect(new Number("+Infinity").valueOf()).toBe(Infinity);
expect(Number("-Infinity")).toBe(-Infinity);
expect(new Number("-Infinity").valueOf()).toBe(-Infinity);
expect(Number(undefined)).toBeNaN();
expect(new Number(undefined).valueOf()).toBeNaN();
expect(Number({})).toBeNaN();
expect(new Number({}).valueOf()).toBeNaN();
expect(Number({a: 1})).toBeNaN();
expect(new Number({a: 1}).valueOf()).toBeNaN();
expect(Number([1, 2, 3])).toBeNaN();
expect(new Number([1, 2, 3]).valueOf()).toBeNaN();
expect(Number("foo")).toBeNaN();
expect(new Number("foo").valueOf()).toBeNaN();
});

View file

@ -1,11 +1,5 @@
load("test-common.js");
try {
test("basic functionality", () => {
// 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);
}
expect(Number.parseFloat).toBe(parseFloat);
});

View file

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