<!doctype html>
<script src="/resources/channel.sub.js"></script>
<script src="serialize-data.js"></script>
<script>
let lastData;
// Hack: these will be converted into testharness AssertionError instances in the test
// This means they will be treated identically to asserts raised by `assert_` in the harness
// In the long term we want to be able to use parts of testharness.js directly in remote
// contexts and automatically send the results over a channel.
function AssertionError(message) {
this.message = message;
}
AssertionError.prototype = Object.create(Error.prototype);
function compareResult(name, actual) {
let obj = objects[name];
// If there's an output property use that, otherwise assume the output is equal to the input
let expected = obj.hasOwnProperty("output") ? obj.output : obj.input;
seen = new Set();
try {
compareValue(actual, expected, seen);
} catch(e) {
throw new AssertionError(e.message);
}
return true;
}
function compareValue(actualValue, expectedValue, seen) {
let seenActual;
if (typeof actualValue != typeof expectedValue) {
throw new Error(`Types differ, expected ${typeof expectedValue}, got ${typeof actualValue}`);
}
if (["undefined", "string", "boolean", "number", "bigint"].includes(typeof expectedValue) ||
actualValue === null) {
if (!Object.is(actualValue, expectedValue)) {
throw new Error(`Expected ${typeof expected} ${expected}, got ${actual}`);
}
return;
}
if (expectedValue.constructor && actualValue.constructor && expectedValue.constructor.name !== actualValue.constructor.name) {
throw new Error(`Constructors differ, expected ${expectedValue.constructor.name}, got ${actualValue.constructor.name}`);
}
if (expectedValue.constructor && expectedValue.constructor.name === "SendChannel") {
if (expectedValue.uuid !== actualValue.uuid) {
throw new Error(`SendChannels differ, expected uuid ${expectedValue.uuid}, got ${actualValue.uuid}`);
}
}
else if (expectedValue.constructor && expectedValue.constructor.name === "RegExp") {
if (expectedValue.source !== actualValue.source ||
expectedValue.flags !== actualValue.flags) {
throw new Error(`RegExps differ, expected ${expectedValue}, got ${actualValue}`);
}
} else if (expectedValue.constructor && expectedValue.constructor.name == "Date") {
if (expectedValue.valueOf() !== actualValue.valueOf()) {
throw new Error(`Dates differ, expected ${expectedValue.valueOf()} (${expectedValue.toDateString()}), `
`got ${actualValue.valueOf()} (${actualValue.toDateString()})`);
}
} else if (expectedValue instanceof Error) {
if (expectedValue.message !== actualValue.message ||
expectedValue.lineNumber !== actualValue.lineNumber ||
expectedValue.columnNumber !== actualValue.columnNumber ||
expectedValue.fileName !== actualValue.fileName) {
throw new Error(`Errors differ, expected ${expectedValue}, got ${actualValue}`);
}
} else if (Array.isArray(expectedValue)) {
seenActual = seen.has(actualValue);
seenExpected = seen.has(expectedValue)
if (seenActual && seenExpected) {
return;
} else if (seenExpected && !seenActual) {
throw new Error(`Expected cyclic array`);
} else if (!seenExpected && seenActual) {
throw new Error(`Got unexpected cyclic array`);
}
seen.add(actualValue);
seen.add(expectedValue);
if (actualValue.length !== expectedValue.length) {
throw new Error(`Array lengths differ, expected ${expectedValue.length}, got ${actualValue.length}`);
}
for (let i=0; i<actualValue.length; i++) {
compareValue(actualValue[i], expectedValue[i], seen);
}
} else if (expectedValue.constructor && expectedValue.constructor.name === "Set") {
seenActual = seen.has(actualValue);
seenExpected = seen.has(expectedValue)
if (seenActual && seenExpected) {
return;
} else if (seenExpected && !seenActual) {
throw new Error(`Expected cyclic set`);
} else if (!seenExpected && seenActual) {
throw new Error(`Got unexpected cyclic set`);
}
seen.add(actualValue);
seen.add(expectedValue);
if (actualValue.size !== expectedValue.size) {
throw new Error(`Set sizes differ, expected ${expectedValue.size}, got ${actualValue.size}`);
}
// For an arbitary set it's complex to check if two sets are equivalent, since
// we'd need to compare every object in one set with every object in the
// other set, so we end up with quadratic complexity. Instead, just support sets
// containing primitives and rely on the other tests for correct handling of
// objects.
for (let entry of expectedValue) {
if (["undefined", "string", "boolean", "number", "bigint"].includes(typeof entry) || entry === null) {
if(!actualValue.has(entry)) {
throw new Error(`Set missing entry, expected ${entry}`);
}
} else {
throw new Error(`Can't compare non-primitive value ${entry} inside sets`);
}
}
} else if (expectedValue.constructor && expectedValue.constructor.name === "Map") {
seenActual = seen.has(actualValue);
seenExpected = seen.has(expectedValue)
if (seenActual && seenExpected) {
return;
} else if (seenExpected && !seenActual) {
throw new Error(`Expected cyclic map`);
} else if (!seenExpected && seenActual) {
throw new Error(`Got unexpected cyclic map`);
}
seen.add(actualValue);
seen.add(expectedValue);
if (actualValue.size !== expectedValue.size) {
throw new Error(`Map sizes differ, expected ${expectedValue.size}, got ${actualValue.size}`);
}
// So for a set we can't really check if the values are the same
// except where they're primitives
for (let [key, value] of expectedValue.entries()) {
if(!actualValue.has(key)) {
throw new Error(`Map missing key, expected key ${key} with value ${value}`);
}
compareValue(actualValue.get(key), value, seen);
}
} else {
seenActual = seen.has(actualValue);
seenExpected = seen.has(expectedValue)
if (seenActual && seenExpected) {
return;
} else if (seenExpected && !seenActual) {
throw new Error(`Expected cyclic object`);
} else if (!seenExpected && seenActual) {
throw new Error(`Got unexpected cyclic object`);
}
seen.add(actualValue);
seen.add(expectedValue);
// Compare as a general Object
let expectedEntries = Object.entries(expectedValue);
if (Object.keys(actualValue).length !== expectedEntries.length) {
throw new Error(`Object keys differ, expected [${Object.keys(expectedValue).join(",")}], got [${Object.keys(actualValue).join(",")}]`);
}
// So for a set we can't really check if the values are the same
// except where they're primitives
for (let [name, entry] of expectedEntries) {
if(!actualValue.hasOwnProperty(name)) {
throw new Error(`Object missing key ${name}`);
}
compareValue(actualValue[name], entry, seen);
}
}
}
ctx = start_global_channel();
</script>
Codebase Browser
chromium