Revision 1dcdb61cb2eb054e6d16733d4eb4a6b56793b598 authored by Kenichi Ishibashi on 12 April 2018, 07:12:22 UTC, committed by Blink WPT Bot on 12 April 2018, 07:31:12 UTC
Before this CL, the test expected that preloadResponse is rejected when decoding a chunked body is failed. However preloadResponse is supposed to be resolved once the headers are arrived. It should be resolved instead of rejected. Update the test to expect that preloadResponse is resolved even for broken chunked body. With S13nSW enabled, this test will start passing but it wouldn't pass w/o S13nSW. This CL also adds a test case where broken chunked body is transfered with delays. Bug: 830472 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_mojo Change-Id: Ibc2909dfc4537f209417a13cff63898ad39229a7 Reviewed-on: https://chromium-review.googlesource.com/1004562 Commit-Queue: Kenichi Ishibashi <bashi@chromium.org> Reviewed-by: Matt Falkenhagen <falken@chromium.org> Cr-Commit-Position: refs/heads/master@{#550061}
1 parent 0060eb4
generic-sensor-tests.js
const properties = {
'AmbientLightSensor' : ['timestamp', 'illuminance'],
'Accelerometer' : ['timestamp', 'x', 'y', 'z'],
'LinearAccelerationSensor' : ['timestamp', 'x', 'y', 'z'],
"GravitySensor" : ['timestamp', 'x', 'y', 'z'],
'Gyroscope' : ['timestamp', 'x', 'y', 'z'],
'Magnetometer' : ['timestamp', 'x', 'y', 'z'],
"UncalibratedMagnetometer" : ['timestamp', 'x', 'y', 'z',
'xBias', 'yBias', 'zBias'],
'AbsoluteOrientationSensor' : ['timestamp', 'quaternion'],
'RelativeOrientationSensor' : ['timestamp', 'quaternion'],
'GeolocationSensor' : ['timestamp', 'latitude', 'longitude', 'altitude',
'accuracy', 'altitudeAccuracy', 'heading', 'speed'],
'ProximitySensor' : ['timestamp', 'max']
};
const spatialSensors = ['Accelerometer',
'LinearAccelerationSensor',
'GravitySensor',
'Gyroscope',
'Magnetometer',
'UncalibratedMagnetometer',
'AbsoluteOrientationSensor',
'RelativeOrientationSensor'];
function assert_reading_not_null(sensor) {
for (let property in properties[sensor.constructor.name]) {
let propertyName = properties[sensor.constructor.name][property];
assert_not_equals(sensor[propertyName], null);
}
}
function assert_reading_null(sensor) {
for (let property in properties[sensor.constructor.name]) {
let propertyName = properties[sensor.constructor.name][property];
assert_equals(sensor[propertyName], null);
}
}
function reading_to_array(sensor) {
const arr = new Array();
for (let property in properties[sensor.constructor.name]) {
let propertyName = properties[sensor.constructor.name][property];
arr[property] = sensor[propertyName];
}
return arr;
}
function runGenericSensorTests(sensorType) {
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
sensor.start();
await sensorWatcher.wait_for("reading");
assert_reading_not_null(sensor);
assert_true(sensor.hasReading);
sensor.stop();
assert_reading_null(sensor);
assert_false(sensor.hasReading);
}, `${sensorType.name}: Test that 'onreading' is called and sensor reading is valid`);
promise_test(async t => {
const sensor1 = new sensorType();
const sensor2 = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor1, ["reading", "error"]);
sensor2.start();
sensor1.start();
await sensorWatcher.wait_for("reading");
// Reading values are correct for both sensors.
assert_reading_not_null(sensor1);
assert_reading_not_null(sensor2);
//After first sensor stops its reading values are null,
//reading values for the second sensor remains
sensor1.stop();
assert_reading_null(sensor1);
assert_reading_not_null(sensor2);
sensor2.stop();
assert_reading_null(sensor2);
}, `${sensorType.name}: sensor reading is correct`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
sensor.start();
await sensorWatcher.wait_for("reading");
const cachedTimeStamp1 = sensor.timestamp;
await sensorWatcher.wait_for("reading");
const cachedTimeStamp2 = sensor.timestamp;
assert_greater_than(cachedTimeStamp2, cachedTimeStamp1);
sensor.stop();
}, `${sensorType.name}: sensor timestamp is updated when time passes`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["activate", "error"]);
assert_false(sensor.activated);
sensor.start();
assert_false(sensor.activated);
await sensorWatcher.wait_for("activate");
assert_true(sensor.activated);
sensor.stop();
assert_false(sensor.activated);
}, `${sensorType.name}: Test that sensor can be successfully created and its states are correct.`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["activate", "error"]);
const start_return = sensor.start();
await sensorWatcher.wait_for("activate");
assert_equals(start_return, undefined);
sensor.stop();
}, `${sensorType.name}: sensor.start() returns undefined`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["activate", "error"]);
sensor.start();
sensor.start();
await sensorWatcher.wait_for("activate");
assert_true(sensor.activated);
sensor.stop();
}, `${sensorType.name}: no exception is thrown when calling start() on already started sensor`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["activate", "error"]);
sensor.start();
await sensorWatcher.wait_for("activate");
const stop_return = sensor.stop();
assert_equals(stop_return, undefined);
}, `${sensorType.name}: sensor.stop() returns undefined`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["activate", "error"]);
sensor.start();
await sensorWatcher.wait_for("activate");
sensor.stop();
sensor.stop();
assert_false(sensor.activated);
}, `${sensorType.name}: no exception is thrown when calling stop() on already stopped sensor`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
sensor.start();
await sensorWatcher.wait_for("reading");
assert_true(sensor.hasReading);
const timestamp = sensor.timestamp;
sensor.stop();
assert_false(sensor.hasReading);
sensor.start();
await sensorWatcher.wait_for("reading");
assert_true(sensor.hasReading);
assert_greater_than(timestamp, 0);
assert_greater_than(sensor.timestamp, timestamp);
sensor.stop();
}, `${sensorType.name}: Test that fresh reading is fetched on start()`);
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
const visibilityChangeWatcher = new EventWatcher(t, document, "visibilitychange");
sensor.start();
await sensorWatcher.wait_for("reading");
assert_reading_not_null(sensor);
const cachedSensor1 = reading_to_array(sensor);
const win = window.open('', '_blank');
await visibilityChangeWatcher.wait_for("visibilitychange");
const cachedSensor2 = reading_to_array(sensor);
win.close();
sensor.stop();
assert_object_equals(cachedSensor1, cachedSensor2);
}, `${sensorType.name}: sensor readings can not be fired on the background tab`);
promise_test(async t => {
const fastSensor = new sensorType({frequency: 30});
const slowSensor = new sensorType({frequency: 5});
slowSensor.start();
const fastCounter = await new Promise((resolve, reject) => {
let fastCounter = 0;
let slowCounter = 0;
fastSensor.onreading = () => {
fastCounter++;
}
slowSensor.onreading = () => {
slowCounter++;
if (slowCounter == 1) {
fastSensor.start();
} else if (slowCounter == 3) {
fastSensor.stop();
slowSensor.stop();
resolve(fastCounter);
}
}
fastSensor.onerror = reject;
slowSensor.onerror = reject;
});
assert_greater_than(fastCounter, 2,
"Fast sensor overtakes the slow one");
}, `${sensorType.name}: frequency hint works`);
promise_test(async t => {
// Create a focused editbox inside a cross-origin iframe,
// sensor notification must suspend.
const iframeSrc = 'data:text/html;charset=utf-8,<html><body>'
+ '<input type="text" autofocus></body></html>';
const iframe = document.createElement('iframe');
iframe.src = encodeURI(iframeSrc);
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
sensor.start();
await sensorWatcher.wait_for("reading");
assert_reading_not_null(sensor);
const cachedTimestamp = sensor.timestamp;
const cachedSensor1 = reading_to_array(sensor);
const iframeWatcher = new EventWatcher(t, iframe, "load");
document.body.appendChild(iframe);
await iframeWatcher.wait_for("load");
const cachedSensor2 = reading_to_array(sensor);
assert_array_equals(cachedSensor1, cachedSensor2);
iframe.remove();
await sensorWatcher.wait_for("reading");
const cachedSensor3 = reading_to_array(sensor);
assert_greater_than(sensor.timestamp, cachedTimestamp);
sensor.stop();
}, `${sensorType.name}: sensor receives suspend / resume notifications when\
cross-origin subframe is focused`);
test(() => {
assert_throws("NotSupportedError", () => { new sensorType({invalid: 1}) });
assert_throws("NotSupportedError", () => { new sensorType({frequency: 60, invalid: 1}) });
if (spatialSensors.indexOf(sensorType.name) == -1) {
assert_throws("NotSupportedError", () => { new sensorType({referenceFrame: "screen"}) });
}
}, `${sensorType.name}: throw 'NotSupportedError' for an unsupported sensor option`);
test(() => {
const invalidFreqs = [
"invalid",
NaN,
Infinity,
-Infinity,
{},
undefined
];
invalidFreqs.map(freq => {
assert_throws(new TypeError(),
() => { new sensorType({frequency: freq}) },
`when freq is ${freq}`);
});
}, `${sensorType.name}: throw 'TypeError' if frequency is invalid`);
if (spatialSensors.indexOf(sensorType.name) == -1) {
// The sensorType does not represent a spatial sensor.
return;
}
promise_test(async t => {
const sensor = new sensorType({referenceFrame: "screen"});
const sensorWatcher = new EventWatcher(t, sensor, ["reading", "error"]);
sensor.start();
await sensorWatcher.wait_for("reading");
//TODO use mock data to verify sensor readings, blocked by issue:
// https://github.com/w3c/web-platform-tests/issues/9686
assert_reading_not_null(sensor);
sensor.stop();
}, `${sensorType.name}: sensor reading is correct when options.referenceFrame is 'screen'`);
test(() => {
const invalidRefFrames = [
"invalid",
null,
123,
{},
"",
true,
undefined
];
invalidRefFrames.map(refFrame => {
assert_throws(new TypeError(),
() => { new sensorType({referenceFrame: refFrame}) },
`when refFrame is ${refFrame}`);
});
}, `${sensorType.name}: throw 'TypeError' if referenceFrame is not one of enumeration values`);
}
function runGenericSensorInsecureContext(sensorType) {
test(() => {
assert_false(sensorType in window, `${sensorType} must not be exposed`);
}, `${sensorType} is not exposed in an insecure context`);
}
function runGenericSensorOnerror(sensorType) {
promise_test(async t => {
const sensor = new sensorType();
const sensorWatcher = new EventWatcher(t, sensor, ["error", "activate"]);
sensor.start();
const event = await sensorWatcher.wait_for("error");
assert_false(sensor.activated);
assert_true(event.error.name == 'NotReadableError' ||
event.error.name == 'NotAllowedError');
}, `${sensorType.name}: 'onerror' event is fired when sensor is not supported`);
}
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...