1 files changed, 378 insertions, 0 deletions
diff --git a/devtools/shared/tests/xpcshell/test_eventemitter_static.js b/devtools/shared/tests/xpcshell/test_eventemitter_static.js
new file mode 100644
index 0000000000..9b17a7612f
--- /dev/null
+++ b/devtools/shared/tests/xpcshell/test_eventemitter_static.js
@@ -0,0 +1,378 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const {
+  ConsoleAPIListener,
+} = require("resource://devtools/server/actors/webconsole/listeners/console-api.js");
+const {
+  on,
+  once,
+  off,
+  emit,
+  count,
+  handler,
+} = require("resource://devtools/shared/event-emitter.js");
+
+const pass = message => ok(true, message);
+const fail = message => ok(false, message);
+
+/**
+ * Each method of this object is a test; tests can be synchronous or asynchronous:
+ *
+ * 1. Plain method are synchronous tests.
+ * 2. methods with `async` keyword are asynchronous tests.
+ * 3. methods with `done` as argument are asynchronous tests (`done` needs to be called to
+ *    complete the test).
+ */
+const TESTS = {
+  testAddListener() {
+    const events = [{ name: "event#1" }, "event#2"];
+    const target = { name: "target" };
+
+    on(target, "message", function (message) {
+      equal(this, target, "this is a target object");
+      equal(message, events.shift(), "message is emitted event");
+    });
+
+    emit(target, "message", events[0]);
+    emit(target, "message", events[0]);
+  },
+
+  testListenerIsUniquePerType() {
+    const actual = [];
+    const target = {};
+    listener = () => actual.push(1);
+
+    on(target, "message", listener);
+    on(target, "message", listener);
+    on(target, "message", listener);
+    on(target, "foo", listener);
+    on(target, "foo", listener);
+
+    emit(target, "message");
+    deepEqual([1], actual, "only one message listener added");
+
+    emit(target, "foo");
+    deepEqual([1, 1], actual, "same listener added for other event");
+  },
+
+  testEventTypeMatters() {
+    const target = { name: "target" };
+    on(target, "message", () => fail("no event is expected"));
+    on(target, "done", () => pass("event is emitted"));
+
+    emit(target, "foo");
+    emit(target, "done");
+  },
+
+  testAllArgumentsArePassed() {
+    const foo = { name: "foo" },
+      bar = "bar";
+    const target = { name: "target" };
+
+    on(target, "message", (a, b) => {
+      equal(a, foo, "first argument passed");
+      equal(b, bar, "second argument passed");
+    });
+
+    emit(target, "message", foo, bar);
+  },
+
+  testNoSideEffectsInEmit() {
+    const target = { name: "target" };
+
+    on(target, "message", () => {
+      pass("first listener is called");
+
+      on(target, "message", () => fail("second listener is called"));
+    });
+    emit(target, "message");
+  },
+
+  testCanRemoveNextListener() {
+    const target = { name: "target" };
+
+    on(target, "data", () => {
+      pass("first listener called");
+      off(target, "data", fail);
+    });
+    on(target, "data", fail);
+
+    emit(target, "data", "Listener should be removed");
+  },
+
+  testOrderOfPropagation() {
+    const actual = [];
+    const target = { name: "target" };
+
+    on(target, "message", () => actual.push(1));
+    on(target, "message", () => actual.push(2));
+    on(target, "message", () => actual.push(3));
+    emit(target, "message");
+
+    deepEqual([1, 2, 3], actual, "called in order they were added");
+  },
+
+  testRemoveListener() {
+    const target = { name: "target" };
+    const actual = [];
+
+    on(target, "message", function listener() {
+      actual.push(1);
+      on(target, "message", () => {
+        off(target, "message", listener);
+        actual.push(2);
+      });
+    });
+
+    emit(target, "message");
+    deepEqual([1], actual, "first listener called");
+
+    emit(target, "message");
+    deepEqual([1, 1, 2], actual, "second listener called");
+
+    emit(target, "message");
+    deepEqual([1, 1, 2, 2, 2], actual, "first listener removed");
+  },
+
+  testRemoveAllListenersForType() {
+    const actual = [];
+    const target = { name: "target" };
+
+    on(target, "message", () => actual.push(1));
+    on(target, "message", () => actual.push(2));
+    on(target, "message", () => actual.push(3));
+    on(target, "bar", () => actual.push("b"));
+    off(target, "message");
+
+    emit(target, "message");
+    emit(target, "bar");
+
+    deepEqual(["b"], actual, "all message listeners were removed");
+  },
+
+  testRemoveAllListeners() {
+    const actual = [];
+    const target = { name: "target" };
+
+    on(target, "message", () => actual.push(1));
+    on(target, "message", () => actual.push(2));
+    on(target, "message", () => actual.push(3));
+    on(target, "bar", () => actual.push("b"));
+
+    off(target);
+
+    emit(target, "message");
+    emit(target, "bar");
+
+    deepEqual([], actual, "all listeners events were removed");
+  },
+
+  testFalsyArgumentsAreFine() {
+    let type, listener;
+    const target = { name: "target" },
+      actual = [];
+    on(target, "bar", () => actual.push(0));
+
+    off(target, "bar", listener);
+    emit(target, "bar");
+    deepEqual([0], actual, "3rd bad arg will keep listener");
+
+    off(target, type);
+    emit(target, "bar");
+    deepEqual([0, 0], actual, "2nd bad arg will keep listener");
+
+    off(target, type, listener);
+    emit(target, "bar");
+    deepEqual([0, 0, 0], actual, "2nd & 3rd bad args will keep listener");
+  },
+
+  testUnhandledExceptions(done) {
+    const listener = new ConsoleAPIListener(null, message => {
+      equal(message.level, "error", "Got the first exception");
+      equal(
+        message.arguments[0].message,
+        "Boom!",
+        "unhandled exception is logged"
+      );
+
+      listener.destroy();
+      done();
+    });
+
+    listener.init();
+
+    const target = {};
+
+    on(target, "message", () => {
+      throw Error("Boom!");
+    });
+
+    emit(target, "message");
+  },
+
+  testCount() {
+    const target = { name: "target" };
+
+    equal(count(target, "foo"), 0, "no listeners for 'foo' events");
+    on(target, "foo", () => {});
+    equal(count(target, "foo"), 1, "listener registered");
+    on(target, "foo", () => {});
+    equal(count(target, "foo"), 2, "another listener registered");
+    off(target);
+    equal(count(target, "foo"), 0, "listeners unregistered");
+  },
+
+  async testOnce() {
+    const target = { name: "target" };
+    const called = false;
+
+    const pFoo = once(target, "foo", function (value) {
+      ok(!called, "listener called only once");
+      equal(value, "bar", "correct argument was passed");
+      equal(this, target, "the contextual object is correct");
+    });
+    const pDone = once(target, "done");
+
+    emit(target, "foo", "bar");
+    emit(target, "foo", "baz");
+    emit(target, "done", "");
+
+    await Promise.all([pFoo, pDone]);
+  },
+
+  testRemovingOnce(done) {
+    const target = { name: "target" };
+
+    once(target, "foo", fail);
+    once(target, "done", done);
+
+    off(target, "foo", fail);
+
+    emit(target, "foo", "listener was called");
+    emit(target, "done", "");
+  },
+
+  testAddListenerWithHandlerMethod() {
+    const target = { name: "target" };
+    const actual = [];
+    const listener = function (...args) {
+      equal(
+        this,
+        target,
+        "the contextual object is correct for function listener"
+      );
+      deepEqual(args, [10, 20, 30], "arguments are properly passed");
+    };
+
+    const object = {
+      name: "target",
+      [handler](type, ...rest) {
+        actual.push(type);
+        equal(
+          this,
+          object,
+          "the contextual object is correct for object listener"
+        );
+        deepEqual(rest, [10, 20, 30], "arguments are properly passed");
+      },
+    };
+
+    on(target, "foo", listener);
+    on(target, "bar", object);
+    on(target, "baz", object);
+
+    emit(target, "foo", 10, 20, 30);
+    emit(target, "bar", 10, 20, 30);
+    emit(target, "baz", 10, 20, 30);
+
+    deepEqual(
+      actual,
+      ["bar", "baz"],
+      "object's listener called in the expected order"
+    );
+  },
+
+  testRemoveListenerWithHandlerMethod() {
+    const target = {};
+    const actual = [];
+
+    const object = {
+      [handler](type) {
+        actual.push(1);
+        on(target, "message", () => {
+          off(target, "message", object);
+          actual.push(2);
+        });
+      },
+    };
+
+    on(target, "message", object);
+
+    emit(target, "message");
+    deepEqual([1], actual, "first listener called");
+
+    emit(target, "message");
+    deepEqual([1, 1, 2], actual, "second listener called");
+
+    emit(target, "message");
+    deepEqual([1, 1, 2, 2, 2], actual, "first listener removed");
+  },
+
+  async testOnceListenerWithHandlerMethod() {
+    const target = { name: "target" };
+    const called = false;
+
+    const object = {
+      [handler](type, value) {
+        ok(!called, "listener called only once");
+        equal(type, "foo", "event type is properly passed");
+        equal(value, "bar", "correct argument was passed");
+        equal(
+          this,
+          object,
+          "the contextual object is correct for object listener"
+        );
+      },
+    };
+
+    const pFoo = once(target, "foo", object);
+
+    const pDone = once(target, "done");
+
+    emit(target, "foo", "bar");
+    emit(target, "foo", "baz");
+    emit(target, "done", "");
+
+    await Promise.all([pFoo, pDone]);
+  },
+
+  testCallingOffWithMoreThan3Args() {
+    const target = { name: "target" };
+    on(target, "data", fail);
+    off(target, "data", fail, undefined);
+    emit(target, "data", "Listener should be removed");
+  },
+};
+
+/**
+ * Create a runnable tests based on the tests descriptor given.
+ *
+ * @param {Object} tests
+ *  The tests descriptor object, contains the tests to run.
+ */
+const runnable = tests =>
+  async function () {
+    for (const name of Object.keys(tests)) {
+      info(name);
+      if (tests[name].length === 1) {
+        await new Promise(resolve => tests[name](resolve));
+      } else {
+        await tests[name]();
+      }
+    }
+  };
+
+add_task(runnable(TESTS));