test_performance_observer.js (8383B)
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");