'use strict';
// Run a set of tests for a given |sensorName|.
// |readingData| is an object with 3 keys, all of which are arrays of arrays:
// 1. "readings". Each value corresponds to one raw reading that will be
// processed by a sensor.
// 2. "expectedReadings". Each value corresponds to the processed value a
// sensor will make available to users (i.e. a capped or rounded value).
// Its length must match |readings|'.
// 3. "expectedRemappedReadings" (optional). Similar to |expectedReadings|, but
// used only by spatial sensors, whose reference frame can change the values
// returned by a sensor.
// Its length should match |readings|'.
// |verificationFunction| is called to verify that a given reading matches a
// value in |expectedReadings|.
// |featurePolicies| represents |sensorName|'s associated sensor feature name.
function runGenericSensorTests(sensorData, readingData) {
validate_sensor_data(sensorData);
validate_reading_data(readingData);
const {sensorName, permissionName, testDriverName, featurePolicyNames} =
sensorData;
const sensorType = self[sensorName];
function sensor_test(func, name, properties) {
promise_test(async t => {
assert_implements(sensorName in self, `${sensorName} is not supported.`);
const readings = new RingBuffer(readingData.readings);
const expectedReadings = new RingBuffer(readingData.expectedReadings);
const expectedRemappedReadings = readingData.expectedRemappedReadings ?
new RingBuffer(readingData.expectedRemappedReadings) :
undefined;
return func(t, readings, expectedReadings, expectedRemappedReadings);
}, name, properties);
}
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'denied');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType;
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['reading', 'error']);
sensor.start();
const event = await sensorWatcher.wait_for('error');
assert_false(sensor.activated);
assert_equals(event.error.name, 'NotAllowedError');
}, `${sensorName}: Test that onerror is sent when permissions are not\
granted.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName, {connected: false});
const sensor = new sensorType;
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['reading', 'error']);
sensor.start();
const event = await sensorWatcher.wait_for('error');
assert_false(sensor.activated);
assert_equals(event.error.name, 'NotReadableError');
}, `${sensorName}: Test that onerror is send when start() call has failed.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType({frequency: 560});
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
const mockSensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
assert_less_than_equal(mockSensorInfo.requestedSamplingFrequency, 60);
}, `${sensorName}: Test that frequency is capped to allowed maximum.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
const maxSupportedFrequency = 5;
await test_driver.create_virtual_sensor(
testDriverName, {maxSamplingFrequency: maxSupportedFrequency});
const sensor = new sensorType({frequency: 50});
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
const mockSensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
assert_equals(
mockSensorInfo.requestedSamplingFrequency, maxSupportedFrequency);
}, `${sensorName}: Test that frequency is capped to the maximum supported\
frequency.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
const minSupportedFrequency = 2;
await test_driver.create_virtual_sensor(
testDriverName, {minSamplingFrequency: minSupportedFrequency});
const sensor = new sensorType({frequency: -1});
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
const mockSensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
assert_equals(
mockSensorInfo.requestedSamplingFrequency, minSupportedFrequency);
}, `${sensorName}: Test that frequency is limited to the minimum supported\
frequency.`);
sensor_test(async t => {
const iframe = document.createElement('iframe');
iframe.allow = featurePolicyNames.join(' \'none\'; ') + ' \'none\';';
iframe.srcdoc = '<script>' +
' window.onmessage = message => {' +
' if (message.data === "LOADED") {' +
' try {' +
' new ' + sensorName + '();' +
' parent.postMessage("FAIL", "*");' +
' } catch (e) {' +
' parent.postMessage(`PASS: got ${e.name}`, "*");' +
' }' +
' }' +
' };' +
'<\/script>';
const iframeWatcher = new EventWatcher(t, iframe, 'load');
document.body.appendChild(iframe);
await iframeWatcher.wait_for('load');
iframe.contentWindow.postMessage('LOADED', '*');
const windowWatcher = new EventWatcher(t, window, 'message');
const message = await windowWatcher.wait_for('message');
assert_equals(message.data, 'PASS: got SecurityError');
}, `${sensorName}: Test that sensor cannot be constructed within iframe\
disallowed to use feature policy.`);
sensor_test(async t => {
const iframe = document.createElement('iframe');
iframe.allow = featurePolicyNames.join(';') + ';';
iframe.srcdoc = '<script>' +
' window.onmessage = message => {' +
' if (message.data === "LOADED") {' +
' try {' +
' new ' + sensorName + '();' +
' parent.postMessage("PASS", "*");' +
' } catch (e) {' +
' parent.postMessage("FAIL", "*");' +
' }' +
' }' +
' };' +
'<\/script>';
const iframeWatcher = new EventWatcher(t, iframe, 'load');
document.body.appendChild(iframe);
await iframeWatcher.wait_for('load');
iframe.contentWindow.postMessage('LOADED', '*');
const windowWatcher = new EventWatcher(t, window, 'message');
const message = await windowWatcher.wait_for('message');
assert_equals(message.data, 'PASS');
}, `${sensorName}: Test that sensor can be constructed within an iframe\
allowed to use feature policy.`);
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType;
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher =
new EventWatcher(t, sensor, ['activate', 'reading', 'error']);
sensor.start();
assert_false(sensor.hasReading);
await sensorWatcher.wait_for('activate');
await Promise.all([
test_driver.update_virtual_sensor(testDriverName, readings.next().value),
sensorWatcher.wait_for('reading')
]);
assert_sensor_reading_equals(sensor, expectedReadings.next().value);
assert_true(sensor.hasReading);
sensor.stop();
assert_sensor_reading_is_null(sensor);
assert_false(sensor.hasReading);
}, `${sensorName}: Test that 'onreading' is called and sensor reading is\
valid.`);
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor1 = new sensorType();
const sensor2 = new sensorType();
t.add_cleanup(async () => {
sensor1.stop();
sensor2.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher1 =
new EventWatcher(t, sensor1, ['activate', 'reading', 'error']);
const sensorWatcher2 =
new EventWatcher(t, sensor2, ['activate', 'reading', 'error']);
sensor1.start();
sensor2.start();
await Promise.all([
sensorWatcher1.wait_for('activate'), sensorWatcher2.wait_for('activate')
]);
await Promise.all([
test_driver.update_virtual_sensor(testDriverName, readings.next().value),
sensorWatcher1.wait_for('reading'), sensorWatcher2.wait_for('reading')
]);
// Reading values are correct for both sensors.
const expected = expectedReadings.next().value;
assert_sensor_reading_equals(sensor1, expected);
assert_sensor_reading_equals(sensor2, expected);
// After first sensor stops its reading values are null,
// reading values for the second sensor sensor remain.
sensor1.stop();
assert_sensor_reading_is_null(sensor1);
assert_sensor_reading_equals(sensor2, expected);
sensor2.stop();
assert_sensor_reading_is_null(sensor2);
}, `${sensorName}: sensor reading is correct.`);
// Tests that readings maps to expectedReadings correctly. Due to threshold
// check and rounding some values might be discarded or changed.
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher =
new EventWatcher(t, sensor, ['activate', 'reading', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
const sensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
const sensorPeriodInMs = (1 / sensorInfo.requestedSamplingFrequency) * 1000;
for (let expectedReading of expectedReadings.data) {
await update_virtual_sensor_until_reading(
t, readings, sensorWatcher.wait_for('reading'), testDriverName,
sensorPeriodInMs * 3);
assert_true(sensor.hasReading, 'hasReading');
assert_sensor_reading_equals(sensor, expectedReading);
}
}, `${sensorName}: Test that readings are all mapped to expectedReadings\
correctly.`);
sensor_test(async (t, readings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher =
new EventWatcher(t, sensor, ['activate', 'reading', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
const sensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
const sensorPeriodInMs = (1 / sensorInfo.requestedSamplingFrequency) * 1000;
await Promise.all([
test_driver.update_virtual_sensor(testDriverName, readings.next().value),
sensorWatcher.wait_for('reading')
]);
const cachedTimeStamp1 = sensor.timestamp;
await update_virtual_sensor_until_reading(
t, readings, sensorWatcher.wait_for('reading'), testDriverName,
sensorPeriodInMs * 3);
const cachedTimeStamp2 = sensor.timestamp;
assert_greater_than(cachedTimeStamp2, cachedTimeStamp1);
}, `${sensorName}: sensor timestamp is updated when time passes.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
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);
}, `${sensorName}: Test that sensor can be successfully created and its\
states are correct.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
sensor.start();
await sensorWatcher.wait_for('activate');
assert_true(sensor.activated);
}, `${sensorName}: no exception is thrown when calling start() on already\
started sensor.`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
sensor.stop();
sensor.stop();
assert_false(sensor.activated);
}, `${sensorName}: no exception is thrown when calling stop() on already\
stopped sensor.`);
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher =
new EventWatcher(t, sensor, ['activate', 'reading', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
await Promise.all([
test_driver.update_virtual_sensor(testDriverName, readings.next().value),
sensorWatcher.wait_for('reading')
]);
assert_true(sensor.hasReading);
const expected = expectedReadings.next().value;
assert_sensor_reading_equals(sensor, expected);
const timestamp = sensor.timestamp;
sensor.stop();
assert_false(sensor.hasReading);
assert_false(sensor.activated);
readings.reset();
await test_driver.update_virtual_sensor(
testDriverName, readings.next().value);
sensor.start();
// Starting |sensor| again will cause the backing virtual sensor to report
// the previous reading automatically.
await sensorWatcher.wait_for('activate');
await sensorWatcher.wait_for('reading');
assert_sensor_reading_equals(sensor, expected);
// Make sure that 'timestamp' is already initialized.
assert_greater_than(timestamp, 0);
// Check that the reading is updated.
assert_greater_than(sensor.timestamp, timestamp);
}, `${sensorName}: Test that fresh reading is fetched on start().`);
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor = new sensorType();
t.add_cleanup(async () => {
sensor.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']);
sensor.start();
await sensorWatcher.wait_for('activate');
assert_false(sensor.hasReading);
assert_sensor_reading_is_null(sensor);
const {minimize, restore} = window_state_context(t);
await minimize();
assert_true(document.hidden);
assert_true(sensor.activated);
assert_false(sensor.hasReading);
assert_sensor_reading_is_null(sensor);
const hiddenEventPromise = new Promise(resolve => {
sensor.addEventListener('reading', t.step_func((event) => {
assert_false(document.hidden);
resolve(event);
}, {once: true}));
});
const reading = readings.next().value;
await test_driver.update_virtual_sensor(testDriverName, reading);
const visibilityChangeEventPromise =
new EventWatcher(t, document, 'visibilitychange')
.wait_for('visibilitychange');
const preRestoreTimestamp = performance.now();
await restore();
const readingEvent = await hiddenEventPromise;
assert_false(document.hidden);
assert_true(sensor.activated);
assert_true(sensor.hasReading);
assert_sensor_reading_equals(sensor, expectedReadings.next().value);
// Check that a reading sent while the page is hidden is stashed and
// triggers an update only when it is visible again: the original timestamp
// remains, but the event is emitted only after the "visibilitychange"
// event is fired.
assert_less_than(
sensor.timestamp, preRestoreTimestamp,
'Original sensor timestamp is used even if the update is delayed');
assert_greater_than(
readingEvent.timeStamp, (await visibilityChangeEventPromise).timeStamp,
'Sensor "reading" event is always emitted after page visibility is restored');
}, `${sensorName}: Readings are not delivered when the page has no visibility`);
sensor_test(async t => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const fastSensor = new sensorType({frequency: 60});
t.add_cleanup(() => {
fastSensor.stop();
});
let eventWatcher = new EventWatcher(t, fastSensor, ['activate']);
fastSensor.start();
// Wait for |fastSensor| to be activated so that the call to
// getSamplingFrequency() below works.
await eventWatcher.wait_for('activate');
let mockSensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
// We need |fastSensorFrequency| because 60Hz might be higher than a sensor
// type's maximum allowed frequency.
const fastSensorFrequency = mockSensorInfo.requestedSamplingFrequency;
const slowSensorFrequency = fastSensorFrequency * 0.25;
const slowSensor = new sensorType({frequency: slowSensorFrequency});
t.add_cleanup(() => {
slowSensor.stop();
});
t.add_cleanup(async () => {
// Remove the virtual sensor only after calling stop() on both sensors.
await test_driver.remove_virtual_sensor(testDriverName);
});
eventWatcher = new EventWatcher(t, slowSensor, 'activate');
slowSensor.start();
// Wait for |slowSensor| to be activated before we check if the mock
// platform sensor's sampling frequency has changed.
await eventWatcher.wait_for('activate');
mockSensorInfo =
await test_driver.get_virtual_sensor_information(testDriverName);
assert_equals(
mockSensorInfo.requestedSamplingFrequency, fastSensorFrequency);
// Now stop |fastSensor| and verify that the sampling frequency has dropped
// to the one |slowSensor| had requested.
fastSensor.stop();
await wait_for_virtual_sensor_state(testDriverName, (info) => {
return info.requestedSamplingFrequency === slowSensorFrequency;
});
}, `${sensorName}: frequency hint works.`);
sensor_test(async (t, readings, expectedReadings) => {
await test_driver.set_permission({name: permissionName}, 'granted');
await test_driver.create_virtual_sensor(testDriverName);
const sensor1 = new sensorType();
const sensor2 = new sensorType();
t.add_cleanup(async () => {
sensor1.stop();
sensor2.stop();
await test_driver.remove_virtual_sensor(testDriverName);
});
return new Promise(async (resolve, reject) => {
sensor1.addEventListener('reading', () => {
sensor2.addEventListener('activate', () => {
try {
assert_true(sensor1.activated);
assert_true(sensor1.hasReading);
const expected = expectedReadings.next().value;
assert_sensor_reading_equals(sensor1, expected);
assert_true(sensor2.activated);
assert_sensor_reading_equals(sensor2, expected);
} catch (e) {
reject(e);
}
}, {once: true});
sensor2.addEventListener('reading', () => {
try {
assert_true(sensor2.activated);
assert_true(sensor2.hasReading);
assert_sensor_reading_equals(sensor1, sensor2);
assert_equals(sensor1.timestamp, sensor2.timestamp);
resolve();
} catch (e) {
reject(e);
}
}, {once: true});
sensor2.start();
}, {once: true});
const eventWatcher = new EventWatcher(t, sensor1, ['activate']);
sensor1.start();
await eventWatcher.wait_for('activate');
await test_driver.update_virtual_sensor(
testDriverName, readings.next().value);
});
}, `${sensorName}: Readings delivered by shared platform sensor are\
immediately accessible to all sensors.`);
// Re-enable after https://github.com/w3c/sensors/issues/361 is fixed.
// test(() => {
// assert_throws_dom("NotSupportedError",
// () => { new sensorType({invalid: 1}) });
// assert_throws_dom("NotSupportedError",
// () => { new sensorType({frequency: 60, invalid: 1}) });
// if (!expectedRemappedReadings) {
// assert_throws_dom("NotSupportedError",
// () => { new sensorType({referenceFrame: "screen"}) });
// }
// }, `${sensorName}: throw 'NotSupportedError' for an unsupported sensor\
// option.`);
test(() => {
const invalidFreqs = ['invalid', NaN, Infinity, -Infinity, {}];
invalidFreqs.map(freq => {
assert_throws_js(
TypeError, () => {new sensorType({frequency: freq})},
`when freq is ${freq}`);
});
}, `${sensorName}: throw 'TypeError' if frequency is invalid.`);
if (!readingData.expectedRemappedReadings) {
// The sensorType does not represent a spatial sensor.
return;
}
// TODO(https://github.com/web-platform-tests/wpt/issues/42724): Re-enable
// when there is a cross-platform way to set an orientation angle.
// sensor_test(
// async (t, readings, expectedReadings, expectedRemappedReadings) => {
// assert_implements_optional(screen.orientation.angle == 270,
// 'Remapped values expect a specific screen rotation.');
// await test_driver.set_permission({name: permissionName}, 'granted');
// await test_driver.create_virtual_sensor(testDriverName);
// const sensor1 = new sensorType({frequency: 60});
// const sensor2 =
// new sensorType({frequency: 60, referenceFrame: 'screen'});
// t.add_cleanup(async () => {
// sensor1.stop();
// sensor2.stop();
// await test_driver.remove_virtual_sensor(testDriverName);
// });
// const sensorWatcher1 =
// new EventWatcher(t, sensor1, ['activate', 'reading', 'error']);
// const sensorWatcher2 =
// new EventWatcher(t, sensor1, ['activate', 'reading', 'error']);
// sensor1.start();
// sensor2.start();
// await Promise.all([
// sensorWatcher1.wait_for('activate'),
// sensorWatcher2.wait_for('activate')
// ]);
// await Promise.all([
// test_driver.update_virtual_sensor(testDriverName,
// readings.next().value), sensorWatcher1.wait_for('reading'),
// sensorWatcher2.wait_for('reading')
// ]);
// const expected = expectedReadings.next().value;
// const expectedRemapped = expectedRemappedReadings.next().value;
// assert_sensor_reading_equals(sensor1, expected);
// assert_sensor_reading_equals(sensor2, expectedRemapped);
// sensor1.stop();
// assert_sensor_reading_is_null(sensor1);
// assert_sensor_reading_equals(sensor2, expectedRemapped);
// sensor2.stop();
// assert_sensor_reading_is_null(sensor2);
// },
// `${sensorName}: sensor reading is correct when options.referenceFrame\
// is 'screen'.`);
}
function runGenericSensorInsecureContext(sensorName) {
test(() => {
assert_false(sensorName in window, `${sensorName} must not be exposed`);
}, `${sensorName} is not exposed in an insecure context.`);
}
Codebase Browser
chromium