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:
parent
46581773c1
commit
3f97d75778
107 changed files with 2031 additions and 2243 deletions
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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();
|
||||
});
|
||||
|
|
|
@ -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);
|
||||
});
|
||||
|
|
|
@ -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);
|
||||
});
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue