dom/performance/tests/test_performance_observer.js

   1 test(t => {
   2   assert_throws(
   3     { name: "TypeError" },
   4     function () {
   5       new PerformanceObserver();
   6     },
   7     "PerformanceObserver constructor should throw TypeError if no argument is specified."
   8   );
   9
  10   assert_throws(
  11     { name: "TypeError" },
  12     function () {
  13       new PerformanceObserver({});
  14     },
  15     "PerformanceObserver constructor should throw TypeError if the argument is not a function."
  16   );
  17 }, "Test that PerformanceObserver constructor throws exception");
  18
  19 test(t => {
  20   var observer = new PerformanceObserver(() => {});
  21
  22   assert_throws(
  23     { name: "TypeError" },
  24     function () {
  25       observer.observe();
  26     },
  27     "observe() should throw TypeError exception if no option specified."
  28   );
  29
  30   assert_throws(
  31     { name: "TypeError" },
  32     function () {
  33       observer.observe({ unsupportedAttribute: "unsupported" });
  34     },
  35     "obsrve() should throw TypeError exception if the option has no 'entryTypes' attribute."
  36   );
  37
  38   assert_equals(
  39     undefined,
  40     observer.observe({ entryTypes: [] }),
  41     "observe() should silently ignore empty 'entryTypes' sequence."
  42   );
  43
  44   assert_throws(
  45     { name: "TypeError" },
  46     function () {
  47       observer.observe({ entryTypes: null });
  48     },
  49     "obsrve() should throw TypeError exception if 'entryTypes' attribute is null."
  50   );
  51
  52   assert_equals(
  53     undefined,
  54     observer.observe({ entryTypes: ["invalid"] }),
  55     "observe() should silently ignore invalid 'entryTypes' values."
  56   );
  57 }, "Test that PerformanceObserver.observe throws exception");
  58
  59 function promiseObserve(test, options) {
  60   return new Promise(resolve => {
  61     performance.clearMarks();
  62     performance.clearMeasures();
  63
  64     var observer = new PerformanceObserver(list => resolve(list));
  65     observer.observe(options);
  66     test.add_cleanup(() => observer.disconnect());
  67   });
  68 }
  69
  70 promise_test(t => {
  71   var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
  72
  73   performance.mark("test-start");
  74   performance.mark("test-end");
  75   performance.measure("test-measure", "test-start", "test-end");
  76
  77   return promise.then(list => {
  78     assert_equals(
  79       list.getEntries().length,
  80       3,
  81       "There should be three observed entries."
  82     );
  83
  84     var markEntries = list.getEntries().filter(entry => {
  85       return entry.entryType == "mark";
  86     });
  87     assert_array_equals(
  88       markEntries,
  89       performance.getEntriesByType("mark"),
  90       "Observed 'mark' entries should equal to entries obtained by getEntriesByType."
  91     );
  92
  93     var measureEntries = list.getEntries().filter(entry => {
  94       return entry.entryType == "measure";
  95     });
  96     assert_array_equals(
  97       measureEntries,
  98       performance.getEntriesByType("measure"),
  99       "Observed 'measure' entries should equal to entries obtained by getEntriesByType."
 100     );
 101   });
 102 }, "Test for user-timing with PerformanceObserver");
 103
 104 promise_test(t => {
 105   var promise = new Promise((resolve, reject) => {
 106     performance.clearMarks();
 107     performance.clearMeasures();
 108
 109     var observer = new PerformanceObserver(list => reject(list));
 110     observer.observe({ entryTypes: ["mark", "measure"] });
 111     observer.disconnect();
 112     t.step_timeout(resolve, 100);
 113   });
 114
 115   performance.mark("test-start");
 116   performance.mark("test-end");
 117   performance.measure("test-measure", "test-start", "test-end");
 118
 119   return promise.then(
 120     () => {
 121       assert_equals(performance.getEntriesByType("mark").length, 2);
 122       assert_equals(performance.getEntriesByType("measure").length, 1);
 123     },
 124     list => {
 125       assert_unreached("Observer callback should never be called.");
 126     }
 127   );
 128 }, "Nothing should be notified after disconnecting observer");
 129
 130 promise_test(t => {
 131   var promise = promiseObserve(t, { entryTypes: ["mark"] });
 132
 133   performance.mark("test");
 134
 135   return promise.then(list => {
 136     assert_array_equals(
 137       list.getEntries({ entryType: "mark" }),
 138       performance.getEntriesByType("mark"),
 139       "getEntries with entryType filter should return correct results."
 140     );
 141
 142     assert_array_equals(
 143       list.getEntries({ name: "test" }),
 144       performance.getEntriesByName("test"),
 145       "getEntries with name filter should return correct results."
 146     );
 147
 148     assert_array_equals(
 149       list.getEntries({ name: "test", entryType: "mark" }),
 150       performance.getEntriesByName("test"),
 151       "getEntries with name and entryType filter should return correct results."
 152     );
 153
 154     assert_array_equals(
 155       list.getEntries({ name: "invalid" }),
 156       [],
 157       "getEntries with non-existent name filter should return an empty array."
 158     );
 159
 160     assert_array_equals(
 161       list.getEntries({ name: "test", entryType: "measure" }),
 162       [],
 163       "getEntries with name filter and non-existent entryType should return an empty array."
 164     );
 165
 166     assert_array_equals(
 167       list.getEntries({ name: "invalid", entryType: "mark" }),
 168       [],
 169       "getEntries with non-existent name and entryType filter should return an empty array."
 170     );
 171
 172     assert_array_equals(
 173       list.getEntries({ initiatorType: "xmlhttprequest" }),
 174       [],
 175       "getEntries with initiatorType filter should return an empty array."
 176     );
 177   });
 178 }, "Test for PerformanceObserverEntryList.getEntries");
 179
 180 promise_test(t => {
 181   var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
 182
 183   performance.mark("test");
 184   performance.measure("test-measure", "test", "test");
 185
 186   return promise.then(list => {
 187     assert_array_equals(
 188       list.getEntriesByType("mark"),
 189       performance.getEntriesByType("mark")
 190     );
 191     assert_array_equals(
 192       list.getEntriesByType("measure"),
 193       performance.getEntriesByType("measure")
 194     );
 195   });
 196 }, "Test for PerformanceObserverEntryList.getEntriesByType");
 197
 198 promise_test(t => {
 199   var promise = promiseObserve(t, { entryTypes: ["mark", "measure"] });
 200
 201   performance.mark("test");
 202   performance.measure("test-measure", "test", "test");
 203
 204   return promise.then(list => {
 205     assert_array_equals(
 206       list.getEntriesByName("test"),
 207       performance.getEntriesByName("test")
 208     );
 209     assert_array_equals(
 210       list.getEntriesByName("test-measure"),
 211       performance.getEntriesByName("test-measure")
 212     );
 213   });
 214 }, "Test for PerformanceObserverEntryList.getEntriesByName");
 215
 216 promise_test(t => {
 217   var promise = new Promise(resolve => {
 218     performance.clearMarks();
 219     performance.clearMeasures();
 220
 221     var observer = new PerformanceObserver(list => resolve(list));
 222     observer.observe({ entryTypes: ["mark", "measure"] });
 223     observer.observe({ entryTypes: ["mark", "measure"] });
 224     t.add_cleanup(() => observer.disconnect());
 225   });
 226
 227   performance.mark("test-start");
 228   performance.mark("test-end");
 229   performance.measure("test-measure", "test-start", "test-end");
 230
 231   return promise.then(list => {
 232     assert_equals(
 233       list.getEntries().length,
 234       3,
 235       "Observed user timing entries should have only three entries."
 236     );
 237   });
 238 }, "Test that invoking observe method twice affects nothing");
 239
 240 promise_test(t => {
 241   var promise = new Promise(resolve => {
 242     performance.clearMarks();
 243     performance.clearMeasures();
 244
 245     var observer = new PerformanceObserver(list => resolve(list));
 246     observer.observe({ entryTypes: ["mark", "measure"] });
 247     observer.observe({ entryTypes: ["mark"] });
 248     t.add_cleanup(() => observer.disconnect());
 249   });
 250
 251   performance.mark("test-start");
 252   performance.mark("test-end");
 253   performance.measure("test-measure", "test-start", "test-end");
 254
 255   return promise.then(list => {
 256     assert_equals(
 257       list.getEntries().length,
 258       2,
 259       "Observed user timing entries should have only two entries."
 260     );
 261   });
 262 }, "Test that observing filter is replaced by a new filter");
 263
 264 promise_test(t => {
 265   var promise = new Promise(resolve => {
 266     performance.clearMarks();
 267     performance.clearMeasures();
 268
 269     var observer = new PerformanceObserver(list => resolve(list));
 270     observer.observe({ entryTypes: ["mark"] });
 271     observer.observe({ entryTypes: ["measure"] });
 272     t.add_cleanup(() => observer.disconnect());
 273   });
 274
 275   performance.mark("test-start");
 276   performance.mark("test-end");
 277   performance.measure("test-measure", "test-start", "test-end");
 278
 279   return promise.then(list => {
 280     assert_equals(
 281       list.getEntries().length,
 282       1,
 283       "Observed user timing entries should have only 1 entries."
 284     );
 285   });
 286 }, "Test that observing filter is replaced by a new filter");