The Tor Browser: comparison toolkit/devtools/server/tests/unit/head_dbg.js

comparison: toolkit/devtools/server/tests/unit/head_dbg.js

toolkit/devtools/server/tests/unit/head_dbg.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:48d98eba5778
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+const Cr = Components.results;
+const { devtools } = Cu.import("resource://gre/modules/devtools/Loader.jsm", {});
+const Services = devtools.require("Services");
+const { ActorPool, createExtraActors, appendExtraActors } = devtools.require("devtools/server/actors/common");
+const DevToolsUtils = devtools.require("devtools/toolkit/DevToolsUtils.js");
+const {Promise: promise} = Cu.import("resource://gre/modules/Promise.jsm", {});
+// Always log packets when running tests. runxpcshelltests.py will throw
+// the output away anyway, unless you give it the --verbose flag.
+Services.prefs.setBoolPref("devtools.debugger.log", true);
+// Enable remote debugging for the relevant tests.
+Services.prefs.setBoolPref("devtools.debugger.remote-enabled", true);
+function tryImport(url) {
+try {
+Cu.import(url);
+} catch (e) {
+dump("Error importing " + url + "\n");
+dump(DevToolsUtils.safeErrorString(e) + "\n");
+throw e;
+}
+}
+tryImport("resource://gre/modules/devtools/dbg-server.jsm");
+tryImport("resource://gre/modules/devtools/dbg-client.jsm");
+tryImport("resource://gre/modules/devtools/Loader.jsm");
+tryImport("resource://gre/modules/devtools/Console.jsm");
+function testExceptionHook(ex) {
+try {
+do_report_unexpected_exception(ex);
+} catch(ex) {
+return {throw: ex}
+}
+return undefined;
+}
+// Convert an nsIScriptError 'aFlags' value into an appropriate string.
+function scriptErrorFlagsToKind(aFlags) {
+var kind;
+if (aFlags & Ci.nsIScriptError.warningFlag)
+kind = "warning";
+if (aFlags & Ci.nsIScriptError.exceptionFlag)
+kind = "exception";
+else
+kind = "error";
+if (aFlags & Ci.nsIScriptError.strictFlag)
+kind = "strict " + kind;
+return kind;
+}
+// Redeclare dbg_assert with a fatal behavior.
+function dbg_assert(cond, e) {
+if (!cond) {
+throw e;
+}
+}
+// Register a console listener, so console messages don't just disappear
+// into the ether.
+let errorCount = 0;
+let listener = {
+observe: function (aMessage) {
+errorCount++;
+try {
+// If we've been given an nsIScriptError, then we can print out
+// something nicely formatted, for tools like Emacs to pick up.
+var scriptError = aMessage.QueryInterface(Ci.nsIScriptError);
+dump(aMessage.sourceName + ":" + aMessage.lineNumber + ": " +
+scriptErrorFlagsToKind(aMessage.flags) + ": " +
+aMessage.errorMessage + "\n");
+var string = aMessage.errorMessage;
+} catch (x) {
+// Be a little paranoid with message, as the whole goal here is to lose
+// no information.
+try {
+var string = "" + aMessage.message;
+} catch (x) {
+var string = "<error converting error message to string>";
+}
+}
+// Make sure we exit all nested event loops so that the test can finish.
+while (DebuggerServer.xpcInspector.eventLoopNestLevel > 0) {
+DebuggerServer.xpcInspector.exitNestedEventLoop();
+}
+do_throw("head_dbg.js got console message: " + string + "\n");
+}
+};
+let consoleService = Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService);
+consoleService.registerListener(listener);
+function check_except(func)
+{
+try {
+func();
+} catch (e) {
+do_check_true(true);
+return;
+}
+dump("Should have thrown an exception: " + func.toString());
+do_check_true(false);
+}
+function testGlobal(aName) {
+let systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+.createInstance(Ci.nsIPrincipal);
+let sandbox = Cu.Sandbox(systemPrincipal);
+sandbox.__name = aName;
+return sandbox;
+}
+function addTestGlobal(aName)
+{
+let global = testGlobal(aName);
+DebuggerServer.addTestGlobal(global);
+return global;
+}
+// List the DebuggerClient |aClient|'s tabs, look for one whose title is
+// |aTitle|, and apply |aCallback| to the packet's entry for that tab.
+function getTestTab(aClient, aTitle, aCallback) {
+aClient.listTabs(function (aResponse) {
+for (let tab of aResponse.tabs) {
+if (tab.title === aTitle) {
+aCallback(tab);
+return;
+}
+}
+aCallback(null);
+});
+}
+// Attach to |aClient|'s tab whose title is |aTitle|; pass |aCallback| the
+// response packet and a TabClient instance referring to that tab.
+function attachTestTab(aClient, aTitle, aCallback) {
+getTestTab(aClient, aTitle, function (aTab) {
+aClient.attachTab(aTab.actor, aCallback);
+});
+}
+// Attach to |aClient|'s tab whose title is |aTitle|, and then attach to
+// that tab's thread. Pass |aCallback| the thread attach response packet, a
+// TabClient referring to the tab, and a ThreadClient referring to the
+// thread.
+function attachTestThread(aClient, aTitle, aCallback) {
+attachTestTab(aClient, aTitle, function (aResponse, aTabClient) {
+function onAttach(aResponse, aThreadClient) {
+aCallback(aResponse, aTabClient, aThreadClient);
+}
+aTabClient.attachThread({ useSourceMaps: true }, onAttach);
+});
+}
+// Attach to |aClient|'s tab whose title is |aTitle|, attach to the tab's
+// thread, and then resume it. Pass |aCallback| the thread's response to
+// the 'resume' packet, a TabClient for the tab, and a ThreadClient for the
+// thread.
+function attachTestTabAndResume(aClient, aTitle, aCallback) {
+attachTestThread(aClient, aTitle, function(aResponse, aTabClient, aThreadClient) {
+aThreadClient.resume(function (aResponse) {
+aCallback(aResponse, aTabClient, aThreadClient);
+});
+});
+}
+/**
+* Initialize the testing debugger server.
+*/
+function initTestDebuggerServer()
+{
+DebuggerServer.addActors("resource://gre/modules/devtools/server/actors/root.js");
+DebuggerServer.addActors("resource://gre/modules/devtools/server/actors/script.js");
+DebuggerServer.addActors("resource://test/testactors.js");
+// Allow incoming connections.
+DebuggerServer.init(function () { return true; });
+}
+function initTestTracerServer()
+{
+DebuggerServer.addActors("resource://gre/modules/devtools/server/actors/root.js");
+DebuggerServer.addActors("resource://gre/modules/devtools/server/actors/script.js");
+DebuggerServer.addActors("resource://test/testactors.js");
+DebuggerServer.registerModule("devtools/server/actors/tracer");
+// Allow incoming connections.
+DebuggerServer.init(function () { return true; });
+}
+function finishClient(aClient)
+{
+aClient.close(function() {
+do_test_finished();
+});
+}
+/**
+* Takes a relative file path and returns the absolute file url for it.
+*/
+function getFileUrl(aName, aAllowMissing=false) {
+let file = do_get_file(aName, aAllowMissing);
+return Services.io.newFileURI(file).spec;
+}
+/**
+* Returns the full path of the file with the specified name in a
+* platform-independent and URL-like form.
+*/
+function getFilePath(aName, aAllowMissing=false)
+{
+let file = do_get_file(aName, aAllowMissing);
+let path = Services.io.newFileURI(file).spec;
+let filePrePath = "file://";
+if ("nsILocalFileWin" in Ci &&
+file instanceof Ci.nsILocalFileWin) {
+filePrePath += "/";
+}
+return path.slice(filePrePath.length);
+}
+Cu.import("resource://gre/modules/NetUtil.jsm");
+/**
+* Returns the full text contents of the given file.
+*/
+function readFile(aFileName) {
+let f = do_get_file(aFileName);
+let s = Cc["@mozilla.org/network/file-input-stream;1"]
+.createInstance(Ci.nsIFileInputStream);
+s.init(f, -1, -1, false);
+try {
+return NetUtil.readInputStreamToString(s, s.available());
+} finally {
+s.close();
+}
+}
+function writeFile(aFileName, aContent) {
+let file = do_get_file(aFileName, true);
+let stream = Cc["@mozilla.org/network/file-output-stream;1"]
+.createInstance(Ci.nsIFileOutputStream);
+stream.init(file, -1, -1, 0);
+try {
+do {
+let numWritten = stream.write(aContent, aContent.length);
+aContent = aContent.slice(numWritten);
+} while (aContent.length > 0);
+} finally {
+stream.close();
+}
+}
+function connectPipeTracing() {
+return new TracingTransport(DebuggerServer.connectPipe());
+}
+function TracingTransport(childTransport) {
+this.hooks = null;
+this.child = childTransport;
+this.child.hooks = this;
+this.expectations = [];
+this.packets = [];
+this.checkIndex = 0;
+}
+function deepEqual(a, b) {
+if (a === b)
+return true;
+if (typeof a != "object" || typeof b != "object")
+return false;
+if (a === null || b === null)
+return false;
+if (Object.keys(a).length != Object.keys(b).length)
+return false;
+for (let k in a) {
+if (!deepEqual(a[k], b[k]))
+return false;
+}
+return true;
+}
+TracingTransport.prototype = {
+// Remove actor names
+normalize: function(packet) {
+return JSON.parse(JSON.stringify(packet, (key, value) => {
+if (key === "to" || key === "from" || key === "actor") {
+return "<actorid>";
+}
+return value;
+}));
+},
+send: function(packet) {
+this.packets.push({
+type: "sent",
+packet: this.normalize(packet)
+});
+return this.child.send(packet);
+},
+close: function() {
+return this.child.close();
+},
+ready: function() {
+return this.child.ready();
+},
+onPacket: function(packet) {
+this.packets.push({
+type: "received",
+packet: this.normalize(packet)
+});
+this.hooks.onPacket(packet);
+},
+onClosed: function() {
+this.hooks.onClosed();
+},
+expectSend: function(expected) {
+let packet = this.packets[this.checkIndex++];
+do_check_eq(packet.type, "sent");
+do_check_true(deepEqual(packet.packet, this.normalize(expected)));
+},
+expectReceive: function(expected) {
+let packet = this.packets[this.checkIndex++];
+do_check_eq(packet.type, "received");
+do_check_true(deepEqual(packet.packet, this.normalize(expected)));
+},
+// Write your tests, call dumpLog at the end, inspect the output,
+// then sprinkle the calls through the right places in your test.
+dumpLog: function() {
+for (let entry of this.packets) {
+if (entry.type === "sent") {
+dump("trace.expectSend(" + entry.packet + ");\n");
+} else {
+dump("trace.expectReceive(" + entry.packet + ");\n");
+}
+}
+}
+};
+function StubTransport() { }
+StubTransport.prototype.ready = function () {};
+StubTransport.prototype.send  = function () {};
+StubTransport.prototype.close = function () {};
+function executeSoon(aFunc) {
+Services.tm.mainThread.dispatch({
+run: DevToolsUtils.makeInfallible(aFunc)
+}, Ci.nsIThread.DISPATCH_NORMAL);
+}