Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 14:10:11 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 0b22439430b6d8d9a6d43a0908e86c0366f207c0

Browse source
This commit is contained in:
WPT Sync Bot 2019-07-06 10:25:38 +00:00
parent 39ec04a065
commit c8e806d0ef
93 changed files with 2118 additions and 597 deletions
Download patch file Download diff file Expand all files Collapse all files

41
tests/wpt/web-platform-tests/event-timing/bufferbeforeonload.html
View file

@ -27,9 +27,7 @@
firstClickEnd = performance.now();
}
function validateEntries() {
const entries = performance.getEntriesByName('mousedown', 'event');
function validateEntries(entries) {
const entriesBeforeOnload = entries.filter(
e => e.startTime < onloadStart);
assert_equals(entriesBeforeOnload.length, 1,
@ -48,8 +46,8 @@
const entriesAfterOnload = entries.filter(
e => e.startTime >= onloadStart);
assert_equals(entriesAfterOnload.length, 0,
"Events after onload shouldn't be buffered.");
assert_equals(entriesAfterOnload.length, 1,
"Events after onload should still be buffered.");
}
/* Timeline:
@ -66,24 +64,31 @@
async_test(function(t) {
clickTimeMin = performance.now();
clickAndBlockMain('button');
// Use a dummy observer to know when both clicks have been dispatched.
const observerPromise = new Promise((resolve, reject) => {
let entryCount = 0;
new PerformanceObserver(entryList => {
entryCount += entryList.getEntries().filter(
entry => entry.name === 'mousedown').length;
if (entryCount >= 2)
resolve();
}).observe({ entryTypes: ['event'] });
});
// Event handlers will be dispatched asynchronously, so this will be called
// before processing begins.
processingStartMin = performance.now();
const bufferedEntries = [];
on_event(window, 'load', e => {
onloadStart = performance.now();
const clickPromise = clickAndBlockMain('button');
Promise.all([observerPromise, clickPromise]).then(
t.step_func_done(validateEntries));
// Register the observer after the page has been loaded
const observer = new PerformanceObserver(function (entryList, observer) {
entryList.getEntries().forEach(function(entry) {
assert_equals(entry.entryType, "event");
if (entry.name === 'mousedown') {
bufferedEntries.push(entry);
}
if (bufferedEntries.length == 2) {
validateEntries(bufferedEntries)
observer.disconnect();
t.done();
}
});
})
observer.observe({
type: "event",
buffered: true
});
clickAndBlockMain('button');
});
}, "Event Timing: click, onload.");

19
tests/wpt/web-platform-tests/event-timing/observethenonload.html
View file

@ -20,19 +20,6 @@
let onloadStart;
let observedEntries = [];
function verifyBuffer(bufferedEntries) {
assert_equals(bufferedEntries.length, 1,
"Only events before onload should be buffered.");
const entry = bufferedEntries[0];
assert_greater_than(onloadStart, entry.startTime,
"Onload should be later than entry's start time.");
assert_greater_than(entry.processingStart, timeBeforeFirstClick,
"The entry's processing start should be after timeBeforeFirstClick");
assert_less_than(entry.processingStart, timeAfterFirstClick,
"The entry's processing start should be before timeAfterFirstClick.");
verifyClickEvent(entry, true);
}
function verifyObserverEntries(observedEntries) {
const entriesAfterFirstClick = observedEntries.filter(
e => e.startTime > timeAfterFirstClick);
@ -60,6 +47,9 @@
"entry2's processing start should be berfore timeAfterFirstClick.");
assert_greater_than(timeAfterFirstClick, entry2.startTime,
"timeAfterFirstClick should be later than entry2's start time.");
// This should happen before onLoad
assert_greater_than(onloadStart, entry2.startTime,
"Onload should be later than entry's start time.");
}
/* Timeline:
@ -82,7 +72,7 @@
entry => entry.name === 'mousedown'));
if (observedEntries.length < 2) return;
resolve(observedEntries);
}).observe({ entryTypes: ['event'] });
}).observe({ type: 'event' , buffered: true});
});
timeBeforeFirstClick = performance.now();
clickAndBlockMain('button').then( () => {
@ -95,7 +85,6 @@
Promise.all([observerPromise, bufferPromise]).then((results) => {
timeAfterSecondClick = performance.now();
t.step(verifyObserverEntries.bind(null, results[0]));
t.step(verifyBuffer.bind(null, performance.getEntriesByName('mousedown', 'event')));
t.done();
});
});

44
tests/wpt/web-platform-tests/event-timing/onloadthenobserve-firstInput.html
View file

@ -23,30 +23,38 @@
async_test(function(t) {
let numFirstInputObserved = 0;
let numEventsObserved = 0;
new PerformanceObserver(t.step_func((entryList, obs) => {
const observedEntries = entryList.getEntries().filter(
entry => entry.name === 'mousedown');
numEventsObserved += observedEntries.filter(entry =>
entry.entryType == 'event').length;
numFirstInputObserved += observedEntries.filter(entry =>
entry.entryType == 'firstInput').length;
let observedEventEntries = [];
const event_observer_promise = new Promise((resolve, reject) => {
new PerformanceObserver(function(entryList) {
observedEventEntries = entryList.getEntries().filter(
entry => entry.name === 'mousedown');
numEventsObserved += observedEventEntries.length;
if (numEventsObserved >= 2) {
assert_equals(performance.getEntriesByType('event').length, 0,
"There should be no buffered event entries.");
assert_equals(performance.getEntriesByType('firstInput').length, 1,
"There should be a buffered firstInput entry.");
// There should be 2 event entries and one firstInput entry.
// There should be 2 event entries.
assert_equals(numEventsObserved, 2,
"There should be 2 observed event entries.");
assert_equals(numFirstInputObserved, 1,
"There should be only 1 observed firstInput entry.");
t.done();
resolve();
}
})).observe({ entryTypes: ['event', 'firstInput'] });
on_event(window, 'load', () => {
clickAndBlockMain('button').then(() => {
}).observe({ type: 'event' , buffered: true});
});
const first_input_observer_promise = new Promise((resolve, reject) => {
new PerformanceObserver(function(entryList) {
assert_equals(entryList.getEntries().length, 1);
resolve();
}).observe({ type: 'firstInput' , buffered: true});
});
on_event(window, 'load', function(e) {
const click_promise = clickAndBlockMain('button').then(() => {
clickAndBlockMain('button');
});
Promise.all(
[event_observer_promise, first_input_observer_promise, click_promise]
).then(() => {
t.done();
});
});
},
"Event Timing: check firstInput after onload, observer, click, click."

17
tests/wpt/web-platform-tests/event-timing/onloadthenobserve.html
View file

@ -17,16 +17,9 @@ registration are lost
let observerStart;
let processingStartMin;
function verifyBufferAndObserverEntries(observedEntries) {
// Verify buffer entries
const bufferedEntries = performance.getEntriesByName('mousedown', 'event');
const bufferedEntriesBeforeObserver = bufferedEntries.filter(e => e.startTime <
observerStart);
assert_equals(bufferedEntries.length, 0,
"Long latency events after onload should not be buffered."
);
// Verify observer entries
function verifyObserverEntries(observedEntries) {
// Verify observer entries. Should not include first click since we didn't
// buffered to true.
assert_equals(observedEntries.length, 1, "Long latency task after observer start should be observed.");
const entry = observedEntries[0];
verifyClickEvent(entry);
@ -45,8 +38,8 @@ registration are lost
callbackTime = performance.now();
const observedEntries = entryList.getEntries().filter(
entry => entry.name === 'mousedown');
verifyBufferAndObserverEntries(observedEntries);
})).observe({ entryTypes: ['event'] });
verifyObserverEntries(observedEntries);
})).observe({ type: 'event'});
observerStart = performance.now();
}

3
tests/wpt/web-platform-tests/event-timing/resources/crossiframe-childframe.html
View file

@ -2,7 +2,6 @@
<html>
<script src=event-timing-test-utils.js></script>
<button id='button_child_frame'>Generate a 'click' event</button>
<img src=slow-image.py>
<script>
const clickTimeMin = performance.now();
clickAndBlockMain('button_child_frame');
@ -10,7 +9,7 @@
const observerPromise = new Promise((resolve, reject) => {
new PerformanceObserver((entryList) => {
resolve(entryList.getEntries().filter(entry => entry.name === 'mousedown'));
}).observe({ entryTypes: ['event'] });
}).observe({ type:'event', buffered: true });
});
window.addEventListener('load', e => {
observerPromise.then((observedEntries) => {