mozilla-central/dom/indexedDB/test/helpers.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/**
* Any copyright is dedicated to the Public Domain.
*/
/* eslint-disable mozilla/no-comparison-or-assignment-inside-ok */
// testSteps is expected to be defined by the test using this file.
/* global testSteps:false */
var testGenerator;
if (testSteps.constructor.name === "GeneratorFunction") {
testGenerator = testSteps();
}
// The test js is shared between xpcshell (which has no SpecialPowers object)
// and content mochitests (where the |Components| object is accessible only as
// SpecialPowers.Components). Expose Components if necessary here to make things
// work everywhere.
//
// Even if the real |Components| doesn't exist, we might shim in a simple JS
// placebo for compat. An easy way to differentiate this from the real thing
// is whether the property is read-only or not.
var c = Object.getOwnPropertyDescriptor(this, "Components");
if ((!c || !c.value || c.writable) && typeof SpecialPowers === "object") {
// eslint-disable-next-line no-global-assign
Components = SpecialPowers.wrap(SpecialPowers.Components);
}
function executeSoon(aFun) {
SpecialPowers.Services.tm.dispatchToMainThread({
run() {
aFun();
},
});
}
function clearAllDatabases(callback) {
let qms = SpecialPowers.Services.qms;
let principal = SpecialPowers.wrap(document).effectiveStoragePrincipal;
let request = qms.clearStoragesForPrincipal(principal);
let cb = SpecialPowers.wrapCallback(callback);
request.callback = cb;
}
var testHarnessGenerator = testHarnessSteps();
testHarnessGenerator.next();
function* testHarnessSteps() {
function nextTestHarnessStep(val) {
testHarnessGenerator.next(val);
}
let testScriptPath;
let testScriptFilename;
let scripts = document.getElementsByTagName("script");
for (let i = 0; i < scripts.length; i++) {
let src = scripts[i].src;
let match = src.match(/indexedDB\/test\/unit\/(test_[^\/]+\.js)$/);
if (match && match.length == 2) {
testScriptPath = src;
testScriptFilename = match[1];
break;
}
}
yield undefined;
info("Running" + (testScriptFilename ? " '" + testScriptFilename + "'" : ""));
info("Pushing preferences");
SpecialPowers.pushPrefEnv(
{
set: [
["dom.indexedDB.testing", true],
["dom.indexedDB.experimental", true],
["javascript.options.wasm_baselinejit", true], // This can be removed when on by default
],
},
nextTestHarnessStep
);
yield undefined;
info("Pushing permissions");
SpecialPowers.pushPermissions(
[
{
type: "indexedDB",
allow: true,
context: document,
},
],
nextTestHarnessStep
);
yield undefined;
info("Clearing old databases");
clearAllDatabases(nextTestHarnessStep);
yield undefined;
if (testScriptFilename && !window.disableWorkerTest) {
// For the AsyncFunction, handle the executing sequece using
// add_task(). For the GeneratorFunction, we just handle the sequence
// manually.
if (testSteps.constructor.name === "AsyncFunction") {
add_task(function workerTestSteps() {
return executeWorkerTestAndCleanUp(testScriptPath);
});
} else {
ok(
testSteps.constructor.name === "GeneratorFunction",
"Unsupported function type"
);
executeWorkerTestAndCleanUp(testScriptPath).then(nextTestHarnessStep);
yield undefined;
}
} else if (testScriptFilename) {
todo(
false,
"Skipping test in a worker because it is explicitly disabled: " +
window.disableWorkerTest
);
} else {
todo(
false,
"Skipping test in a worker because it's not structured properly"
);
}
info("Running test in main thread");
// Now run the test script in the main thread.
if (testSteps.constructor.name === "AsyncFunction") {
// Register a callback to clean up databases because it's the only way for
// add_task() to clean them right before the SimpleTest.FinishTest
SimpleTest.registerCleanupFunction(async function () {
await new Promise(function (resolve, reject) {
clearAllDatabases(function (result) {
if (result.resultCode == SpecialPowers.Cr.NS_OK) {
resolve(result);
} else {
reject(result.resultCode);
}
});
});
});
add_task(testSteps);
} else {
testGenerator.next();
yield undefined;
}
}
if (!window.runTest) {
window.runTest = function () {
SimpleTest.waitForExplicitFinish();
testHarnessGenerator.next();
};
}
function finishTest() {
ok(
testSteps.constructor.name === "GeneratorFunction",
"Async/await tests shouldn't call finishTest()"
);
SimpleTest.executeSoon(function () {
clearAllDatabases(function () {
SimpleTest.finish();
});
});
}
function browserRunTest() {
testGenerator.next();
}
function browserFinishTest() {}
function grabEventAndContinueHandler(event) {
testGenerator.next(event);
}
function continueToNextStep() {
SimpleTest.executeSoon(function () {
testGenerator.next();
});
}
function continueToNextStepSync() {
testGenerator.next();
}
function errorHandler(event) {
ok(false, "indexedDB error, '" + event.target.error.name + "'");
finishTest();
}
// For error callbacks where the argument is not an event object.
function errorCallbackHandler(err) {
ok(false, "got unexpected error callback: " + err);
finishTest();
}
function expectUncaughtException(expecting) {
SimpleTest.expectUncaughtException(expecting);
}
function browserErrorHandler(event) {
browserFinishTest();
throw new Error("indexedDB error (" + event.code + "): " + event.message);
}
function unexpectedSuccessHandler() {
ok(false, "Got success, but did not expect it!");
finishTest();
}
function expectedErrorHandler(name) {
return function (event) {
is(event.type, "error", "Got an error event");
is(event.target.error.name, name, "Expected error was thrown.");
event.preventDefault();
grabEventAndContinueHandler(event);
};
}
function ExpectError(name, preventDefault) {
this._name = name;
this._preventDefault = preventDefault;
}
ExpectError.prototype = {
handleEvent(event) {
is(event.type, "error", "Got an error event");
is(event.target.error.name, this._name, "Expected error was thrown.");
if (this._preventDefault) {
event.preventDefault();
event.stopPropagation();
}
grabEventAndContinueHandler(event);
},
};
function compareKeys(_k1_, _k2_) {
let t = typeof _k1_;
if (t != typeof _k2_) {
return false;
}
if (t !== "object") {
return _k1_ === _k2_;
}
if (_k1_ instanceof Date) {
return _k2_ instanceof Date && _k1_.getTime() === _k2_.getTime();
}
if (_k1_ instanceof Array) {
if (!(_k2_ instanceof Array) || _k1_.length != _k2_.length) {
return false;
}
for (let i = 0; i < _k1_.length; ++i) {
if (!compareKeys(_k1_[i], _k2_[i])) {
return false;
}
}
return true;
}
if (_k1_ instanceof ArrayBuffer) {
if (!(_k2_ instanceof ArrayBuffer)) {
return false;
}
function arrayBuffersAreEqual(a, b) {
if (a.byteLength != b.byteLength) {
return false;
}
let ui8b = new Uint8Array(b);
return new Uint8Array(a).every((val, i) => val === ui8b[i]);
}
return arrayBuffersAreEqual(_k1_, _k2_);
}
return false;
}
function removePermission(type, url) {
if (!url) {
url = window.document;
}
SpecialPowers.removePermission(type, url);
}
function gc() {
SpecialPowers.forceGC();
SpecialPowers.forceCC();
}
function scheduleGC() {
SpecialPowers.exactGC(continueToNextStep);
}
// Assert that eventually a condition becomes true, running a garbage
// collection between evaluations. Fails, after a high number of iterations
// without a successful evaluation of the condition.
function* assertEventuallyWithGC(conditionFunctor, message) {
const maxGC = 100;
for (let i = 0; i < maxGC; ++i) {
let result =
conditionFunctor.constructor.name === "GeneratorFunction"
? yield* conditionFunctor()
: conditionFunctor();
if (result) {
ok(true, message + " (after " + i + " garbage collections)");
return;
}
SpecialPowers.exactGC(continueToNextStep);
yield undefined;
}
ok(false, message + " (even after " + maxGC + " garbage collections)");
}
// Asserts that a functor `f` throws an exception that is an instance of
// `ctor`. If it doesn't throw, or throws a different type of exception, this
// throws an Error, including the optional `msg` given.
// Otherwise, it returns the message of the exception.
//
// This should be moved to a more generic place, as it is in no way specific
// to IndexedDB.
function assertThrowsInstanceOf(f, ctor, msg) {
var fullmsg;
try {
f();
} catch (exc) {
if (exc instanceof ctor) {
return exc.message;
}
fullmsg = `Assertion failed: expected exception ${ctor.name}, got ${exc}`;
}
if (fullmsg === undefined) {
fullmsg = `Assertion failed: expected exception ${ctor.name}, no exception thrown`;
}
if (msg !== undefined) {
fullmsg += " - " + msg;
}
throw new Error(fullmsg);
}
function isWasmSupported() {
let testingFunctions = SpecialPowers.Cu.getJSTestingFunctions();
return testingFunctions.wasmIsSupported();
}
function getWasmModule(_binary_) {
let module = new WebAssembly.Module(_binary_);
return module;
}
function expectingSuccess(request) {
return new Promise(function (resolve, reject) {
request.onerror = function (event) {
ok(false, "indexedDB error, '" + event.target.error.name + "'");
reject(event);
};
request.onsuccess = function (event) {
resolve(event);
};
request.onupgradeneeded = function (event) {
ok(false, "Got upgrade, but did not expect it!");
reject(event);
};
});
}
function expectingUpgrade(request) {
return new Promise(function (resolve, reject) {
request.onerror = function (event) {
ok(false, "indexedDB error, '" + event.target.error.name + "'");
reject(event);
};
request.onupgradeneeded = function (event) {
resolve(event);
};
request.onsuccess = function (event) {
ok(false, "Got success, but did not expect it!");
reject(event);
};
});
}
function expectingError(request, errorName) {
return new Promise(function (resolve, reject) {
request.onerror = function (event) {
is(errorName, event.target.error.name, "Correct exception type");
event.stopPropagation();
resolve(event);
};
request.onsuccess = function (event) {
ok(false, "Got success, but did not expect it!");
reject(event);
};
request.onupgradeneeded = function (event) {
ok(false, "Got upgrade, but did not expect it!");
reject(event);
};
});
}
function workerScript() {
"use strict";
self.wasmSupported = false;
self.repr = function (_thing_) {
if (typeof _thing_ == "undefined") {
return "undefined";
}
let str;
try {
str = _thing_ + "";
} catch (e) {
return "[" + typeof _thing_ + "]";
}
if (typeof _thing_ == "function") {
str = str.replace(/^\s+/, "");
let idx = str.indexOf("{");
if (idx != -1) {
str = str.substr(0, idx) + "{...}";
}
}
return str;
};
self.ok = function (_condition_, _name_, _diag_) {
self.postMessage({
op: "ok",
condition: !!_condition_,
name: _name_,
diag: _diag_,
});
};
self.is = function (_a_, _b_, _name_) {
let pass = _a_ == _b_;
let diag = pass ? "" : "got " + repr(_a_) + ", expected " + repr(_b_);
ok(pass, _name_, diag);
};
self.isnot = function (_a_, _b_, _name_) {
let pass = _a_ != _b_;
let diag = pass ? "" : "didn't expect " + repr(_a_) + ", but got it";
ok(pass, _name_, diag);
};
self.todo = function (_condition_, _name_, _diag_) {
self.postMessage({
op: "todo",
condition: !!_condition_,
name: _name_,
diag: _diag_,
});
};
self.info = function (_msg_) {
self.postMessage({ op: "info", msg: _msg_ });
};
self.executeSoon = function (_fun_) {
var channel = new MessageChannel();
channel.port1.postMessage("");
channel.port2.onmessage = function () {
_fun_();
};
};
self.finishTest = function () {
self.ok(
testSteps.constructor.name === "GeneratorFunction",
"Async/await tests shouldn't call finishTest()"
);
if (self._expectingUncaughtException) {
self.ok(
false,
"expectUncaughtException was called but no uncaught " +
"exception was detected!"
);
}
self.postMessage({ op: "done" });
};
self.grabEventAndContinueHandler = function (_event_) {
testGenerator.next(_event_);
};
self.continueToNextStep = function () {
executeSoon(function () {
testGenerator.next();
});
};
self.continueToNextStepSync = function () {
testGenerator.next();
};
self.errorHandler = function (_event_) {
ok(false, "indexedDB error, '" + _event_.target.error.name + "'");
finishTest();
};
self.unexpectedSuccessHandler = function () {
ok(false, "Got success, but did not expect it!");
finishTest();
};
self.expectedErrorHandler = function (_name_) {
return function (_event_) {
is(_event_.type, "error", "Got an error event");
is(_event_.target.error.name, _name_, "Expected error was thrown.");
_event_.preventDefault();
grabEventAndContinueHandler(_event_);
};
};
self.ExpectError = function (_name_, _preventDefault_) {
this._name = _name_;
this._preventDefault = _preventDefault_;
};
self.ExpectError.prototype = {
handleEvent(_event_) {
is(_event_.type, "error", "Got an error event");
is(_event_.target.error.name, this._name, "Expected error was thrown.");
if (this._preventDefault) {
_event_.preventDefault();
_event_.stopPropagation();
}
grabEventAndContinueHandler(_event_);
},
};
// TODO this is duplicate from the global compareKeys function defined above,
// this duplication should be avoided (bug 1565986)
self.compareKeys = function (_k1_, _k2_) {
let t = typeof _k1_;
if (t != typeof _k2_) {
return false;
}
if (t !== "object") {
return _k1_ === _k2_;
}
if (_k1_ instanceof Date) {
return _k2_ instanceof Date && _k1_.getTime() === _k2_.getTime();
}
if (_k1_ instanceof Array) {
if (!(_k2_ instanceof Array) || _k1_.length != _k2_.length) {
return false;
}
for (let i = 0; i < _k1_.length; ++i) {
if (!compareKeys(_k1_[i], _k2_[i])) {
return false;
}
}
return true;
}
if (_k1_ instanceof ArrayBuffer) {
if (!(_k2_ instanceof ArrayBuffer)) {
return false;
}
function arrayBuffersAreEqual(a, b) {
if (a.byteLength != b.byteLength) {
return false;
}
let ui8b = new Uint8Array(b);
return new Uint8Array(a).every((val, i) => val === ui8b[i]);
}
return arrayBuffersAreEqual(_k1_, _k2_);
}
return false;
};
self.getRandomBuffer = function (_size_) {
let buffer = new ArrayBuffer(_size_);
is(buffer.byteLength, _size_, "Correct byte length");
let view = new Uint8Array(buffer);
for (let i = 0; i < _size_; i++) {
view[i] = parseInt(Math.random() * 255);
}
return buffer;
};
self._expectingUncaughtException = false;
self.expectUncaughtException = function (_expecting_) {
self._expectingUncaughtException = !!_expecting_;
self.postMessage({
op: "expectUncaughtException",
expecting: !!_expecting_,
});
};
self._clearAllDatabasesCallback = undefined;
self.clearAllDatabases = function (_callback_) {
self._clearAllDatabasesCallback = _callback_;
self.postMessage({ op: "clearAllDatabases" });
};
self.onerror = function (_message_, _file_, _line_) {
if (self._expectingUncaughtException) {
self._expectingUncaughtException = false;
ok(
true,
"Worker: expected exception [" +
_file_ +
":" +
_line_ +
"]: '" +
_message_ +
"'"
);
return false;
}
ok(
false,
"Worker: uncaught exception [" +
_file_ +
":" +
_line_ +
"]: '" +
_message_ +
"'"
);
self.finishTest();
self.close();
return true;
};
self.isWasmSupported = function () {
return self.wasmSupported;
};
self.getWasmModule = function (_binary_) {
let module = new WebAssembly.Module(_binary_);
return module;
};
self.verifyWasmModule = function (_module) {
self.todo(false, "Need a verifyWasmModule implementation on workers");
self.continueToNextStep();
};
self.onmessage = function (_event_) {
let message = _event_.data;
switch (message.op) {
case "load":
info("Worker: loading " + JSON.stringify(message.files));
self.importScripts(message.files);
self.postMessage({ op: "loaded" });
break;
case "start":
self.wasmSupported = message.wasmSupported;
executeSoon(async function () {
info("Worker: starting tests");
if (testSteps.constructor.name === "AsyncFunction") {
await testSteps();
if (self._expectingUncaughtException) {
self.ok(
false,
"expectUncaughtException was called but no " +
"uncaught exception was detected!"
);
}
self.postMessage({ op: "done" });
} else {
ok(
testSteps.constructor.name === "GeneratorFunction",
"Unsupported function type"
);
testGenerator.next();
}
});
break;
case "clearAllDatabasesDone":
info("Worker: all databases are cleared");
if (self._clearAllDatabasesCallback) {
self._clearAllDatabasesCallback();
}
break;
default:
throw new Error(
"Received a bad message from parent: " + JSON.stringify(message)
);
}
};
self.expectingSuccess = function (_request_) {
return new Promise(function (_resolve_, _reject_) {
_request_.onerror = function (_event_) {
ok(false, "indexedDB error, '" + _event_.target.error.name + "'");
_reject_(_event_);
};
_request_.onsuccess = function (_event_) {
_resolve_(_event_);
};
_request_.onupgradeneeded = function (_event_) {
ok(false, "Got upgrade, but did not expect it!");
_reject_(_event_);
};
});
};
self.expectingUpgrade = function (_request_) {
return new Promise(function (_resolve_, _reject_) {
_request_.onerror = function (_event_) {
ok(false, "indexedDB error, '" + _event_.target.error.name + "'");
_reject_(_event_);
};
_request_.onupgradeneeded = function (_event_) {
_resolve_(_event_);
};
_request_.onsuccess = function (_event_) {
ok(false, "Got success, but did not expect it!");
_reject_(_event_);
};
});
};
self.postMessage({ op: "ready" });
}
async function executeWorkerTestAndCleanUp(testScriptPath) {
info("Running test in a worker");
let workerScriptBlob = new Blob(["(" + workerScript.toString() + ")();"], {
type: "text/javascript",
});
let workerScriptURL = URL.createObjectURL(workerScriptBlob);
let worker;
try {
await new Promise(function (resolve, reject) {
worker = new Worker(workerScriptURL);
worker._expectingUncaughtException = false;
worker.onerror = function (event) {
if (worker._expectingUncaughtException) {
ok(true, "Worker had an expected error: " + event.message);
worker._expectingUncaughtException = false;
event.preventDefault();
return;
}
ok(false, "Worker had an error: " + event.message);
worker.terminate();
reject();
};
worker.onmessage = function (event) {
let message = event.data;
switch (message.op) {
case "ok":
SimpleTest.ok(
message.condition,
`${message.name}: ${message.diag}`
);
break;
case "todo":
todo(message.condition, message.name, message.diag);
break;
case "info":
info(message.msg);
break;
case "ready":
worker.postMessage({ op: "load", files: [testScriptPath] });
break;
case "loaded":
worker.postMessage({
op: "start",
wasmSupported: isWasmSupported(),
});
break;
case "done":
ok(true, "Worker finished");
resolve();
break;
case "expectUncaughtException":
worker._expectingUncaughtException = message.expecting;
break;
case "clearAllDatabases":
clearAllDatabases(function () {
worker.postMessage({ op: "clearAllDatabasesDone" });
});
break;
default:
ok(
false,
"Received a bad message from worker: " + JSON.stringify(message)
);
reject();
}
};
});
URL.revokeObjectURL(workerScriptURL);
} catch (e) {
info("Unexpected thing happened: " + e);
}
return new Promise(function (resolve) {
info("Cleaning up the databases");
if (worker._expectingUncaughtException) {
ok(
false,
"expectUncaughtException was called but no uncaught " +
"exception was detected!"
);
}
worker.terminate();
worker = null;
clearAllDatabases(resolve);
});
}