1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-23 09:55:08 +00:00
serenity/Userland/Libraries/LibJS/Tests/test-common.js
davidot 45646eee43 LibJS: Fix Map Iterators when elements are deleted during iteration
Before this would assume that the element found in operator++ was still
valid when dereferencing it in operator*.
Since any code can have been run since that increment this is not always
valid.
To further simplify the logic of the iterator we no longer store the
index in an optional.
2022-02-10 14:09:39 +00:00

579 lines
18 KiB
JavaScript

var describe;
var test;
var expect;
// Stores the results of each test and suite. Has a terrible
// name to avoid name collision.
var __TestResults__ = {};
// So test names like "toString" don't automatically produce an error
Object.setPrototypeOf(__TestResults__, null);
// This array is used to communicate with the C++ program. It treats
// each message in this array as a separate message. Has a terrible
// name to avoid name collision.
var __UserOutput__ = [];
// We also rebind console.log here to use the array above
console.log = (...args) => {
__UserOutput__.push(args.join(" "));
};
class ExpectationError extends Error {
constructor(message) {
super(message);
this.name = "ExpectationError";
}
}
// Use an IIFE to avoid polluting the global namespace as much as possible
(() => {
// FIXME: This is a very naive deepEquals algorithm
const deepEquals = (a, b) => {
if (Array.isArray(a)) return Array.isArray(b) && deepArrayEquals(a, b);
if (typeof a === "object") return typeof b === "object" && deepObjectEquals(a, b);
return Object.is(a, b);
};
const deepArrayEquals = (a, b) => {
if (a.length !== b.length) return false;
for (let i = 0; i < a.length; ++i) {
if (!deepEquals(a[i], b[i])) return false;
}
return true;
};
const deepObjectEquals = (a, b) => {
if (a === null) return b === null;
for (let key of Reflect.ownKeys(a)) {
if (!deepEquals(a[key], b[key])) return false;
}
return true;
};
const valueToString = value => {
try {
return String(value);
} catch {
// e.g for objects without a prototype, the above throws.
return Object.prototype.toString.call(value);
}
};
class Expector {
constructor(target, inverted) {
this.target = target;
this.inverted = !!inverted;
}
get not() {
return new Expector(this.target, !this.inverted);
}
toBe(value) {
this.__doMatcher(() => {
this.__expect(
Object.is(this.target, value),
() =>
`toBe: expected _${valueToString(value)}_, got _${valueToString(
this.target
)}_`
);
});
}
// FIXME: Take a precision argument like jest's toBeCloseTo matcher
toBeCloseTo(value) {
this.__expect(
typeof this.target === "number",
() => `toBeCloseTo: expected target of type number, got ${typeof value}`
);
this.__expect(
typeof value === "number",
() => `toBeCloseTo: expected argument of type number, got ${typeof value}`
);
this.__doMatcher(() => {
this.__expect(Math.abs(this.target - value) < 0.000001);
});
}
toHaveLength(length) {
this.__expect(
typeof this.target.length === "number",
() => "toHaveLength: target.length not of type number"
);
this.__doMatcher(() => {
this.__expect(Object.is(this.target.length, length));
});
}
toHaveSize(size) {
this.__expect(
typeof this.target.size === "number",
() => "toHaveSize: target.size not of type number"
);
this.__doMatcher(() => {
this.__expect(Object.is(this.target.size, size));
});
}
toHaveProperty(property, value) {
this.__doMatcher(() => {
let object = this.target;
if (typeof property === "string" && property.includes(".")) {
let propertyArray = [];
while (property.includes(".")) {
let index = property.indexOf(".");
propertyArray.push(property.substring(0, index));
if (index + 1 >= property.length) break;
property = property.substring(index + 1, property.length);
}
propertyArray.push(property);
property = propertyArray;
}
if (Array.isArray(property)) {
for (let key of property) {
this.__expect(object !== undefined && object !== null);
object = object[key];
}
} else {
object = object[property];
}
this.__expect(object !== undefined);
if (value !== undefined) this.__expect(deepEquals(object, value));
});
}
toBeDefined() {
this.__doMatcher(() => {
this.__expect(
this.target !== undefined,
() => "toBeDefined: expected target to be defined, got undefined"
);
});
}
toBeInstanceOf(class_) {
this.__doMatcher(() => {
this.__expect(this.target instanceof class_);
});
}
toBeNull() {
this.__doMatcher(() => {
this.__expect(this.target === null);
});
}
toBeUndefined() {
this.__doMatcher(() => {
this.__expect(
this.target === undefined,
() =>
`toBeUndefined: expected target to be undefined, got _${valueToString(
this.target
)}_`
);
});
}
toBeNaN() {
this.__doMatcher(() => {
this.__expect(
isNaN(this.target),
() => `toBeNaN: expected target to be NaN, got _${valueToString(this.target)}_`
);
});
}
toBeTrue() {
this.__doMatcher(() => {
this.__expect(
this.target === true,
() =>
`toBeTrue: expected target to be true, got _${valueToString(this.target)}_`
);
});
}
toBeFalse() {
this.__doMatcher(() => {
this.__expect(
this.target === false,
() =>
`toBeFalse: expected target to be false, got _${valueToString(
this.target
)}_`
);
});
}
__validateNumericComparisonTypes(value) {
this.__expect(typeof this.target === "number" || typeof this.target === "bigint");
this.__expect(typeof value === "number" || typeof value === "bigint");
this.__expect(typeof this.target === typeof value);
}
toBeLessThan(value) {
this.__validateNumericComparisonTypes(value);
this.__doMatcher(() => {
this.__expect(this.target < value);
});
}
toBeLessThanOrEqual(value) {
this.__validateNumericComparisonTypes(value);
this.__doMatcher(() => {
this.__expect(this.target <= value);
});
}
toBeGreaterThan(value) {
this.__validateNumericComparisonTypes(value);
this.__doMatcher(() => {
this.__expect(this.target > value);
});
}
toBeGreaterThanOrEqual(value) {
this.__validateNumericComparisonTypes(value);
this.__doMatcher(() => {
this.__expect(this.target >= value);
});
}
toContain(item) {
this.__doMatcher(() => {
for (let element of this.target) {
if (item === element) return;
}
throw new ExpectationError();
});
}
toContainEqual(item) {
this.__doMatcher(() => {
for (let element of this.target) {
if (deepEquals(item, element)) return;
}
throw new ExpectationError();
});
}
toEqual(value) {
this.__doMatcher(() => {
this.__expect(deepEquals(this.target, value));
});
}
toThrow(value) {
this.__expect(typeof this.target === "function");
this.__expect(
typeof value === "string" ||
typeof value === "function" ||
typeof value === "object" ||
value === undefined
);
this.__doMatcher(() => {
let threw = true;
try {
this.target();
threw = false;
} catch (e) {
if (typeof value === "string") {
this.__expect(e.message.includes(value));
} else if (typeof value === "function") {
this.__expect(e instanceof value);
} else if (typeof value === "object") {
this.__expect(e.message === value.message);
}
}
this.__expect(threw);
});
}
pass(message) {
// FIXME: This does nothing. If we want to implement things
// like assertion count, this will have to do something
}
// jest-extended
fail(message) {
this.__doMatcher(() => {
this.__expect(false, message);
});
}
// jest-extended
toThrowWithMessage(class_, message) {
this.__expect(typeof this.target === "function");
this.__expect(class_ !== undefined);
this.__expect(message !== undefined);
this.__doMatcher(() => {
try {
this.target();
this.__expect(false, () => "toThrowWithMessage: target function did not throw");
} catch (e) {
this.__expect(
e instanceof class_,
() =>
`toThrowWithMessage: expected error to be instance of ${valueToString(
class_.name
)}, got ${valueToString(e.name)}`
);
this.__expect(
e.message.includes(message),
() =>
`toThrowWithMessage: expected error message to include _${valueToString(
message
)}_, got _${valueToString(e.message)}_`
);
}
});
}
// Test for syntax errors; target must be a string
toEval() {
this.__expect(typeof this.target === "string");
const success = canParseSource(this.target);
this.__expect(
this.inverted ? !success : success,
() =>
`Expected _${valueToString(this.target)}_` +
(this.inverted ? "not to eval but it did" : "to eval but it didn't")
);
}
// Must compile regardless of inverted-ness
toEvalTo(value) {
this.__expect(typeof this.target === "string");
let result;
try {
result = eval(this.target);
} catch (e) {
throw new ExpectationError(
`Expected _${valueToString(this.target)}_ to eval but it failed with ${e}`
);
}
this.__doMatcher(() => {
this.__expect(
deepEquals(value, result),
() =>
`Expected _${valueToString(this.target)}_ to eval to ` +
`_${valueToString(value)}_ but got _${valueToString(result)}_`
);
});
}
toHaveConfigurableProperty(property) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.configurable);
});
}
toHaveEnumerableProperty(property) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.enumerable);
});
}
toHaveWritableProperty(property) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.writable);
});
}
toHaveValueProperty(property, value) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.value !== undefined);
if (value !== undefined) this.__expect(deepEquals(value, d.value));
});
}
toHaveGetterProperty(property) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.get !== undefined);
});
}
toHaveSetterProperty(property) {
this.__expect(this.target !== undefined && this.target !== null);
let d = Object.getOwnPropertyDescriptor(this.target, property);
this.__expect(d !== undefined);
this.__doMatcher(() => {
this.__expect(d.set !== undefined);
});
}
toBeIteratorResultWithValue(value) {
this.__expect(this.target !== undefined && this.target !== null);
this.__doMatcher(() => {
this.__expect(
this.target.done === false,
() =>
`toGiveIteratorResultWithValue: expected 'done' to be _false_ got ${valueToString(
this.target.done
)}`
);
this.__expect(
deepEquals(value, this.target.value),
() =>
`toGiveIteratorResultWithValue: expected 'value' to be _${valueToString(
value
)}_ got ${valueToString(this.target.value)}`
);
});
}
toBeIteratorResultDone() {
this.__expect(this.target !== undefined && this.target !== null);
this.__doMatcher(() => {
this.__expect(
this.target.done === true,
() =>
`toGiveIteratorResultDone: expected 'done' to be _true_ got ${valueToString(
this.target.done
)}`
);
this.__expect(
this.target.value === undefined,
() =>
`toGiveIteratorResultDone: expected 'value' to be _undefined_ got ${valueToString(
this.target.value
)}`
);
});
}
__doMatcher(matcher) {
if (!this.inverted) {
matcher();
} else {
let threw = false;
try {
matcher();
} catch (e) {
if (e.name === "ExpectationError") threw = true;
}
if (!threw) throw new ExpectationError("not: test didn't fail");
}
}
__expect(value, details) {
if (value !== true) {
if (details !== undefined) {
throw new ExpectationError(details());
} else {
throw new ExpectationError();
}
}
}
}
expect = value => new Expector(value);
// describe is able to lump test results inside of it by using this context
// variable. Top level tests have the default suite message
const defaultSuiteMessage = "__$$TOP_LEVEL$$__";
let suiteMessage = defaultSuiteMessage;
describe = (message, callback) => {
suiteMessage = message;
if (!__TestResults__[suiteMessage]) __TestResults__[suiteMessage] = {};
try {
callback();
} catch (e) {
__TestResults__[suiteMessage][defaultSuiteMessage] = {
result: "fail",
details: String(e),
};
}
suiteMessage = defaultSuiteMessage;
};
test = (message, callback) => {
if (!__TestResults__[suiteMessage]) __TestResults__[suiteMessage] = {};
const suite = __TestResults__[suiteMessage];
if (Object.prototype.hasOwnProperty.call(suite, message)) {
suite[message] = {
result: "fail",
details: "Another test with the same message did already run",
};
return;
}
try {
callback();
suite[message] = {
result: "pass",
};
} catch (e) {
suite[message] = {
result: "fail",
details: String(e),
};
}
};
test.skip = (message, callback) => {
if (typeof callback !== "function")
throw new Error("test.skip has invalid second argument (must be a function)");
if (!__TestResults__[suiteMessage]) __TestResults__[suiteMessage] = {};
const suite = __TestResults__[suiteMessage];
if (Object.prototype.hasOwnProperty.call(suite, message)) {
suite[message] = {
result: "fail",
details: "Another test with the same message did already run",
};
return;
}
suite[message] = {
result: "skip",
};
};
})();