1 files changed, 286 insertions, 0 deletions
diff --git a/dom/performance/tests/test_performance_observer.js b/dom/performance/tests/test_performance_observer.js
new file mode 100644
index 0000000000..ddc57d4096
--- /dev/null
+++ b/dom/performance/tests/test_performance_observer.js
@@ -0,0 +1,286 @@
+test(t => {
+  assert_throws(
+    { name: "TypeError" },
+    function () {
+      new PerformanceObserver();
+    },
+    "PerformanceObserver constructor should throw TypeError if no argument is specified."
+  );
+
+  assert_throws(
+    { name: "TypeError" },
+    function () {
+      new PerformanceObserver({});
+    },
+    "PerformanceObserver constructor should throw TypeError if the argument is not a function."
+  );
+}, "Test that PerformanceObserver constructor throws exception");
+
+test(t => {
+  var observer = new PerformanceObserver(() => {});
+
+  assert_throws(
+    { name: "TypeError" },
+    function () {
+      observer.observe();
+    },
+    "observe() should throw TypeError exception if no option specified."
+  );
+
+  assert_throws(
+    { name: "TypeError" },
+    function () {
+      observer.observe({ unsupportedAttribute: "unsupported" });
+    },
+    "obsrve() should throw TypeError exception if the option has no 'entryTypes' attribute."
+  );
+
+  assert_equals(
+    undefined,
+    observer.observe({ entryTypes: [] }),
+    "observe() should silently ignore empty 'entryTypes' sequence."
+  );
+
+  assert_throws(
+    { name: "TypeError" },
+    function () {
+      observer.observe({ entryTypes: null });
+    },
+    "obsrve() should throw TypeError exception if 'entryTypes' attribute is null."
+  );
+
+  assert_equals(
+    undefined,
+    observer.observe({ entryTypes: ["invalid"] }),
+    "observe() should silently ignore invalid 'entryTypes' values."
+  );
+}, "Test that PerformanceObserver.observe throws exception");
+
+function promiseObserve(test, options) {
+  return new Promise(resolve => {
+    performance.clearMarks();
+    performance.clearMeasures();
+
+    var observer = new PerformanceObserver(list => resolve(list));
+    observer.observe(options);
+    test.add_cleanup(() => observer.disconnect());
+  });
+}
+
+promise_test(t => {
+  var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
+
+  performance.mark("test-start");
+  performance.mark("test-end");
+  performance.measure("test-measure", "test-start", "test-end");
+
+  return promise.then(list => {
+    assert_equals(
+      list.getEntries().length,
+      3,
+      "There should be three observed entries."
+    );
+
+    var markEntries = list.getEntries().filter(entry => {
+      return entry.entryType == "mark";
+    });
+    assert_array_equals(
+      markEntries,
+      performance.getEntriesByType("mark"),
+      "Observed 'mark' entries should equal to entries obtained by getEntriesByType."
+    );
+
+    var measureEntries = list.getEntries().filter(entry => {
+      return entry.entryType == "measure";
+    });
+    assert_array_equals(
+      measureEntries,
+      performance.getEntriesByType("measure"),
+      "Observed 'measure' entries should equal to entries obtained by getEntriesByType."
+    );
+  });
+}, "Test for user-timing with PerformanceObserver");
+
+promise_test(t => {
+  var promise = new Promise((resolve, reject) => {
+    performance.clearMarks();
+    performance.clearMeasures();
+
+    var observer = new PerformanceObserver(list => reject(list));
+    observer.observe({ entryTypes: ["mark", "measure"] });
+    observer.disconnect();
+    t.step_timeout(resolve, 100);
+  });
+
+  performance.mark("test-start");
+  performance.mark("test-end");
+  performance.measure("test-measure", "test-start", "test-end");
+
+  return promise.then(
+    () => {
+      assert_equals(performance.getEntriesByType("mark").length, 2);
+      assert_equals(performance.getEntriesByType("measure").length, 1);
+    },
+    list => {
+      assert_unreached("Observer callback should never be called.");
+    }
+  );
+}, "Nothing should be notified after disconnecting observer");
+
+promise_test(t => {
+  var promise = promiseObserve(t, { entryTypes: ["mark"] });
+
+  performance.mark("test");
+
+  return promise.then(list => {
+    assert_array_equals(
+      list.getEntries({ entryType: "mark" }),
+      performance.getEntriesByType("mark"),
+      "getEntries with entryType filter should return correct results."
+    );
+
+    assert_array_equals(
+      list.getEntries({ name: "test" }),
+      performance.getEntriesByName("test"),
+      "getEntries with name filter should return correct results."
+    );
+
+    assert_array_equals(
+      list.getEntries({ name: "test", entryType: "mark" }),
+      performance.getEntriesByName("test"),
+      "getEntries with name and entryType filter should return correct results."
+    );
+
+    assert_array_equals(
+      list.getEntries({ name: "invalid" }),
+      [],
+      "getEntries with non-existent name filter should return an empty array."
+    );
+
+    assert_array_equals(
+      list.getEntries({ name: "test", entryType: "measure" }),
+      [],
+      "getEntries with name filter and non-existent entryType should return an empty array."
+    );
+
+    assert_array_equals(
+      list.getEntries({ name: "invalid", entryType: "mark" }),
+      [],
+      "getEntries with non-existent name and entryType filter should return an empty array."
+    );
+
+    assert_array_equals(
+      list.getEntries({ initiatorType: "xmlhttprequest" }),
+      [],
+      "getEntries with initiatorType filter should return an empty array."
+    );
+  });
+}, "Test for PerformanceObserverEntryList.getEntries");
+
+promise_test(t => {
+  var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
+
+  performance.mark("test");
+  performance.measure("test-measure", "test", "test");
+
+  return promise.then(list => {
+    assert_array_equals(
+      list.getEntriesByType("mark"),
+      performance.getEntriesByType("mark")
+    );
+    assert_array_equals(
+      list.getEntriesByType("measure"),
+      performance.getEntriesByType("measure")
+    );
+  });
+}, "Test for PerformanceObserverEntryList.getEntriesByType");
+
+promise_test(t => {
+  var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
+
+  performance.mark("test");
+  performance.measure("test-measure", "test", "test");
+
+  return promise.then(list => {
+    assert_array_equals(
+      list.getEntriesByName("test"),
+      performance.getEntriesByName("test")
+    );
+    assert_array_equals(
+      list.getEntriesByName("test-measure"),
+      performance.getEntriesByName("test-measure")
+    );
+  });
+}, "Test for PerformanceObserverEntryList.getEntriesByName");
+
+promise_test(t => {
+  var promise = new Promise(resolve => {
+    performance.clearMarks();
+    performance.clearMeasures();
+
+    var observer = new PerformanceObserver(list => resolve(list));
+    observer.observe({ entryTypes: ["mark", "measure"] });
+    observer.observe({ entryTypes: ["mark", "measure"] });
+    t.add_cleanup(() => observer.disconnect());
+  });
+
+  performance.mark("test-start");
+  performance.mark("test-end");
+  performance.measure("test-measure", "test-start", "test-end");
+
+  return promise.then(list => {
+    assert_equals(
+      list.getEntries().length,
+      3,
+      "Observed user timing entries should have only three entries."
+    );
+  });
+}, "Test that invoking observe method twice affects nothing");
+
+promise_test(t => {
+  var promise = new Promise(resolve => {
+    performance.clearMarks();
+    performance.clearMeasures();
+
+    var observer = new PerformanceObserver(list => resolve(list));
+    observer.observe({ entryTypes: ["mark", "measure"] });
+    observer.observe({ entryTypes: ["mark"] });
+    t.add_cleanup(() => observer.disconnect());
+  });
+
+  performance.mark("test-start");
+  performance.mark("test-end");
+  performance.measure("test-measure", "test-start", "test-end");
+
+  return promise.then(list => {
+    assert_equals(
+      list.getEntries().length,
+      2,
+      "Observed user timing entries should have only two entries."
+    );
+  });
+}, "Test that observing filter is replaced by a new filter");
+
+promise_test(t => {
+  var promise = new Promise(resolve => {
+    performance.clearMarks();
+    performance.clearMeasures();
+
+    var observer = new PerformanceObserver(list => resolve(list));
+    observer.observe({ entryTypes: ["mark"] });
+    observer.observe({ entryTypes: ["measure"] });
+    t.add_cleanup(() => observer.disconnect());
+  });
+
+  performance.mark("test-start");
+  performance.mark("test-end");
+  performance.measure("test-measure", "test-start", "test-end");
+
+  return promise.then(list => {
+    assert_equals(
+      list.getEntries().length,
+      1,
+      "Observed user timing entries should have only 1 entries."
+    );
+  });
+}, "Test that observing filter is replaced by a new filter");