summaryrefslogtreecommitdiffstats
path: root/devtools/shared/tests
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /devtools/shared/tests
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'devtools/shared/tests')
-rw-r--r--devtools/shared/tests/browser/.eslintrc.js6
-rw-r--r--devtools/shared/tests/browser/browser.ini8
-rw-r--r--devtools/shared/tests/browser/browser_async_storage.js77
-rw-r--r--devtools/shared/tests/browser/browser_l10n_localizeMarkup.js54
-rw-r--r--devtools/shared/tests/mochitest/chrome.ini7
-rw-r--r--devtools/shared/tests/mochitest/test_devtools_extensions.html117
-rw-r--r--devtools/shared/tests/mochitest/test_eventemitter_basic.html194
-rw-r--r--devtools/shared/tests/unit/.eslintrc.js6
-rw-r--r--devtools/shared/tests/unit/exposeLoader.js8
-rw-r--r--devtools/shared/tests/unit/head_devtools.js60
-rw-r--r--devtools/shared/tests/unit/test_assert.js36
-rw-r--r--devtools/shared/tests/unit/test_async-utils.js157
-rw-r--r--devtools/shared/tests/unit/test_console_filtering.js133
-rw-r--r--devtools/shared/tests/unit/test_css-properties-db.js136
-rw-r--r--devtools/shared/tests/unit/test_csslexer.js242
-rw-r--r--devtools/shared/tests/unit/test_defer.js32
-rw-r--r--devtools/shared/tests/unit/test_defineLazyPrototypeGetter.js68
-rw-r--r--devtools/shared/tests/unit/test_executeSoon.js48
-rw-r--r--devtools/shared/tests/unit/test_fetch-bom.js76
-rw-r--r--devtools/shared/tests/unit/test_fetch-chrome.js31
-rw-r--r--devtools/shared/tests/unit/test_fetch-file.js104
-rw-r--r--devtools/shared/tests/unit/test_fetch-http.js61
-rw-r--r--devtools/shared/tests/unit/test_fetch-resource.js31
-rw-r--r--devtools/shared/tests/unit/test_flatten.js24
-rw-r--r--devtools/shared/tests/unit/test_indentation.js133
-rw-r--r--devtools/shared/tests/unit/test_independent_loaders.js20
-rw-r--r--devtools/shared/tests/unit/test_invisible_loader.js60
-rw-r--r--devtools/shared/tests/unit/test_isSet.js25
-rw-r--r--devtools/shared/tests/unit/test_pluralForm-english.js29
-rw-r--r--devtools/shared/tests/unit/test_pluralForm-makeGetter.js38
-rw-r--r--devtools/shared/tests/unit/test_prettifyCSS.js68
-rw-r--r--devtools/shared/tests/unit/test_require.js20
-rw-r--r--devtools/shared/tests/unit/test_require_lazy.js32
-rw-r--r--devtools/shared/tests/unit/test_require_raw.js19
-rw-r--r--devtools/shared/tests/unit/test_safeErrorString.js58
-rw-r--r--devtools/shared/tests/unit/test_stack.js45
-rw-r--r--devtools/shared/tests/unit/xpcshell.ini40
37 files changed, 2303 insertions, 0 deletions
diff --git a/devtools/shared/tests/browser/.eslintrc.js b/devtools/shared/tests/browser/.eslintrc.js
new file mode 100644
index 000000000..8d15a76d9
--- /dev/null
+++ b/devtools/shared/tests/browser/.eslintrc.js
@@ -0,0 +1,6 @@
+"use strict";
+
+module.exports = {
+ // Extend from the shared list of defined globals for mochitests.
+ "extends": "../../../.eslintrc.mochitests.js"
+};
diff --git a/devtools/shared/tests/browser/browser.ini b/devtools/shared/tests/browser/browser.ini
new file mode 100644
index 000000000..4acac6521
--- /dev/null
+++ b/devtools/shared/tests/browser/browser.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+tags = devtools
+subsuite = devtools
+support-files =
+ ../../../server/tests/browser/head.js
+
+[browser_async_storage.js]
+[browser_l10n_localizeMarkup.js]
diff --git a/devtools/shared/tests/browser/browser_async_storage.js b/devtools/shared/tests/browser/browser_async_storage.js
new file mode 100644
index 000000000..4329d639a
--- /dev/null
+++ b/devtools/shared/tests/browser/browser_async_storage.js
@@ -0,0 +1,77 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Test the basic functionality of async-storage.
+// Adapted from https://github.com/mozilla-b2g/gaia/blob/f09993563fb5fec4393eb71816ce76cb00463190/apps/sharedtest/test/unit/async_storage_test.js.
+
+const asyncStorage = require("devtools/shared/async-storage");
+add_task(function* () {
+ is(typeof asyncStorage.length, "function", "API exists.");
+ is(typeof asyncStorage.key, "function", "API exists.");
+ is(typeof asyncStorage.getItem, "function", "API exists.");
+ is(typeof asyncStorage.setItem, "function", "API exists.");
+ is(typeof asyncStorage.removeItem, "function", "API exists.");
+ is(typeof asyncStorage.clear, "function", "API exists.");
+});
+
+add_task(function* () {
+ yield asyncStorage.setItem("foo", "bar");
+ let value = yield asyncStorage.getItem("foo");
+ is(value, "bar", "value is correct");
+ yield asyncStorage.setItem("foo", "overwritten");
+ value = yield asyncStorage.getItem("foo");
+ is(value, "overwritten", "value is correct");
+ yield asyncStorage.removeItem("foo");
+ value = yield asyncStorage.getItem("foo");
+ is(value, null, "value is correct");
+});
+
+add_task(function* () {
+ var object = {
+ x: 1,
+ y: "foo",
+ z: true
+ };
+
+ yield asyncStorage.setItem("myobj", object);
+ let value = yield asyncStorage.getItem("myobj");
+ is(object.x, value.x, "value is correct");
+ is(object.y, value.y, "value is correct");
+ is(object.z, value.z, "value is correct");
+ yield asyncStorage.removeItem("myobj");
+ value = yield asyncStorage.getItem("myobj");
+ is(value, null, "value is correct");
+});
+
+add_task(function* () {
+ yield asyncStorage.clear();
+ let len = yield asyncStorage.length();
+ is(len, 0, "length is correct");
+ yield asyncStorage.setItem("key1", "value1");
+ len = yield asyncStorage.length();
+ is(len, 1, "length is correct");
+ yield asyncStorage.setItem("key2", "value2");
+ len = yield asyncStorage.length();
+ is(len, 2, "length is correct");
+ yield asyncStorage.setItem("key3", "value3");
+ len = yield asyncStorage.length();
+ is(len, 3, "length is correct");
+
+ let key = yield asyncStorage.key(0);
+ is(key, "key1", "key is correct");
+ key = yield asyncStorage.key(1);
+ is(key, "key2", "key is correct");
+ key = yield asyncStorage.key(2);
+ is(key, "key3", "key is correct");
+ key = yield asyncStorage.key(3);
+ is(key, null, "key is correct");
+ yield asyncStorage.clear();
+ key = yield asyncStorage.key(0);
+ is(key, null, "key is correct");
+
+ len = yield asyncStorage.length();
+ is(len, 0, "length is correct");
+});
diff --git a/devtools/shared/tests/browser/browser_l10n_localizeMarkup.js b/devtools/shared/tests/browser/browser_l10n_localizeMarkup.js
new file mode 100644
index 000000000..f33a5a331
--- /dev/null
+++ b/devtools/shared/tests/browser/browser_l10n_localizeMarkup.js
@@ -0,0 +1,54 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Tests that the markup localization works properly.
+
+const { localizeMarkup, LocalizationHelper } = require("devtools/shared/l10n");
+
+add_task(function* () {
+ info("Check that the strings used for this test are still valid");
+ let STARTUP_L10N = new LocalizationHelper("devtools/client/locales/startup.properties");
+ let TOOLBOX_L10N = new LocalizationHelper("devtools/client/locales/toolbox.properties");
+ let str1 = STARTUP_L10N.getStr("inspector.label");
+ let str2 = STARTUP_L10N.getStr("inspector.commandkey");
+ let str3 = TOOLBOX_L10N.getStr("toolbox.defaultTitle");
+ ok(str1 && str2 && str3, "If this failed, strings should be updated in the test");
+
+ info("Create the test markup");
+ let div = document.createElement("div");
+ div.innerHTML =
+ `<div data-localization-bundle="devtools/client/locales/startup.properties">
+ <div id="d0" data-localization="content=inspector.someInvalidKey"></div>
+ <div id="d1" data-localization="content=inspector.label">Text will disappear</div>
+ <div id="d2" data-localization="content=inspector.label;title=inspector.commandkey">
+ </div>
+ <!-- keep the following data-localization on two separate lines -->
+ <div id="d3" data-localization="content=inspector.label;
+ title=inspector.commandkey"></div>
+ <div id="d4" data-localization="aria-label=inspector.label">Some content</div>
+ <div data-localization-bundle="devtools/client/locales/toolbox.properties">
+ <div id="d5" data-localization="content=toolbox.defaultTitle"></div>
+ </div>
+ </div>
+ `;
+
+ info("Use localization helper to localize the test markup");
+ localizeMarkup(div);
+
+ let div1 = div.querySelector("#d1");
+ let div2 = div.querySelector("#d2");
+ let div3 = div.querySelector("#d3");
+ let div4 = div.querySelector("#d4");
+ let div5 = div.querySelector("#d5");
+
+ is(div1.innerHTML, str1, "The content of #d1 is localized");
+ is(div2.innerHTML, str1, "The content of #d2 is localized");
+ is(div2.getAttribute("title"), str2, "The title of #d2 is localized");
+ is(div3.innerHTML, str1, "The content of #d3 is localized");
+ is(div3.getAttribute("title"), str2, "The title of #d3 is localized");
+ is(div4.innerHTML, "Some content", "The content of #d4 is not replaced");
+ is(div4.getAttribute("aria-label"), str1, "The aria-label of #d4 is localized");
+ is(div5.innerHTML, str3, "The content of #d5 is localized with another bundle");
+});
diff --git a/devtools/shared/tests/mochitest/chrome.ini b/devtools/shared/tests/mochitest/chrome.ini
new file mode 100644
index 000000000..85ece7c48
--- /dev/null
+++ b/devtools/shared/tests/mochitest/chrome.ini
@@ -0,0 +1,7 @@
+[DEFAULT]
+tags = devtools
+skip-if = os == 'android'
+
+[test_eventemitter_basic.html]
+[test_devtools_extensions.html]
+skip-if = os == 'linux' && debug # Bug 1205739
diff --git a/devtools/shared/tests/mochitest/test_devtools_extensions.html b/devtools/shared/tests/mochitest/test_devtools_extensions.html
new file mode 100644
index 000000000..04cc82b22
--- /dev/null
+++ b/devtools/shared/tests/mochitest/test_devtools_extensions.html
@@ -0,0 +1,117 @@
+<!DOCTYPE html>
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+
+ <head>
+ <meta charset="utf8">
+ <title></title>
+
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css"
+ href="chrome://mochikit/content/tests/SimpleTest/test.css">
+
+ <script type="application/javascript;version=1.8">
+ const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+
+ let { require } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+ const contentGlobals = require("devtools/server/content-globals");
+ const Services = require("Services");
+ const tabs = require('sdk/tabs');
+ const { getMostRecentBrowserWindow, getInnerId } = require('sdk/window/utils');
+ const { PageMod } = require('sdk/page-mod');
+
+ var _tests = [];
+ function addTest(test) {
+ _tests.push(test);
+ }
+
+ function runNextTest() {
+ if (_tests.length == 0) {
+ SimpleTest.finish()
+ return;
+ }
+ _tests.shift()();
+ }
+
+ window.onload = function() {
+ SimpleTest.waitForExplicitFinish();
+ runNextTest();
+ }
+
+ addTest(function () {
+ let TEST_URL = 'data:text/html;charset=utf-8,test';
+
+ let mod = PageMod({
+ include: TEST_URL,
+ contentScriptWhen: 'ready',
+ contentScript: 'null;'
+ });
+
+ tabs.open({
+ url: TEST_URL,
+ onLoad: function(tab) {
+ let id = getInnerId(getMostRecentBrowserWindow().gBrowser.selectedBrowser.contentWindow);
+
+ // getting
+ is(contentGlobals.getContentGlobals({
+ 'inner-window-id': id
+ }).length, 1, 'found a global for inner-id = ' + id);
+
+ Services.obs.addObserver(function observer(subject, topic, data) {
+ if (id == subject.QueryInterface(Components.interfaces.nsISupportsPRUint64).data) {
+ Services.obs.removeObserver(observer, 'inner-window-destroyed');
+ setTimeout(function() {
+ // closing the tab window should have removed the global
+ is(contentGlobals.getContentGlobals({
+ 'inner-window-id': id
+ }).length, 0, 'did not find a global for inner-id = ' + id);
+
+ mod.destroy();
+ runNextTest();
+ })
+ }
+ }, 'inner-window-destroyed', false);
+
+ tab.close();
+ }
+ });
+ })
+
+ addTest(function testAddRemoveGlobal() {
+ let global = {};
+ let globalDetails = {
+ global: global,
+ 'inner-window-id': 5
+ };
+
+ // adding
+ contentGlobals.addContentGlobal(globalDetails);
+
+ // getting
+ is(contentGlobals.getContentGlobals({
+ 'inner-window-id': 5
+ }).length, 1, 'found a global for inner-id = 5');
+ is(contentGlobals.getContentGlobals({
+ 'inner-window-id': 4
+ }).length, 0, 'did not find a global for inner-id = 4');
+
+ // remove
+ contentGlobals.removeContentGlobal(globalDetails);
+
+ // getting again
+ is(contentGlobals.getContentGlobals({
+ 'inner-window-id': 5
+ }).length, 0, 'did not find a global for inner-id = 5');
+
+ runNextTest();
+ });
+
+ </script>
+ </head>
+ <body></body>
+</html>
diff --git a/devtools/shared/tests/mochitest/test_eventemitter_basic.html b/devtools/shared/tests/mochitest/test_eventemitter_basic.html
new file mode 100644
index 000000000..9826eebca
--- /dev/null
+++ b/devtools/shared/tests/mochitest/test_eventemitter_basic.html
@@ -0,0 +1,194 @@
+<!DOCTYPE html>
+<!--
+ Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/
+-->
+
+<html>
+
+ <head>
+ <meta charset="utf8">
+ <title></title>
+
+ <script type="application/javascript"
+ src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css"
+ href="chrome://mochikit/content/tests/SimpleTest/test.css">
+ </head>
+
+ <body>
+
+ <script type="application/javascript;version=1.8">
+ "use strict";
+
+ const { utils: Cu } = Components;
+ const { require } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+ const promise = require("promise");
+ const EventEmitter = require("devtools/shared/event-emitter");
+ const { Task } = require("devtools/shared/task");
+
+ SimpleTest.waitForExplicitFinish();
+
+ testEmitter();
+ testEmitter({});
+
+ Task.spawn(testPromise)
+ .then(null, ok.bind(null, false))
+ .then(SimpleTest.finish);
+
+ function testEmitter(aObject) {
+ let emitter;
+
+ if (aObject) {
+ emitter = aObject;
+ EventEmitter.decorate(emitter);
+ } else {
+ emitter = new EventEmitter();
+ }
+
+ ok(emitter, "We have an event emitter");
+
+ let beenHere1 = false;
+ let beenHere2 = false;
+
+ emitter.on("next", next);
+ emitter.emit("next", "abc", "def");
+
+ function next(eventName, str1, str2) {
+ is(eventName, "next", "Got event");
+ is(str1, "abc", "Argument 1 is correct");
+ is(str2, "def", "Argument 2 is correct");
+
+ ok(!beenHere1, "first time in next callback");
+ beenHere1 = true;
+
+ emitter.off("next", next);
+
+ emitter.emit("next");
+
+ emitter.once("onlyonce", onlyOnce);
+
+ emitter.emit("onlyonce");
+ emitter.emit("onlyonce");
+ }
+
+ function onlyOnce() {
+ ok(!beenHere2, "\"once\" listener has been called once");
+ beenHere2 = true;
+ emitter.emit("onlyonce");
+
+ testThrowingExceptionInListener();
+ }
+
+ function testThrowingExceptionInListener() {
+ function throwListener() {
+ emitter.off("throw-exception");
+ throw {
+ toString: () => "foo",
+ stack: "bar",
+ };
+ }
+
+ emitter.on("throw-exception", throwListener);
+ emitter.emit("throw-exception");
+
+ killItWhileEmitting();
+ }
+
+ function killItWhileEmitting() {
+ function c1() {
+ ok(true, "c1 called");
+ }
+ function c2() {
+ ok(true, "c2 called");
+ emitter.off("tick", c3);
+ }
+ function c3() {
+ ok(false, "c3 should not be called");
+ }
+ function c4() {
+ ok(true, "c4 called");
+ }
+
+ emitter.on("tick", c1);
+ emitter.on("tick", c2);
+ emitter.on("tick", c3);
+ emitter.on("tick", c4);
+
+ emitter.emit("tick");
+
+ offAfterOnce();
+ }
+
+ function offAfterOnce() {
+ let enteredC1 = false;
+
+ function c1() {
+ enteredC1 = true;
+ }
+
+ emitter.once("oao", c1);
+ emitter.off("oao", c1);
+
+ emitter.emit("oao");
+
+ ok(!enteredC1, "c1 should not be called");
+ }
+ }
+
+ function testPromise() {
+ let emitter = new EventEmitter();
+ let p = emitter.once("thing");
+
+ // Check that the promise is only resolved once event though we
+ // emit("thing") more than once
+ let firstCallbackCalled = false;
+ let check1 = p.then(arg => {
+ is(firstCallbackCalled, false, "first callback called only once");
+ firstCallbackCalled = true;
+ is(arg, "happened", "correct arg in promise");
+ return "rval from c1";
+ });
+
+ emitter.emit("thing", "happened", "ignored");
+
+ // Check that the promise is resolved asynchronously
+ let secondCallbackCalled = false;
+ let check2 = p.then(arg => {
+ ok(true, "second callback called");
+ is(arg, "happened", "correct arg in promise");
+ secondCallbackCalled = true;
+ is(arg, "happened", "correct arg in promise (a second time)");
+ return "rval from c2";
+ });
+
+ // Shouldn't call any of the above listeners
+ emitter.emit("thing", "trashinate");
+
+ // Check that we can still separate events with different names
+ // and that it works with no parameters
+ let pfoo = emitter.once("foo");
+ let pbar = emitter.once("bar");
+
+ let check3 = pfoo.then(arg => {
+ ok(arg === undefined, "no arg for foo event");
+ return "rval from c3";
+ });
+
+ pbar.then(() => {
+ ok(false, "pbar should not be called");
+ });
+
+ emitter.emit("foo");
+
+ is(secondCallbackCalled, false, "second callback not called yet");
+
+ return promise.all([ check1, check2, check3 ]).then(args => {
+ is(args[0], "rval from c1", "callback 1 done good");
+ is(args[1], "rval from c2", "callback 2 done good");
+ is(args[2], "rval from c3", "callback 3 done good");
+ });
+ }
+ </script>
+ </body>
+</html>
diff --git a/devtools/shared/tests/unit/.eslintrc.js b/devtools/shared/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..012428019
--- /dev/null
+++ b/devtools/shared/tests/unit/.eslintrc.js
@@ -0,0 +1,6 @@
+"use strict";
+
+module.exports = {
+ // Extend from the common devtools xpcshell eslintrc config.
+ "extends": "../../../.eslintrc.xpcshell.js"
+};
diff --git a/devtools/shared/tests/unit/exposeLoader.js b/devtools/shared/tests/unit/exposeLoader.js
new file mode 100644
index 000000000..949640a03
--- /dev/null
+++ b/devtools/shared/tests/unit/exposeLoader.js
@@ -0,0 +1,8 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+exports.exerciseLazyRequire = (name, path) => {
+ const o = {};
+ loader.lazyRequireGetter(o, name, path);
+ return o;
+};
diff --git a/devtools/shared/tests/unit/head_devtools.js b/devtools/shared/tests/unit/head_devtools.js
new file mode 100644
index 000000000..f0f47c93a
--- /dev/null
+++ b/devtools/shared/tests/unit/head_devtools.js
@@ -0,0 +1,60 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+var Cu = Components.utils;
+var Cr = Components.results;
+
+const {require, DevToolsLoader, devtools} = Cu.import("resource://devtools/shared/Loader.jsm", {});
+const DevToolsUtils = require("devtools/shared/DevToolsUtils");
+const flags = require("devtools/shared/flags");
+
+flags.testing = true;
+do_register_cleanup(() => {
+ flags.testing = false;
+});
+
+// Register a console listener, so console messages don't just disappear
+// into the ether.
+
+// If for whatever reason the test needs to post console errors that aren't
+// failures, set this to true.
+var ALLOW_CONSOLE_ERRORS = false;
+
+var errorCount = 0;
+var 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();
+ }
+
+ if (!ALLOW_CONSOLE_ERRORS) {
+ do_throw("head_devtools.js got console message: " + string + "\n");
+ }
+ }
+};
+
+var consoleService = Cc["@mozilla.org/consoleservice;1"].getService(Ci.nsIConsoleService);
+consoleService.registerListener(listener);
diff --git a/devtools/shared/tests/unit/test_assert.js b/devtools/shared/tests/unit/test_assert.js
new file mode 100644
index 000000000..b87171751
--- /dev/null
+++ b/devtools/shared/tests/unit/test_assert.js
@@ -0,0 +1,36 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test DevToolsUtils.assert
+
+ALLOW_CONSOLE_ERRORS = true;
+
+function run_test() {
+ // Enable assertions.
+ flags.testing = true;
+
+ const { assert } = DevToolsUtils;
+ equal(typeof assert, "function");
+
+ try {
+ assert(true, "this assertion should not fail");
+ } catch (e) {
+ // If you catch assertion failures in practice, I will hunt you down. I get
+ // email notifications every time it happens.
+ ok(false, "Should not get an error for an assertion that should not fail. Got "
+ + DevToolsUtils.safeErrorString(e));
+ }
+
+ let assertionFailed = false;
+ try {
+ assert(false, "this assertion should fail");
+ } catch (e) {
+ ok(e.message.startsWith("Assertion failure:"),
+ "Should be an assertion failure error");
+ assertionFailed = true;
+ }
+
+ ok(assertionFailed,
+ "The assertion should have failed, which should throw an error when assertions are enabled.");
+}
diff --git a/devtools/shared/tests/unit/test_async-utils.js b/devtools/shared/tests/unit/test_async-utils.js
new file mode 100644
index 000000000..2b09b8260
--- /dev/null
+++ b/devtools/shared/tests/unit/test_async-utils.js
@@ -0,0 +1,157 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test async-utils.js
+
+const {Task} = require("devtools/shared/task");
+// |const| will not work because
+// it will make the Promise object immutable before assigning.
+// Using Object.defineProperty() instead.
+Object.defineProperty(this, "Promise", {
+ value: require("promise"),
+ writable: false, configurable: false
+});
+const {asyncOnce, promiseInvoke, promiseCall} = require("devtools/shared/async-utils");
+
+function run_test() {
+ do_test_pending();
+ Task.spawn(function* () {
+ yield test_async_args(asyncOnce);
+ yield test_async_return(asyncOnce);
+ yield test_async_throw(asyncOnce);
+
+ yield test_async_once();
+ yield test_async_invoke();
+ do_test_finished();
+ }).then(null, error => {
+ do_throw(error);
+ });
+}
+
+// Test that arguments are correctly passed through to the async function.
+function test_async_args(async) {
+ let obj = {
+ method: async(function* (a, b) {
+ do_check_eq(this, obj);
+ do_check_eq(a, "foo");
+ do_check_eq(b, "bar");
+ })
+ };
+
+ return obj.method("foo", "bar");
+}
+
+// Test that the return value from the async function is resolution value of
+// the promise.
+function test_async_return(async) {
+ let obj = {
+ method: async(function* (a, b) {
+ return a + b;
+ })
+ };
+
+ return obj.method("foo", "bar").then(ret => {
+ do_check_eq(ret, "foobar");
+ });
+}
+
+// Test that the throwing from an async function rejects the promise.
+function test_async_throw(async) {
+ let obj = {
+ method: async(function* () {
+ throw "boom";
+ })
+ };
+
+ return obj.method().then(null, error => {
+ do_check_eq(error, "boom");
+ });
+}
+
+// Test that asyncOnce only runs the async function once per instance and
+// returns the same promise for that instance.
+function test_async_once() {
+ let counter = 0;
+
+ function Foo() {}
+ Foo.prototype = {
+ ran: false,
+ method: asyncOnce(function* () {
+ yield Promise.resolve();
+ if (this.ran) {
+ do_throw("asyncOnce function unexpectedly ran twice on the same object");
+ }
+ this.ran = true;
+ return counter++;
+ })
+ };
+
+ let foo1 = new Foo();
+ let foo2 = new Foo();
+ let p1 = foo1.method();
+ let p2 = foo2.method();
+
+ do_check_neq(p1, p2);
+
+ let p3 = foo1.method();
+ do_check_eq(p1, p3);
+ do_check_false(foo1.ran);
+
+ let p4 = foo2.method();
+ do_check_eq(p2, p4);
+ do_check_false(foo2.ran);
+
+ return p1.then(ret => {
+ do_check_true(foo1.ran);
+ do_check_eq(ret, 0);
+ return p2;
+ }).then(ret => {
+ do_check_true(foo2.ran);
+ do_check_eq(ret, 1);
+ });
+}
+
+// Test invoke and call.
+function test_async_invoke() {
+ return Task.spawn(function* () {
+ function func(a, b, expectedThis, callback) {
+ "use strict";
+ do_check_eq(a, "foo");
+ do_check_eq(b, "bar");
+ do_check_eq(this, expectedThis);
+ callback(a + b);
+ }
+
+ // Test call.
+ let callResult = yield promiseCall(func, "foo", "bar", undefined);
+ do_check_eq(callResult, "foobar");
+
+
+ // Test invoke.
+ let obj = { method: func };
+ let invokeResult = yield promiseInvoke(obj, obj.method, "foo", "bar", obj);
+ do_check_eq(invokeResult, "foobar");
+
+
+ // Test passing multiple values to the callback.
+ function multipleResults(callback) {
+ callback("foo", "bar");
+ }
+
+ let results = yield promiseCall(multipleResults);
+ do_check_eq(results.length, 2);
+ do_check_eq(results[0], "foo");
+ do_check_eq(results[1], "bar");
+
+
+ // Test throwing from the function.
+ function thrower() {
+ throw "boom";
+ }
+
+ yield promiseCall(thrower).then(null, error => {
+ do_check_eq(error, "boom");
+ });
+ });
+}
diff --git a/devtools/shared/tests/unit/test_console_filtering.js b/devtools/shared/tests/unit/test_console_filtering.js
new file mode 100644
index 000000000..431e2b234
--- /dev/null
+++ b/devtools/shared/tests/unit/test_console_filtering.js
@@ -0,0 +1,133 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { console, ConsoleAPI } = require("resource://gre/modules/Console.jsm");
+const { ConsoleAPIListener } = require("devtools/server/actors/utils/webconsole-utils");
+const Services = require("Services");
+
+var seenMessages = 0;
+var seenTypes = 0;
+
+var callback = {
+ onConsoleAPICall: function (aMessage) {
+ if (aMessage.consoleID && aMessage.consoleID == "addon/foo") {
+ do_check_eq(aMessage.level, "warn");
+ do_check_eq(aMessage.arguments[0], "Warning from foo");
+ seenTypes |= 1;
+ } else if (aMessage.originAttributes &&
+ aMessage.originAttributes.addonId == "bar") {
+ do_check_eq(aMessage.level, "error");
+ do_check_eq(aMessage.arguments[0], "Error from bar");
+ seenTypes |= 2;
+ } else {
+ do_check_eq(aMessage.level, "log");
+ do_check_eq(aMessage.arguments[0], "Hello from default console");
+ seenTypes |= 4;
+ }
+ seenMessages++;
+ }
+};
+
+function createFakeAddonWindow({addonId} = {}) {
+ let baseURI = Services.io.newURI("about:blank", null, null);
+ let originAttributes = {addonId};
+ let principal = Services.scriptSecurityManager
+ .createCodebasePrincipal(baseURI, originAttributes);
+ let chromeWebNav = Services.appShell.createWindowlessBrowser(true);
+ let docShell = chromeWebNav.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDocShell);
+ docShell.createAboutBlankContentViewer(principal);
+ let addonWindow = docShell.contentViewer.DOMDocument.defaultView;
+
+ return {addonWindow, chromeWebNav};
+}
+
+/**
+ * Tests that the consoleID property of the ConsoleAPI options gets passed
+ * through to console messages.
+ */
+function run_test() {
+ // console1 Test Console.jsm messages tagged by the Addon SDK
+ // are still filtered correctly.
+ let console1 = new ConsoleAPI({
+ consoleID: "addon/foo"
+ });
+
+ // console2 - WebExtension page's console messages tagged
+ // by 'originAttributes.addonId' are filtered correctly.
+ let {addonWindow, chromeWebNav} = createFakeAddonWindow({addonId: "bar"});
+ let console2 = addonWindow.console;
+
+ // console - Plain console object (messages are tagged with window ids
+ // and originAttributes, but the addonId will be empty).
+ console.log("Hello from default console");
+
+ console1.warn("Warning from foo");
+ console2.error("Error from bar");
+
+ let listener = new ConsoleAPIListener(null, callback);
+ listener.init();
+ let messages = listener.getCachedMessages();
+
+ seenTypes = 0;
+ seenMessages = 0;
+ messages.forEach(callback.onConsoleAPICall);
+ do_check_eq(seenMessages, 3);
+ do_check_eq(seenTypes, 7);
+
+ seenTypes = 0;
+ seenMessages = 0;
+ console.log("Hello from default console");
+ console1.warn("Warning from foo");
+ console2.error("Error from bar");
+ do_check_eq(seenMessages, 3);
+ do_check_eq(seenTypes, 7);
+
+ listener.destroy();
+
+ listener = new ConsoleAPIListener(null, callback, {addonId: "foo"});
+ listener.init();
+ messages = listener.getCachedMessages();
+
+ seenTypes = 0;
+ seenMessages = 0;
+ messages.forEach(callback.onConsoleAPICall);
+ do_check_eq(seenMessages, 2);
+ do_check_eq(seenTypes, 1);
+
+ seenTypes = 0;
+ seenMessages = 0;
+ console.log("Hello from default console");
+ console1.warn("Warning from foo");
+ console2.error("Error from bar");
+ do_check_eq(seenMessages, 1);
+ do_check_eq(seenTypes, 1);
+
+ listener.destroy();
+
+ listener = new ConsoleAPIListener(null, callback, {addonId: "bar"});
+ listener.init();
+ messages = listener.getCachedMessages();
+
+ seenTypes = 0;
+ seenMessages = 0;
+ messages.forEach(callback.onConsoleAPICall);
+ do_check_eq(seenMessages, 3);
+ do_check_eq(seenTypes, 2);
+
+ seenTypes = 0;
+ seenMessages = 0;
+ console.log("Hello from default console");
+ console1.warn("Warning from foo");
+ console2.error("Error from bar");
+
+ do_check_eq(seenMessages, 1);
+ do_check_eq(seenTypes, 2);
+
+ listener.destroy();
+
+ // Close the addon window's chromeWebNav.
+ chromeWebNav.close();
+}
diff --git a/devtools/shared/tests/unit/test_css-properties-db.js b/devtools/shared/tests/unit/test_css-properties-db.js
new file mode 100644
index 000000000..108650a3e
--- /dev/null
+++ b/devtools/shared/tests/unit/test_css-properties-db.js
@@ -0,0 +1,136 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Test that the devtool's client-side CSS properties database is in sync with the values
+ * on the platform (in Nightly only). If they are not, then `mach devtools-css-db` needs
+ * to be run to make everything up to date. Nightly, aurora, beta, and release may have
+ * different CSS properties and values. These are based on preferences and compiler flags.
+ *
+ * This test broke uplifts as the database needed to be regenerated every uplift. The
+ * combination of compiler flags and preferences means that it's too difficult to
+ * statically determine which properties are enabled between Firefox releases.
+ *
+ * Because of these difficulties, the database only needs to be up to date with Nightly.
+ * It is a fallback that is only used if the remote debugging protocol doesn't support
+ * providing a CSS database, so it's ok if the provided properties don't exactly match
+ * the inspected target in this particular case.
+ */
+
+"use strict";
+
+const DOMUtils = Components.classes["@mozilla.org/inspector/dom-utils;1"]
+ .getService(Components.interfaces.inIDOMUtils);
+
+const {PSEUDO_ELEMENTS, CSS_PROPERTIES} = require("devtools/shared/css/generated/properties-db");
+const {generateCssProperties} = require("devtools/server/actors/css-properties");
+
+function run_test() {
+ const propertiesErrorMessage = "If this assertion fails, then the client side CSS " +
+ "properties list in devtools is out of sync with the " +
+ "CSS properties on the platform. To fix this " +
+ "assertion run `mach devtools-css-db` to re-generate " +
+ "the client side properties.";
+
+ // Check that the platform and client match for pseudo elements.
+ deepEqual(PSEUDO_ELEMENTS, DOMUtils.getCSSPseudoElementNames(), `The pseudo elements ` +
+ `match on the client and platform. ${propertiesErrorMessage}`);
+
+ /**
+ * Check that the platform and client match for the details on their CSS properties.
+ * Enumerate each property to aid in debugging.
+ */
+ const platformProperties = generateCssProperties();
+
+ for (let propertyName in CSS_PROPERTIES) {
+ const platformProperty = platformProperties[propertyName];
+ const clientProperty = CSS_PROPERTIES[propertyName];
+ const deepEqual = isJsonDeepEqual(platformProperty, clientProperty);
+
+ if (deepEqual) {
+ ok(true, `The static database and platform match for "${propertyName}".`);
+ } else {
+ const prefMessage = `The static database and platform do not match ` +
+ `for "${propertyName}".`;
+ if (getPreference(propertyName) === false) {
+ ok(true, `${prefMessage} However, there is a preference for disabling this ` +
+ `property on the current build.`);
+ } else {
+ ok(false, `${prefMessage} ${propertiesErrorMessage}`);
+ }
+ }
+ }
+
+ /**
+ * Check that the list of properties on the platform and client are the same. If
+ * they are not, check that there may be preferences that are disabling them on the
+ * target platform.
+ */
+ const mismatches = getKeyMismatches(platformProperties, CSS_PROPERTIES)
+ // Filter out OS-specific properties.
+ .filter(name => name && name.indexOf("-moz-osx-") === -1);
+
+ if (mismatches.length === 0) {
+ ok(true, "No client and platform CSS property database mismatches were found.");
+ }
+
+ mismatches.forEach(propertyName => {
+ ok(false, `The static database and platform do not agree on the property ` +
+ `"${propertyName}" ${propertiesErrorMessage}`);
+ });
+}
+
+/**
+ * Check JSON-serializable objects for deep equality.
+ */
+function isJsonDeepEqual(a, b) {
+ // Handle primitives.
+ if (a === b) {
+ return true;
+ }
+
+ // Handle arrays.
+ if (Array.isArray(a) && Array.isArray(b)) {
+ if (a.length !== b.length) {
+ return false;
+ }
+ for (let i = 0; i < a.length; i++) {
+ if (!isJsonDeepEqual(a[i], b[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ // Handle objects
+ if (typeof a === "object" && typeof b === "object") {
+ for (let key in a) {
+ if (!isJsonDeepEqual(a[key], b[key])) {
+ return false;
+ }
+ }
+
+ return Object.keys(a).length === Object.keys(b).length;
+ }
+
+ // Not something handled by these cases, therefore not equal.
+ return false;
+}
+
+/**
+ * Take the keys of two objects, and return the ones that don't match.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Array} keys
+ */
+function getKeyMismatches(a, b) {
+ const aNames = Object.keys(a);
+ const bNames = Object.keys(b);
+ const aMismatches = aNames.filter(key => !bNames.includes(key));
+ const bMismatches = bNames.filter(key => {
+ return !aNames.includes(key) && !aMismatches.includes(key);
+ });
+
+ return aMismatches.concat(bMismatches);
+}
diff --git a/devtools/shared/tests/unit/test_csslexer.js b/devtools/shared/tests/unit/test_csslexer.js
new file mode 100644
index 000000000..35855640b
--- /dev/null
+++ b/devtools/shared/tests/unit/test_csslexer.js
@@ -0,0 +1,242 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+// This file is a copy of layout/style/test/test_csslexer.js, modified
+// to use both our pure-JS lexer and the DOMUtils lexer for
+// cross-checking.
+
+"use strict";
+
+const jsLexer = require("devtools/shared/css/lexer");
+const domutils = Components.classes["@mozilla.org/inspector/dom-utils;1"]
+ .getService(Components.interfaces.inIDOMUtils);
+
+// An object that acts like a CSSLexer but verifies that the DOM lexer
+// and the JS lexer do the same thing.
+function DoubleLexer(input) {
+ do_print("DoubleLexer input: " + input);
+ this.domLexer = domutils.getCSSLexer(input);
+ this.jsLexer = jsLexer.getCSSLexer(input);
+}
+
+DoubleLexer.prototype = {
+ checkState: function () {
+ equal(this.domLexer.lineNumber, this.jsLexer.lineNumber,
+ "check line number");
+ equal(this.domLexer.columnNumber, this.jsLexer.columnNumber,
+ "check column number");
+ },
+
+ get lineNumber() {
+ return this.domLexer.lineNumber;
+ },
+
+ get columnNumber() {
+ return this.domLexer.columnNumber;
+ },
+
+ performEOFFixup: function (inputString, preserveBackslash) {
+ let d = this.domLexer.performEOFFixup(inputString, preserveBackslash);
+ let j = this.jsLexer.performEOFFixup(inputString, preserveBackslash);
+
+ equal(d, j);
+ return d;
+ },
+
+ mungeNumber: function (token) {
+ if (token && (token.tokenType === "number" ||
+ token.tokenType === "percentage") &&
+ !token.isInteger) {
+ // The JS lexer does its computations in double, but the
+ // platform lexer does its computations in float. Account for
+ // this discrepancy in a way that's sufficient for this test.
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=1163047
+ token.number = parseFloat(token.number.toPrecision(8));
+ }
+ },
+
+ nextToken: function () {
+ // Check state both before and after.
+ this.checkState();
+
+ let d = this.domLexer.nextToken();
+ let j = this.jsLexer.nextToken();
+
+ this.mungeNumber(d);
+ this.mungeNumber(j);
+
+ deepEqual(d, j);
+
+ this.checkState();
+
+ return d;
+ }
+};
+
+function test_lexer(cssText, tokenTypes) {
+ let lexer = new DoubleLexer(cssText);
+ let reconstructed = "";
+ let lastTokenEnd = 0;
+ let i = 0;
+ while (true) {
+ let token = lexer.nextToken();
+ if (!token) {
+ break;
+ }
+ let combined = token.tokenType;
+ if (token.text) {
+ combined += ":" + token.text;
+ }
+ equal(combined, tokenTypes[i]);
+ ok(token.endOffset > token.startOffset);
+ equal(token.startOffset, lastTokenEnd);
+ lastTokenEnd = token.endOffset;
+ reconstructed += cssText.substring(token.startOffset, token.endOffset);
+ ++i;
+ }
+ // Ensure that we saw the correct number of tokens.
+ equal(i, tokenTypes.length);
+ // Ensure that the reported offsets cover all the text.
+ equal(reconstructed, cssText);
+}
+
+var LEX_TESTS = [
+ ["simple", ["ident:simple"]],
+ ["simple: { hi; }",
+ ["ident:simple", "symbol::",
+ "whitespace", "symbol:{",
+ "whitespace", "ident:hi",
+ "symbol:;", "whitespace",
+ "symbol:}"]],
+ ["/* whatever */", ["comment"]],
+ ["'string'", ["string:string"]],
+ ['"string"', ["string:string"]],
+ ["rgb(1,2,3)", ["function:rgb", "number",
+ "symbol:,", "number",
+ "symbol:,", "number",
+ "symbol:)"]],
+ ["@media", ["at:media"]],
+ ["#hibob", ["id:hibob"]],
+ ["#123", ["hash:123"]],
+ ["23px", ["dimension:px"]],
+ ["23%", ["percentage"]],
+ ["url(http://example.com)", ["url:http://example.com"]],
+ ["url('http://example.com')", ["url:http://example.com"]],
+ ["url( 'http://example.com' )",
+ ["url:http://example.com"]],
+ // In CSS Level 3, this is an ordinary URL, not a BAD_URL.
+ ["url(http://example.com", ["url:http://example.com"]],
+ // See bug 1153981 to understand why this gets a SYMBOL token.
+ ["url(http://example.com @", ["bad_url:http://example.com", "symbol:@"]],
+ ["quo\\ting", ["ident:quoting"]],
+ ["'bad string\n", ["bad_string:bad string", "whitespace"]],
+ ["~=", ["includes"]],
+ ["|=", ["dashmatch"]],
+ ["^=", ["beginsmatch"]],
+ ["$=", ["endsmatch"]],
+ ["*=", ["containsmatch"]],
+
+ // URANGE may be on the way out, and it isn't used by devutils, so
+ // let's skip it.
+
+ ["<!-- html comment -->", ["htmlcomment", "whitespace", "ident:html",
+ "whitespace", "ident:comment", "whitespace",
+ "htmlcomment"]],
+
+ // earlier versions of CSS had "bad comment" tokens, but in level 3,
+ // unterminated comments are just comments.
+ ["/* bad comment", ["comment"]]
+];
+
+function test_lexer_linecol(cssText, locations) {
+ let lexer = new DoubleLexer(cssText);
+ let i = 0;
+ while (true) {
+ let token = lexer.nextToken();
+ let startLine = lexer.lineNumber;
+ let startColumn = lexer.columnNumber;
+
+ // We do this in a bit of a funny way so that we can also test the
+ // location of the EOF.
+ let combined = ":" + startLine + ":" + startColumn;
+ if (token) {
+ combined = token.tokenType + combined;
+ }
+
+ equal(combined, locations[i]);
+ ++i;
+
+ if (!token) {
+ break;
+ }
+ }
+ // Ensure that we saw the correct number of tokens.
+ equal(i, locations.length);
+}
+
+function test_lexer_eofchar(cssText, argText, expectedAppend,
+ expectedNoAppend) {
+ let lexer = new DoubleLexer(cssText);
+ while (lexer.nextToken()) {
+ // Nothing.
+ }
+
+ do_print("EOF char test, input = " + cssText);
+
+ let result = lexer.performEOFFixup(argText, true);
+ equal(result, expectedAppend);
+
+ result = lexer.performEOFFixup(argText, false);
+ equal(result, expectedNoAppend);
+}
+
+var LINECOL_TESTS = [
+ ["simple", ["ident:0:0", ":0:6"]],
+ ["\n stuff", ["whitespace:0:0", "ident:1:4", ":1:9"]],
+ ['"string with \\\nnewline" \r\n', ["string:0:0", "whitespace:1:8",
+ ":2:0"]]
+];
+
+var EOFCHAR_TESTS = [
+ ["hello", "hello"],
+ ["hello \\", "hello \\\\", "hello \\\uFFFD"],
+ ["'hello", "'hello'"],
+ ["\"hello", "\"hello\""],
+ ["'hello\\", "'hello\\\\'", "'hello'"],
+ ["\"hello\\", "\"hello\\\\\"", "\"hello\""],
+ ["/*hello", "/*hello*/"],
+ ["/*hello*", "/*hello*/"],
+ ["/*hello\\", "/*hello\\*/"],
+ ["url(hello", "url(hello)"],
+ ["url('hello", "url('hello')"],
+ ["url(\"hello", "url(\"hello\")"],
+ ["url(hello\\", "url(hello\\\\)", "url(hello\\\uFFFD)"],
+ ["url('hello\\", "url('hello\\\\')", "url('hello')"],
+ ["url(\"hello\\", "url(\"hello\\\\\")", "url(\"hello\")"],
+];
+
+function run_test() {
+ let text, result;
+ for ([text, result] of LEX_TESTS) {
+ test_lexer(text, result);
+ }
+
+ for ([text, result] of LINECOL_TESTS) {
+ test_lexer_linecol(text, result);
+ }
+
+ let expectedAppend, expectedNoAppend;
+ for ([text, expectedAppend, expectedNoAppend] of EOFCHAR_TESTS) {
+ if (!expectedNoAppend) {
+ expectedNoAppend = expectedAppend;
+ }
+ test_lexer_eofchar(text, text, expectedAppend, expectedNoAppend);
+ }
+
+ // Ensure that passing a different inputString to performEOFFixup
+ // doesn't cause an assertion trying to strip a backslash from the
+ // end of an empty string.
+ test_lexer_eofchar("'\\", "", "\\'", "'");
+}
diff --git a/devtools/shared/tests/unit/test_defer.js b/devtools/shared/tests/unit/test_defer.js
new file mode 100644
index 000000000..c0babe961
--- /dev/null
+++ b/devtools/shared/tests/unit/test_defer.js
@@ -0,0 +1,32 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const defer = require("devtools/shared/defer");
+
+function testResolve() {
+ const deferred = defer();
+ deferred.resolve("success");
+ return deferred.promise;
+}
+
+function testReject() {
+ const deferred = defer();
+ deferred.reject("error");
+ return deferred.promise;
+}
+
+add_task(function* () {
+ const success = yield testResolve();
+ equal(success, "success");
+
+ let error;
+ try {
+ yield testReject();
+ } catch (e) {
+ error = e;
+ }
+
+ equal(error, "error");
+});
diff --git a/devtools/shared/tests/unit/test_defineLazyPrototypeGetter.js b/devtools/shared/tests/unit/test_defineLazyPrototypeGetter.js
new file mode 100644
index 000000000..d729e7473
--- /dev/null
+++ b/devtools/shared/tests/unit/test_defineLazyPrototypeGetter.js
@@ -0,0 +1,68 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test DevToolsUtils.defineLazyPrototypeGetter
+
+function Class() {}
+DevToolsUtils.defineLazyPrototypeGetter(Class.prototype, "foo", () => []);
+
+
+function run_test() {
+ test_prototype_attributes();
+ test_instance_attributes();
+ test_multiple_instances();
+ test_callback_receiver();
+}
+
+function test_prototype_attributes() {
+ // Check that the prototype has a getter property with expected attributes.
+ let descriptor = Object.getOwnPropertyDescriptor(Class.prototype, "foo");
+ do_check_eq(typeof descriptor.get, "function");
+ do_check_eq(descriptor.set, undefined);
+ do_check_eq(descriptor.enumerable, false);
+ do_check_eq(descriptor.configurable, true);
+}
+
+function test_instance_attributes() {
+ // Instances should not have an own property until the lazy getter has been
+ // activated.
+ let instance = new Class();
+ do_check_false(instance.hasOwnProperty("foo"));
+ instance.foo;
+ do_check_true(instance.hasOwnProperty("foo"));
+
+ // Check that the instance has an own property with the expecred value and
+ // attributes after the lazy getter is activated.
+ let descriptor = Object.getOwnPropertyDescriptor(instance, "foo");
+ do_check_true(descriptor.value instanceof Array);
+ do_check_eq(descriptor.writable, true);
+ do_check_eq(descriptor.enumerable, false);
+ do_check_eq(descriptor.configurable, true);
+}
+
+function test_multiple_instances() {
+ let instance1 = new Class();
+ let instance2 = new Class();
+ let foo1 = instance1.foo;
+ let foo2 = instance2.foo;
+ // Check that the lazy getter returns the expected type of value.
+ do_check_true(foo1 instanceof Array);
+ do_check_true(foo2 instanceof Array);
+ // Make sure the lazy getter runs once and only once per instance.
+ do_check_eq(instance1.foo, foo1);
+ do_check_eq(instance2.foo, foo2);
+ // Make sure each instance gets its own unique value.
+ do_check_neq(foo1, foo2);
+}
+
+function test_callback_receiver() {
+ function Foo() {}
+ DevToolsUtils.defineLazyPrototypeGetter(Foo.prototype, "foo", function () {
+ return this;
+ });
+
+ // Check that the |this| value in the callback is the instance itself.
+ let instance = new Foo();
+ do_check_eq(instance.foo, instance);
+}
diff --git a/devtools/shared/tests/unit/test_executeSoon.js b/devtools/shared/tests/unit/test_executeSoon.js
new file mode 100644
index 000000000..6154a3e67
--- /dev/null
+++ b/devtools/shared/tests/unit/test_executeSoon.js
@@ -0,0 +1,48 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Client request stacks should span the entire process from before making the
+ * request to handling the reply from the server. The server frames are not
+ * included, nor can they be in most cases, since the server can be a remote
+ * device.
+ */
+
+var { executeSoon } = require("devtools/shared/DevToolsUtils");
+var promise = require("promise");
+var defer = require("devtools/shared/defer");
+var Services = require("Services");
+
+var asyncStackEnabled =
+ Services.prefs.getBoolPref("javascript.options.asyncstack");
+
+do_register_cleanup(() => {
+ Services.prefs.setBoolPref("javascript.options.asyncstack",
+ asyncStackEnabled);
+});
+
+add_task(function* () {
+ Services.prefs.setBoolPref("javascript.options.asyncstack", true);
+
+ yield waitForTick();
+
+ let stack = Components.stack;
+ while (stack) {
+ do_print(stack.name);
+ if (stack.name == "waitForTick") {
+ // Reached back to outer function before executeSoon
+ ok(true, "Complete stack");
+ return;
+ }
+ stack = stack.asyncCaller || stack.caller;
+ }
+ ok(false, "Incomplete stack");
+});
+
+function waitForTick() {
+ let deferred = defer();
+ executeSoon(deferred.resolve);
+ return deferred.promise;
+}
diff --git a/devtools/shared/tests/unit/test_fetch-bom.js b/devtools/shared/tests/unit/test_fetch-bom.js
new file mode 100644
index 000000000..7f299b1ce
--- /dev/null
+++ b/devtools/shared/tests/unit/test_fetch-bom.js
@@ -0,0 +1,76 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Tests for DevToolsUtils.fetch BOM detection.
+
+const CC = Components.Constructor;
+
+const { HttpServer } = Cu.import("resource://testing-common/httpd.js", {});
+const BinaryOutputStream = CC("@mozilla.org/binaryoutputstream;1",
+ "nsIBinaryOutputStream", "setOutputStream");
+
+function write8(bos) {
+ bos.write8(0xef);
+ bos.write8(0xbb);
+ bos.write8(0xbf);
+ bos.write8(0x68);
+ bos.write8(0xc4);
+ bos.write8(0xb1);
+}
+
+function write16be(bos) {
+ bos.write8(0xfe);
+ bos.write8(0xff);
+ bos.write8(0x00);
+ bos.write8(0x68);
+ bos.write8(0x01);
+ bos.write8(0x31);
+}
+
+function write16le(bos) {
+ bos.write8(0xff);
+ bos.write8(0xfe);
+ bos.write8(0x68);
+ bos.write8(0x00);
+ bos.write8(0x31);
+ bos.write8(0x01);
+}
+
+function getHandler(writer) {
+ return function (request, response) {
+ response.setStatusLine(request.httpVersion, 200, "OK");
+
+ let bos = new BinaryOutputStream(response.bodyOutputStream);
+ writer(bos);
+ };
+}
+
+const server = new HttpServer();
+server.registerDirectory("/", do_get_cwd());
+server.registerPathHandler("/u8", getHandler(write8));
+server.registerPathHandler("/u16be", getHandler(write16be));
+server.registerPathHandler("/u16le", getHandler(write16le));
+server.start(-1);
+
+const port = server.identity.primaryPort;
+const serverURL = "http://localhost:" + port;
+
+do_register_cleanup(() => {
+ return new Promise(resolve => server.stop(resolve));
+});
+
+add_task(function* () {
+ yield test_one(serverURL + "/u8", "UTF-8");
+ yield test_one(serverURL + "/u16be", "UTF-16BE");
+ yield test_one(serverURL + "/u16le", "UTF-16LE");
+});
+
+function* test_one(url, encoding) {
+ // Be sure to set the encoding to something that will yield an
+ // invalid result if BOM sniffing is not done.
+ yield DevToolsUtils.fetch(url, { charset: "ISO-8859-1" }).then(({content}) => {
+ do_check_eq(content, "hı", "The content looks correct for " + encoding);
+ });
+}
diff --git a/devtools/shared/tests/unit/test_fetch-chrome.js b/devtools/shared/tests/unit/test_fetch-chrome.js
new file mode 100644
index 000000000..441d4c7ba
--- /dev/null
+++ b/devtools/shared/tests/unit/test_fetch-chrome.js
@@ -0,0 +1,31 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Tests for DevToolsUtils.fetch on chrome:// URI's.
+
+const URL_FOUND = "chrome://devtools-shared/locale/debugger.properties";
+const URL_NOT_FOUND = "chrome://this/is/not/here.js";
+
+/**
+ * Test that non-existent files are handled correctly.
+ */
+add_task(function* test_missing() {
+ yield DevToolsUtils.fetch(URL_NOT_FOUND).then(result => {
+ do_print(result);
+ ok(false, "fetch resolved unexpectedly for non-existent chrome:// URI");
+ }, () => {
+ ok(true, "fetch rejected as the chrome:// URI was non-existent.");
+ });
+});
+
+/**
+ * Tests that existing files are handled correctly.
+ */
+add_task(function* test_normal() {
+ yield DevToolsUtils.fetch(URL_FOUND).then(result => {
+ notDeepEqual(result.content, "",
+ "chrome:// URI seems to be read correctly.");
+ });
+});
diff --git a/devtools/shared/tests/unit/test_fetch-file.js b/devtools/shared/tests/unit/test_fetch-file.js
new file mode 100644
index 000000000..d9d712322
--- /dev/null
+++ b/devtools/shared/tests/unit/test_fetch-file.js
@@ -0,0 +1,104 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Tests for DevToolsUtils.fetch on file:// URI's.
+
+const { FileUtils } = Cu.import("resource://gre/modules/FileUtils.jsm", {});
+const { OS } = Cu.import("resource://gre/modules/osfile.jsm", {});
+
+const TEST_CONTENT = "aéd";
+
+// The TEST_CONTENT encoded as UTF-8.
+const UTF8_TEST_BUFFER = new Uint8Array([0x61, 0xc3, 0xa9, 0x64]);
+
+// The TEST_CONTENT encoded as ISO 8859-1.
+const ISO_8859_1_BUFFER = new Uint8Array([0x61, 0xe9, 0x64]);
+
+/**
+ * Tests that URLs with arrows pointing to an actual source are handled properly
+ * (bug 808960). For example 'resource://gre/modules/XPIProvider.jsm ->
+ * file://l10n.js' should load 'file://l10n.js'.
+ */
+add_task(function* test_arrow_urls() {
+ let { path } = createTemporaryFile(".js");
+ let url = "resource://gre/modules/XPIProvider.jsm -> file://" + path;
+
+ yield OS.File.writeAtomic(path, TEST_CONTENT, { encoding: "utf-8" });
+ let { content } = yield DevToolsUtils.fetch(url);
+
+ deepEqual(content, TEST_CONTENT, "The file contents were correctly read.");
+});
+
+/**
+ * Tests that empty files are read correctly.
+ */
+add_task(function* test_empty() {
+ let { path } = createTemporaryFile();
+ let { content } = yield DevToolsUtils.fetch("file://" + path);
+ deepEqual(content, "", "The empty file was read correctly.");
+});
+
+/**
+ * Tests that UTF-8 encoded files are correctly read.
+ */
+add_task(function* test_encoding_utf8() {
+ let { path } = createTemporaryFile();
+ yield OS.File.writeAtomic(path, UTF8_TEST_BUFFER);
+
+ let { content } = yield DevToolsUtils.fetch(path);
+ deepEqual(content, TEST_CONTENT,
+ "The UTF-8 encoded file was correctly read.");
+});
+
+/**
+ * Tests that ISO 8859-1 (Latin-1) encoded files are correctly read.
+ */
+add_task(function* test_encoding_iso_8859_1() {
+ let { path } = createTemporaryFile();
+ yield OS.File.writeAtomic(path, ISO_8859_1_BUFFER);
+
+ let { content } = yield DevToolsUtils.fetch(path);
+ deepEqual(content, TEST_CONTENT,
+ "The ISO 8859-1 encoded file was correctly read.");
+});
+
+/**
+ * Test that non-existent files are handled correctly.
+ */
+add_task(function* test_missing() {
+ yield DevToolsUtils.fetch("file:///file/not/found.right").then(result => {
+ do_print(result);
+ ok(false, "Fetch resolved unexpectedly when the file was not found.");
+ }, () => {
+ ok(true, "Fetch rejected as expected because the file was not found.");
+ });
+});
+
+/**
+ * Test that URLs without file:// scheme work.
+ */
+add_task(function* test_schemeless_files() {
+ let { path } = createTemporaryFile();
+
+ yield OS.File.writeAtomic(path, TEST_CONTENT, { encoding: "utf-8" });
+
+ let { content } = yield DevToolsUtils.fetch(path);
+ deepEqual(content, TEST_CONTENT, "The content was correct.");
+});
+
+/**
+ * Creates a temporary file that is removed after the test completes.
+ */
+function createTemporaryFile(extension) {
+ let name = "test_fetch-file-" + Math.random() + (extension || "");
+ let file = FileUtils.getFile("TmpD", [name]);
+ file.create(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("0755", 8));
+
+ do_register_cleanup(() => {
+ file.remove(false);
+ });
+
+ return file;
+}
diff --git a/devtools/shared/tests/unit/test_fetch-http.js b/devtools/shared/tests/unit/test_fetch-http.js
new file mode 100644
index 000000000..028fa33ee
--- /dev/null
+++ b/devtools/shared/tests/unit/test_fetch-http.js
@@ -0,0 +1,61 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Tests for DevToolsUtils.fetch on http:// URI's.
+
+const { HttpServer } = Cu.import("resource://testing-common/httpd.js", {});
+
+const server = new HttpServer();
+server.registerDirectory("/", do_get_cwd());
+server.registerPathHandler("/cached.json", cacheRequestHandler);
+server.start(-1);
+
+const port = server.identity.primaryPort;
+const serverURL = "http://localhost:" + port;
+const CACHED_URL = serverURL + "/cached.json";
+const NORMAL_URL = serverURL + "/test_fetch-http.js";
+
+function cacheRequestHandler(request, response) {
+ do_print("Got request for " + request.path);
+ response.setHeader("Cache-Control", "max-age=10000", false);
+ response.setStatusLine(request.httpVersion, 200, "OK");
+ response.setHeader("Content-Type", "application/json", false);
+
+ let body = "[" + Math.random() + "]";
+ response.bodyOutputStream.write(body, body.length);
+}
+
+do_register_cleanup(() => {
+ return new Promise(resolve => server.stop(resolve));
+});
+
+add_task(function* test_normal() {
+ yield DevToolsUtils.fetch(NORMAL_URL).then(({content}) => {
+ ok(content.includes("The content looks correct."),
+ "The content looks correct.");
+ });
+});
+
+add_task(function* test_caching() {
+ let initialContent = null;
+
+ do_print("Performing the first request.");
+ yield DevToolsUtils.fetch(CACHED_URL).then(({content}) => {
+ do_print("Got the first response: " + content);
+ initialContent = content;
+ });
+
+ do_print("Performing another request, expecting to get cached response.");
+ yield DevToolsUtils.fetch(CACHED_URL).then(({content}) => {
+ deepEqual(content, initialContent, "The content was loaded from cache.");
+ });
+
+ do_print("Performing a third request with cache bypassed.");
+ let opts = { loadFromCache: false };
+ yield DevToolsUtils.fetch(CACHED_URL, opts).then(({content}) => {
+ notDeepEqual(content, initialContent,
+ "The URL wasn't loaded from cache with loadFromCache: false.");
+ });
+});
diff --git a/devtools/shared/tests/unit/test_fetch-resource.js b/devtools/shared/tests/unit/test_fetch-resource.js
new file mode 100644
index 000000000..45e79cfa1
--- /dev/null
+++ b/devtools/shared/tests/unit/test_fetch-resource.js
@@ -0,0 +1,31 @@
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+// Tests for DevToolsUtils.fetch on resource:// URI's.
+
+const URL_FOUND = "resource://devtools/shared/DevToolsUtils.js";
+const URL_NOT_FOUND = "resource://devtools/this/is/not/here.js";
+
+/**
+ * Test that non-existent files are handled correctly.
+ */
+add_task(function* test_missing() {
+ yield DevToolsUtils.fetch(URL_NOT_FOUND).then(result => {
+ do_print(result);
+ ok(false, "fetch resolved unexpectedly for non-existent resource:// URI");
+ }, () => {
+ ok(true, "fetch rejected as the resource:// URI was non-existent.");
+ });
+});
+
+/**
+ * Tests that existing files are handled correctly.
+ */
+add_task(function* test_normal() {
+ yield DevToolsUtils.fetch(URL_FOUND).then(result => {
+ notDeepEqual(result.content, "",
+ "resource:// URI seems to be read correctly.");
+ });
+});
diff --git a/devtools/shared/tests/unit/test_flatten.js b/devtools/shared/tests/unit/test_flatten.js
new file mode 100644
index 000000000..f5a186770
--- /dev/null
+++ b/devtools/shared/tests/unit/test_flatten.js
@@ -0,0 +1,24 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test ThreadSafeDevToolsUtils.flatten
+
+function run_test() {
+ const { flatten } = DevToolsUtils;
+
+ const flat = flatten([["a", "b", "c"],
+ ["d", "e", "f"],
+ ["g", "h", "i"]]);
+
+ equal(flat.length, 9);
+ equal(flat[0], "a");
+ equal(flat[1], "b");
+ equal(flat[2], "c");
+ equal(flat[3], "d");
+ equal(flat[4], "e");
+ equal(flat[5], "f");
+ equal(flat[6], "g");
+ equal(flat[7], "h");
+ equal(flat[8], "i");
+}
diff --git a/devtools/shared/tests/unit/test_indentation.js b/devtools/shared/tests/unit/test_indentation.js
new file mode 100644
index 000000000..f7e4403d4
--- /dev/null
+++ b/devtools/shared/tests/unit/test_indentation.js
@@ -0,0 +1,133 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const Services = require("Services");
+const {
+ EXPAND_TAB,
+ TAB_SIZE,
+ DETECT_INDENT,
+ getIndentationFromPrefs,
+ getIndentationFromIteration,
+ getIndentationFromString,
+} = require("devtools/shared/indentation");
+
+function test_indent_from_prefs() {
+ Services.prefs.setBoolPref(DETECT_INDENT, true);
+ equal(getIndentationFromPrefs(), false,
+ "getIndentationFromPrefs returning false");
+
+ Services.prefs.setIntPref(TAB_SIZE, 73);
+ Services.prefs.setBoolPref(EXPAND_TAB, false);
+ Services.prefs.setBoolPref(DETECT_INDENT, false);
+ deepEqual(getIndentationFromPrefs(), {indentUnit: 73, indentWithTabs: true},
+ "getIndentationFromPrefs basic test");
+}
+
+const TESTS = [
+ {
+ desc: "two spaces",
+ input: [
+ "/*",
+ " * tricky comment block",
+ " */",
+ "div {",
+ " color: red;",
+ " background: blue;",
+ "}",
+ " ",
+ "span {",
+ " padding-left: 10px;",
+ "}"
+ ],
+ expected: {indentUnit: 2, indentWithTabs: false}
+ },
+ {
+ desc: "four spaces",
+ input: [
+ "var obj = {",
+ " addNumbers: function() {",
+ " var x = 5;",
+ " var y = 18;",
+ " return x + y;",
+ " },",
+ " ",
+ " /*",
+ " * Do some stuff to two numbers",
+ " * ",
+ " * @param x",
+ " * @param y",
+ " * ",
+ " * @return the result of doing stuff",
+ " */",
+ " subtractNumbers: function(x, y) {",
+ " var x += 7;",
+ " var y += 18;",
+ " var result = x - y;",
+ " result %= 2;",
+ " }",
+ "}"
+ ],
+ expected: {indentUnit: 4, indentWithTabs: false}
+ },
+ {
+ desc: "tabs",
+ input: [
+ "/*",
+ " * tricky comment block",
+ " */",
+ "div {",
+ "\tcolor: red;",
+ "\tbackground: blue;",
+ "}",
+ "",
+ "span {",
+ "\tpadding-left: 10px;",
+ "}"
+ ],
+ expected: {indentUnit: 2, indentWithTabs: true}
+ },
+ {
+ desc: "no indent",
+ input: [
+ "var x = 0;",
+ " // stray thing",
+ "var y = 9;",
+ " ",
+ ""
+ ],
+ expected: {indentUnit: 2, indentWithTabs: false}
+ },
+];
+
+function test_indent_detection() {
+ Services.prefs.setIntPref(TAB_SIZE, 2);
+ Services.prefs.setBoolPref(EXPAND_TAB, true);
+ Services.prefs.setBoolPref(DETECT_INDENT, true);
+
+ for (let test of TESTS) {
+ let iterFn = function (start, end, callback) {
+ test.input.slice(start, end).forEach(callback);
+ };
+
+ deepEqual(getIndentationFromIteration(iterFn), test.expected,
+ "test getIndentationFromIteration " + test.desc);
+ }
+
+ for (let test of TESTS) {
+ deepEqual(getIndentationFromString(test.input.join("\n")), test.expected,
+ "test getIndentationFromString " + test.desc);
+ }
+}
+
+function run_test() {
+ try {
+ test_indent_from_prefs();
+ test_indent_detection();
+ } finally {
+ Services.prefs.clearUserPref(TAB_SIZE);
+ Services.prefs.clearUserPref(EXPAND_TAB);
+ Services.prefs.clearUserPref(DETECT_INDENT);
+ }
+}
diff --git a/devtools/shared/tests/unit/test_independent_loaders.js b/devtools/shared/tests/unit/test_independent_loaders.js
new file mode 100644
index 000000000..20abed27d
--- /dev/null
+++ b/devtools/shared/tests/unit/test_independent_loaders.js
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/**
+ * Ensure that each instance of the Dev Tools loader contains its own loader
+ * instance, and also returns unique objects. This ensures there is no sharing
+ * in place between loaders.
+ */
+function run_test() {
+ let loader1 = new DevToolsLoader();
+ let loader2 = new DevToolsLoader();
+
+ let indent1 = loader1.require("devtools/shared/indentation");
+ let indent2 = loader2.require("devtools/shared/indentation");
+
+ do_check_true(indent1 !== indent2);
+
+ do_check_true(loader1._provider !== loader2._provider);
+ do_check_true(loader1._provider.loader !== loader2._provider.loader);
+}
diff --git a/devtools/shared/tests/unit/test_invisible_loader.js b/devtools/shared/tests/unit/test_invisible_loader.js
new file mode 100644
index 000000000..96a68abc4
--- /dev/null
+++ b/devtools/shared/tests/unit/test_invisible_loader.js
@@ -0,0 +1,60 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { addDebuggerToGlobal } = Cu.import("resource://gre/modules/jsdebugger.jsm", {});
+addDebuggerToGlobal(this);
+
+/**
+ * Ensure that sandboxes created via the Dev Tools loader respect the
+ * invisibleToDebugger flag.
+ */
+function run_test() {
+ visible_loader();
+ invisible_loader();
+}
+
+function visible_loader() {
+ let loader = new DevToolsLoader();
+ loader.invisibleToDebugger = false;
+ loader.require("devtools/shared/indentation");
+
+ let dbg = new Debugger();
+ let sandbox = loader._provider.loader.sharedGlobalSandbox;
+
+ try {
+ dbg.addDebuggee(sandbox);
+ do_check_true(true);
+ } catch (e) {
+ do_throw("debugger could not add visible value");
+ }
+
+ // Check that for common loader used for tabs, promise modules is Promise.jsm
+ // Which is required to support unhandled promises rejection in mochitests
+ const promise = Cu.import("resource://gre/modules/Promise.jsm", {}).Promise;
+ do_check_eq(loader.require("promise"), promise);
+}
+
+function invisible_loader() {
+ let loader = new DevToolsLoader();
+ loader.invisibleToDebugger = true;
+ loader.require("devtools/shared/indentation");
+
+ let dbg = new Debugger();
+ let sandbox = loader._provider.loader.sharedGlobalSandbox;
+
+ try {
+ dbg.addDebuggee(sandbox);
+ do_throw("debugger added invisible value");
+ } catch (e) {
+ do_check_true(true);
+ }
+
+ // But for browser toolbox loader, promise is loaded as a regular modules out
+ // of Promise-backend.js, that to be invisible to the debugger and not step
+ // into it.
+ const promise = loader.require("promise");
+ const promiseModule = loader._provider.loader.modules["resource://gre/modules/Promise-backend.js"];
+ do_check_eq(promise, promiseModule.exports);
+}
diff --git a/devtools/shared/tests/unit/test_isSet.js b/devtools/shared/tests/unit/test_isSet.js
new file mode 100644
index 000000000..f85d6ae3c
--- /dev/null
+++ b/devtools/shared/tests/unit/test_isSet.js
@@ -0,0 +1,25 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test ThreadSafeDevToolsUtils.isSet
+
+function run_test() {
+ const { isSet } = DevToolsUtils;
+
+ equal(isSet(new Set()), true);
+ equal(isSet(new Map()), false);
+ equal(isSet({}), false);
+ equal(isSet("I swear I'm a Set"), false);
+ equal(isSet(5), false);
+
+ const systemPrincipal = Cc["@mozilla.org/systemprincipal;1"]
+ .createInstance(Ci.nsIPrincipal);
+ const sandbox = new Cu.Sandbox(systemPrincipal);
+
+ equal(isSet(Cu.evalInSandbox("new Set()", sandbox)), true);
+ equal(isSet(Cu.evalInSandbox("new Map()", sandbox)), false);
+ equal(isSet(Cu.evalInSandbox("({})", sandbox)), false);
+ equal(isSet(Cu.evalInSandbox("'I swear I\\'m a Set'", sandbox)), false);
+ equal(isSet(Cu.evalInSandbox("5", sandbox)), false);
+}
diff --git a/devtools/shared/tests/unit/test_pluralForm-english.js b/devtools/shared/tests/unit/test_pluralForm-english.js
new file mode 100644
index 000000000..67cd3b712
--- /dev/null
+++ b/devtools/shared/tests/unit/test_pluralForm-english.js
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/**
+ * This unit test makes sure the plural form for Irish Gaeilge is working by
+ * using the makeGetter method instead of using the default language (by
+ * development), English.
+ */
+
+const {PluralForm} = require("devtools/shared/plural-form");
+
+function run_test() {
+ // English has 2 plural forms
+ do_check_eq(2, PluralForm.numForms());
+
+ // Make sure for good inputs, things work as expected
+ for (let num = 0; num <= 200; num++) {
+ do_check_eq(num == 1 ? "word" : "words", PluralForm.get(num, "word;words"));
+ }
+
+ // Not having enough plural forms defaults to the first form
+ do_check_eq("word", PluralForm.get(2, "word"));
+
+ // Empty forms defaults to the first form
+ do_check_eq("word", PluralForm.get(2, "word;"));
+}
diff --git a/devtools/shared/tests/unit/test_pluralForm-makeGetter.js b/devtools/shared/tests/unit/test_pluralForm-makeGetter.js
new file mode 100644
index 000000000..a9d4928b1
--- /dev/null
+++ b/devtools/shared/tests/unit/test_pluralForm-makeGetter.js
@@ -0,0 +1,38 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+/**
+ * This unit test makes sure the plural form for Irish Gaeilge is working by
+ * using the makeGetter method instead of using the default language (by
+ * development), English.
+ */
+
+const {PluralForm} = require("devtools/shared/plural-form");
+
+function run_test() {
+ // Irish is plural rule #11
+ let [get, numForms] = PluralForm.makeGetter(11);
+
+ // Irish has 5 plural forms
+ do_check_eq(5, numForms());
+
+ // I don't really know Irish, so I'll stick in some dummy text
+ let words = "is 1;is 2;is 3-6;is 7-10;everything else";
+
+ let test = function (text, low, high) {
+ for (let num = low; num <= high; num++) {
+ do_check_eq(text, get(num, words));
+ }
+ };
+
+ // Make sure for good inputs, things work as expected
+ test("everything else", 0, 0);
+ test("is 1", 1, 1);
+ test("is 2", 2, 2);
+ test("is 3-6", 3, 6);
+ test("is 7-10", 7, 10);
+ test("everything else", 11, 200);
+}
diff --git a/devtools/shared/tests/unit/test_prettifyCSS.js b/devtools/shared/tests/unit/test_prettifyCSS.js
new file mode 100644
index 000000000..8415c9b83
--- /dev/null
+++ b/devtools/shared/tests/unit/test_prettifyCSS.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test prettifyCSS.
+
+"use strict";
+
+const {prettifyCSS} = require("devtools/shared/inspector/css-logic");
+
+const TESTS = [
+ { name: "simple test",
+ input: "div { font-family:'Arial Black', Arial, sans-serif; }",
+ expected: [
+ "div {",
+ "\tfont-family:'Arial Black', Arial, sans-serif;",
+ "}"
+ ]
+ },
+
+ { name: "whitespace before open brace",
+ input: "div{}",
+ expected: [
+ "div {",
+ "}"
+ ]
+ },
+
+ { name: "minified with trailing newline",
+ input: "\nbody{background:white;}div{font-size:4em;color:red}span{color:green;}\n",
+ expected: [
+ "body {",
+ "\tbackground:white;",
+ "}",
+ "div {",
+ "\tfont-size:4em;",
+ "\tcolor:red",
+ "}",
+ "span {",
+ "\tcolor:green;",
+ "}"
+ ]
+ },
+
+ { name: "leading whitespace",
+ input: "\n div{color: red;}",
+ expected: [
+ "div {",
+ "\tcolor: red;",
+ "}"
+ ]
+ },
+];
+
+function run_test() {
+ // Note that prettifyCSS.LINE_SEPARATOR is computed lazily, so we
+ // ensure it is set.
+ prettifyCSS("");
+
+ for (let test of TESTS) {
+ do_print(test.name);
+
+ let input = test.input.split("\n").join(prettifyCSS.LINE_SEPARATOR);
+ let output = prettifyCSS(input);
+ let expected = test.expected.join(prettifyCSS.LINE_SEPARATOR) +
+ prettifyCSS.LINE_SEPARATOR;
+ equal(output, expected, test.name);
+ }
+}
diff --git a/devtools/shared/tests/unit/test_require.js b/devtools/shared/tests/unit/test_require.js
new file mode 100644
index 000000000..005e56656
--- /dev/null
+++ b/devtools/shared/tests/unit/test_require.js
@@ -0,0 +1,20 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test require
+
+// Ensure that DevtoolsLoader.require doesn't spawn multiple
+// loader/modules when early cached
+function testBug1091706() {
+ let loader = new DevToolsLoader();
+ let require = loader.require;
+
+ let indent1 = require("devtools/shared/indentation");
+ let indent2 = require("devtools/shared/indentation");
+
+ do_check_true(indent1 === indent2);
+}
+
+function run_test() {
+ testBug1091706();
+}
diff --git a/devtools/shared/tests/unit/test_require_lazy.js b/devtools/shared/tests/unit/test_require_lazy.js
new file mode 100644
index 000000000..8ef5a7d23
--- /dev/null
+++ b/devtools/shared/tests/unit/test_require_lazy.js
@@ -0,0 +1,32 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test devtools.lazyRequireGetter
+
+function run_test() {
+ const name = "asyncUtils";
+ const path = "devtools/shared/async-utils";
+ const o = {};
+ devtools.lazyRequireGetter(o, name, path);
+ const asyncUtils = require(path);
+ // XXX: do_check_eq only works on primitive types, so we have this
+ // do_check_true of an equality expression.
+ do_check_true(o.asyncUtils === asyncUtils);
+
+ // A non-main loader should get a new object via |lazyRequireGetter|, just
+ // as it would via a direct |require|.
+ const o2 = {};
+ let loader = new DevToolsLoader();
+
+ // We have to init the loader by loading any module before lazyRequireGetter is available
+ loader.require("devtools/shared/DevToolsUtils");
+
+ loader.lazyRequireGetter(o2, name, path);
+ do_check_true(o2.asyncUtils !== asyncUtils);
+
+ // A module required via a non-main loader that then uses |lazyRequireGetter|
+ // should also get the same object from that non-main loader.
+ let exposeLoader = loader.require("xpcshell-test/exposeLoader");
+ const o3 = exposeLoader.exerciseLazyRequire(name, path);
+ do_check_true(o3.asyncUtils === o2.asyncUtils);
+}
diff --git a/devtools/shared/tests/unit/test_require_raw.js b/devtools/shared/tests/unit/test_require_raw.js
new file mode 100644
index 000000000..5bec82b55
--- /dev/null
+++ b/devtools/shared/tests/unit/test_require_raw.js
@@ -0,0 +1,19 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test require using "raw!".
+
+function run_test() {
+ let loader = new DevToolsLoader();
+ let require = loader.require;
+
+ let variableFileContents = require("raw!devtools/client/themes/variables.css");
+ ok(variableFileContents.length > 0, "raw browserRequire worked");
+
+ let propertiesFileContents = require("raw!devtools/client/locales/shared.properties");
+ ok(propertiesFileContents.length > 0, "unprefixed properties raw require worked");
+
+ let chromePropertiesFileContents =
+ require("raw!chrome://devtools/locale/shared.properties");
+ ok(chromePropertiesFileContents.length > 0, "prefixed properties raw require worked");
+}
diff --git a/devtools/shared/tests/unit/test_safeErrorString.js b/devtools/shared/tests/unit/test_safeErrorString.js
new file mode 100644
index 000000000..9892f34d1
--- /dev/null
+++ b/devtools/shared/tests/unit/test_safeErrorString.js
@@ -0,0 +1,58 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test DevToolsUtils.safeErrorString
+
+function run_test() {
+ test_with_error();
+ test_with_tricky_error();
+ test_with_string();
+ test_with_thrower();
+ test_with_psychotic();
+}
+
+function test_with_error() {
+ let s = DevToolsUtils.safeErrorString(new Error("foo bar"));
+ // Got the message.
+ do_check_true(s.includes("foo bar"));
+ // Got the stack.
+ do_check_true(s.includes("test_with_error"));
+ do_check_true(s.includes("test_safeErrorString.js"));
+ // Got the lineNumber and columnNumber.
+ do_check_true(s.includes("Line"));
+ do_check_true(s.includes("column"));
+}
+
+function test_with_tricky_error() {
+ let e = new Error("batman");
+ e.stack = { toString: Object.create(null) };
+ let s = DevToolsUtils.safeErrorString(e);
+ // Still got the message, despite a bad stack property.
+ do_check_true(s.includes("batman"));
+}
+
+function test_with_string() {
+ let s = DevToolsUtils.safeErrorString("not really an error");
+ // Still get the message.
+ do_check_true(s.includes("not really an error"));
+}
+
+function test_with_thrower() {
+ let s = DevToolsUtils.safeErrorString({
+ toString: () => {
+ throw new Error("Muahahaha");
+ }
+ });
+ // Still don't fail, get string back.
+ do_check_eq(typeof s, "string");
+}
+
+function test_with_psychotic() {
+ let s = DevToolsUtils.safeErrorString({
+ toString: () => Object.create(null)
+ });
+ // Still get a string out, and no exceptions thrown
+ do_check_eq(typeof s, "string");
+ do_check_eq(s, "[object Object]");
+}
diff --git a/devtools/shared/tests/unit/test_stack.js b/devtools/shared/tests/unit/test_stack.js
new file mode 100644
index 000000000..ef747c83f
--- /dev/null
+++ b/devtools/shared/tests/unit/test_stack.js
@@ -0,0 +1,45 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+// Test stack.js.
+
+function run_test() {
+ let loader = new DevToolsLoader();
+ let require = loader.require;
+
+ const {StackFrameCache} = require("devtools/server/actors/utils/stack");
+
+ let cache = new StackFrameCache();
+ cache.initFrames();
+ let baseFrame = {
+ line: 23,
+ column: 77,
+ source: "nowhere",
+ functionDisplayName: "nobody",
+ parent: null,
+ asyncParent: null,
+ asyncCause: null
+ };
+ cache.addFrame(baseFrame);
+
+ let event = cache.makeEvent();
+ do_check_eq(event[0], null);
+ do_check_eq(event[1].functionDisplayName, "nobody");
+ do_check_eq(event.length, 2);
+
+ cache.addFrame({
+ line: 24,
+ column: 78,
+ source: "nowhere",
+ functionDisplayName: "still nobody",
+ parent: null,
+ asyncParent: baseFrame,
+ asyncCause: "async"
+ });
+
+ event = cache.makeEvent();
+ do_check_eq(event[0].functionDisplayName, "still nobody");
+ do_check_eq(event[0].parent, 0);
+ do_check_eq(event[0].asyncParent, 1);
+ do_check_eq(event.length, 1);
+}
diff --git a/devtools/shared/tests/unit/xpcshell.ini b/devtools/shared/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..d0323c813
--- /dev/null
+++ b/devtools/shared/tests/unit/xpcshell.ini
@@ -0,0 +1,40 @@
+[DEFAULT]
+tags = devtools
+head = head_devtools.js
+tail =
+firefox-appdir = browser
+skip-if = toolkit == 'android'
+support-files =
+ exposeLoader.js
+
+[test_assert.js]
+[test_csslexer.js]
+[test_css-properties-db.js]
+# This test only enforces that the CSS database is up to date with nightly. The DB is
+# only used when inspecting a target that doesn't support the getCSSDatabase actor.
+# CSS properties are behind compile-time flags, and there is no automatic rebuild
+# process for uplifts, so this test breaks on uplift.
+run-if = nightly_build
+[test_fetch-bom.js]
+[test_fetch-chrome.js]
+[test_fetch-file.js]
+[test_fetch-http.js]
+[test_fetch-resource.js]
+[test_flatten.js]
+[test_indentation.js]
+[test_independent_loaders.js]
+[test_invisible_loader.js]
+[test_isSet.js]
+[test_safeErrorString.js]
+[test_defineLazyPrototypeGetter.js]
+[test_async-utils.js]
+[test_console_filtering.js]
+[test_pluralForm-english.js]
+[test_pluralForm-makeGetter.js]
+[test_prettifyCSS.js]
+[test_require_lazy.js]
+[test_require_raw.js]
+[test_require.js]
+[test_stack.js]
+[test_defer.js]
+[test_executeSoon.js]