generic-sensor-tests.js (26641B)
1 'use strict'; 2 3 // Run a set of tests for a given |sensorName|. 4 // |readingData| is an object with 3 keys, all of which are arrays of arrays: 5 // 1. "readings". Each value corresponds to one raw reading that will be 6 // processed by a sensor. 7 // 2. "expectedReadings". Each value corresponds to the processed value a 8 // sensor will make available to users (i.e. a capped or rounded value). 9 // Its length must match |readings|'. 10 // 3. "expectedRemappedReadings" (optional). Similar to |expectedReadings|, but 11 // used only by spatial sensors, whose reference frame can change the values 12 // returned by a sensor. 13 // Its length should match |readings|'. 14 // |verificationFunction| is called to verify that a given reading matches a 15 // value in |expectedReadings|. 16 // |featurePolicies| represents |sensorName|'s associated sensor feature name. 17 function runGenericSensorTests(sensorData, readingData) { 18 validate_sensor_data(sensorData); 19 validate_reading_data(readingData); 20 21 const {sensorName, permissionName, testDriverName, featurePolicyNames} = 22 sensorData; 23 const sensorType = self[sensorName]; 24 25 function sensor_test(func, name, properties) { 26 promise_test(async t => { 27 assert_implements(sensorName in self, `${sensorName} is not supported.`); 28 29 const readings = new RingBuffer(readingData.readings); 30 const expectedReadings = new RingBuffer(readingData.expectedReadings); 31 const expectedRemappedReadings = readingData.expectedRemappedReadings ? 32 new RingBuffer(readingData.expectedRemappedReadings) : 33 undefined; 34 35 return func(t, readings, expectedReadings, expectedRemappedReadings); 36 }, name, properties); 37 } 38 39 promise_setup(async () => { 40 // Ensure window's document has focus so that the global under test can 41 // receive data. 42 await test_driver.click(document.documentElement); 43 }); 44 45 sensor_test(async t => { 46 await test_driver.bidi.permissions.set_permission( 47 {descriptor: {name: permissionName}, state: 'denied'}); 48 49 await test_driver.create_virtual_sensor(testDriverName); 50 const sensor = new sensorType; 51 t.add_cleanup(async () => { 52 sensor.stop(); 53 await test_driver.remove_virtual_sensor(testDriverName); 54 }); 55 const sensorWatcher = new EventWatcher(t, sensor, ['reading', 'error']); 56 sensor.start(); 57 58 const event = await sensorWatcher.wait_for('error'); 59 60 assert_false(sensor.activated); 61 assert_equals(event.error.name, 'NotAllowedError'); 62 }, `${sensorName}: Test that onerror is sent when permissions are not\ 63 granted.`); 64 65 sensor_test(async t => { 66 await test_driver.bidi.permissions.set_permission( 67 {descriptor: {name: permissionName}, state: 'granted'}); 68 69 await test_driver.create_virtual_sensor(testDriverName, {connected: false}); 70 const sensor = new sensorType; 71 t.add_cleanup(async () => { 72 sensor.stop(); 73 await test_driver.remove_virtual_sensor(testDriverName); 74 }); 75 const sensorWatcher = new EventWatcher(t, sensor, ['reading', 'error']); 76 77 sensor.start(); 78 79 const event = await sensorWatcher.wait_for('error'); 80 81 assert_false(sensor.activated); 82 assert_equals(event.error.name, 'NotReadableError'); 83 }, `${sensorName}: Test that onerror is send when start() call has failed.`); 84 85 sensor_test(async t => { 86 await test_driver.bidi.permissions.set_permission( 87 {descriptor: {name: permissionName}, state: 'granted'}); 88 89 await test_driver.create_virtual_sensor(testDriverName); 90 91 const sensor = new sensorType({frequency: 560}); 92 t.add_cleanup(async () => { 93 sensor.stop(); 94 await test_driver.remove_virtual_sensor(testDriverName); 95 }); 96 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 97 sensor.start(); 98 99 await sensorWatcher.wait_for('activate'); 100 const mockSensorInfo = 101 await test_driver.get_virtual_sensor_information(testDriverName); 102 103 assert_less_than_equal(mockSensorInfo.requestedSamplingFrequency, 60); 104 }, `${sensorName}: Test that frequency is capped to allowed maximum.`); 105 106 sensor_test(async t => { 107 await test_driver.bidi.permissions.set_permission( 108 {descriptor: {name: permissionName}, state: 'granted'}); 109 110 const maxSupportedFrequency = 5; 111 await test_driver.create_virtual_sensor( 112 testDriverName, {maxSamplingFrequency: maxSupportedFrequency}); 113 114 const sensor = new sensorType({frequency: 50}); 115 t.add_cleanup(async () => { 116 sensor.stop(); 117 await test_driver.remove_virtual_sensor(testDriverName); 118 }); 119 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 120 sensor.start(); 121 122 await sensorWatcher.wait_for('activate'); 123 const mockSensorInfo = 124 await test_driver.get_virtual_sensor_information(testDriverName); 125 126 assert_equals( 127 mockSensorInfo.requestedSamplingFrequency, maxSupportedFrequency); 128 }, `${sensorName}: Test that frequency is capped to the maximum supported\ 129 frequency.`); 130 131 sensor_test(async t => { 132 await test_driver.bidi.permissions.set_permission( 133 {descriptor: {name: permissionName}, state: 'granted'}); 134 135 const minSupportedFrequency = 2; 136 await test_driver.create_virtual_sensor( 137 testDriverName, {minSamplingFrequency: minSupportedFrequency}); 138 139 const sensor = new sensorType({frequency: -1}); 140 t.add_cleanup(async () => { 141 sensor.stop(); 142 await test_driver.remove_virtual_sensor(testDriverName); 143 }); 144 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 145 sensor.start(); 146 147 await sensorWatcher.wait_for('activate'); 148 const mockSensorInfo = 149 await test_driver.get_virtual_sensor_information(testDriverName); 150 151 assert_equals( 152 mockSensorInfo.requestedSamplingFrequency, minSupportedFrequency); 153 }, `${sensorName}: Test that frequency is limited to the minimum supported\ 154 frequency.`); 155 156 sensor_test(async t => { 157 const iframe = document.createElement('iframe'); 158 iframe.allow = featurePolicyNames.join(' \'none\'; ') + ' \'none\';'; 159 iframe.srcdoc = '<script>' + 160 ' window.onmessage = message => {' + 161 ' if (message.data === "LOADED") {' + 162 ' try {' + 163 ' new ' + sensorName + '();' + 164 ' parent.postMessage("FAIL", "*");' + 165 ' } catch (e) {' + 166 ' parent.postMessage(`PASS: got ${e.name}`, "*");' + 167 ' }' + 168 ' }' + 169 ' };' + 170 '<\/script>'; 171 const iframeWatcher = new EventWatcher(t, iframe, 'load'); 172 document.body.appendChild(iframe); 173 await iframeWatcher.wait_for('load'); 174 iframe.contentWindow.postMessage('LOADED', '*'); 175 176 const windowWatcher = new EventWatcher(t, window, 'message'); 177 const message = await windowWatcher.wait_for('message'); 178 assert_equals(message.data, 'PASS: got SecurityError'); 179 }, `${sensorName}: Test that sensor cannot be constructed within iframe\ 180 disallowed to use feature policy.`); 181 182 sensor_test(async t => { 183 const iframe = document.createElement('iframe'); 184 iframe.allow = featurePolicyNames.join(';') + ';'; 185 iframe.srcdoc = '<script>' + 186 ' window.onmessage = message => {' + 187 ' if (message.data === "LOADED") {' + 188 ' try {' + 189 ' new ' + sensorName + '();' + 190 ' parent.postMessage("PASS", "*");' + 191 ' } catch (e) {' + 192 ' parent.postMessage("FAIL", "*");' + 193 ' }' + 194 ' }' + 195 ' };' + 196 '<\/script>'; 197 const iframeWatcher = new EventWatcher(t, iframe, 'load'); 198 document.body.appendChild(iframe); 199 await iframeWatcher.wait_for('load'); 200 iframe.contentWindow.postMessage('LOADED', '*'); 201 202 const windowWatcher = new EventWatcher(t, window, 'message'); 203 const message = await windowWatcher.wait_for('message'); 204 assert_equals(message.data, 'PASS'); 205 }, `${sensorName}: Test that sensor can be constructed within an iframe\ 206 allowed to use feature policy.`); 207 208 sensor_test(async (t, readings, expectedReadings) => { 209 await test_driver.bidi.permissions.set_permission( 210 {descriptor: {name: permissionName}, state: 'granted'}); 211 212 await test_driver.create_virtual_sensor(testDriverName); 213 214 const sensor = new sensorType; 215 t.add_cleanup(async () => { 216 sensor.stop(); 217 await test_driver.remove_virtual_sensor(testDriverName); 218 }); 219 const sensorWatcher = 220 new EventWatcher(t, sensor, ['activate', 'reading', 'error']); 221 222 sensor.start(); 223 assert_false(sensor.hasReading); 224 await sensorWatcher.wait_for('activate'); 225 226 await Promise.all([ 227 test_driver.update_virtual_sensor(testDriverName, readings.next().value), 228 sensorWatcher.wait_for('reading') 229 ]); 230 231 assert_sensor_reading_equals(sensor, expectedReadings.next().value); 232 233 assert_true(sensor.hasReading); 234 235 sensor.stop(); 236 237 assert_sensor_reading_is_null(sensor); 238 assert_false(sensor.hasReading); 239 }, `${sensorName}: Test that 'onreading' is called and sensor reading is\ 240 valid.`); 241 242 sensor_test(async (t, readings, expectedReadings) => { 243 await test_driver.bidi.permissions.set_permission( 244 {descriptor: {name: permissionName}, state: 'granted'}); 245 246 await test_driver.create_virtual_sensor(testDriverName); 247 248 const sensor1 = new sensorType(); 249 const sensor2 = new sensorType(); 250 t.add_cleanup(async () => { 251 sensor1.stop(); 252 sensor2.stop(); 253 await test_driver.remove_virtual_sensor(testDriverName); 254 }); 255 const sensorWatcher1 = 256 new EventWatcher(t, sensor1, ['activate', 'reading', 'error']); 257 const sensorWatcher2 = 258 new EventWatcher(t, sensor2, ['activate', 'reading', 'error']); 259 sensor1.start(); 260 sensor2.start(); 261 262 await Promise.all([ 263 sensorWatcher1.wait_for('activate'), sensorWatcher2.wait_for('activate') 264 ]); 265 266 await Promise.all([ 267 test_driver.update_virtual_sensor(testDriverName, readings.next().value), 268 sensorWatcher1.wait_for('reading'), sensorWatcher2.wait_for('reading') 269 ]); 270 271 // Reading values are correct for both sensors. 272 const expected = expectedReadings.next().value; 273 assert_sensor_reading_equals(sensor1, expected); 274 assert_sensor_reading_equals(sensor2, expected); 275 276 // After first sensor stops its reading values are null, 277 // reading values for the second sensor sensor remain. 278 sensor1.stop(); 279 assert_sensor_reading_is_null(sensor1); 280 assert_sensor_reading_equals(sensor2, expected); 281 282 sensor2.stop(); 283 assert_sensor_reading_is_null(sensor2); 284 }, `${sensorName}: sensor reading is correct.`); 285 286 // Tests that readings maps to expectedReadings correctly. Due to threshold 287 // check and rounding some values might be discarded or changed. 288 sensor_test(async (t, readings, expectedReadings) => { 289 await test_driver.bidi.permissions.set_permission( 290 {descriptor: {name: permissionName}, state: 'granted'}); 291 292 await test_driver.create_virtual_sensor(testDriverName); 293 294 const sensor = new sensorType(); 295 t.add_cleanup(async () => { 296 sensor.stop(); 297 await test_driver.remove_virtual_sensor(testDriverName); 298 }); 299 const sensorWatcher = 300 new EventWatcher(t, sensor, ['activate', 'reading', 'error']); 301 sensor.start(); 302 303 await sensorWatcher.wait_for('activate'); 304 305 const sensorInfo = 306 await test_driver.get_virtual_sensor_information(testDriverName); 307 const sensorPeriodInMs = (1 / sensorInfo.requestedSamplingFrequency) * 1000; 308 309 for (let expectedReading of expectedReadings.data) { 310 await update_virtual_sensor_until_reading( 311 t, readings, sensorWatcher.wait_for('reading'), testDriverName, 312 sensorPeriodInMs * 3); 313 assert_true(sensor.hasReading, 'hasReading'); 314 assert_sensor_reading_equals(sensor, expectedReading); 315 } 316 }, `${sensorName}: Test that readings are all mapped to expectedReadings\ 317 correctly.`); 318 319 sensor_test(async (t, readings) => { 320 await test_driver.bidi.permissions.set_permission( 321 {descriptor: {name: permissionName}, state: 'granted'}); 322 323 await test_driver.create_virtual_sensor(testDriverName); 324 325 const sensor = new sensorType(); 326 t.add_cleanup(async () => { 327 sensor.stop(); 328 await test_driver.remove_virtual_sensor(testDriverName); 329 }); 330 const sensorWatcher = 331 new EventWatcher(t, sensor, ['activate', 'reading', 'error']); 332 sensor.start(); 333 334 await sensorWatcher.wait_for('activate'); 335 336 const sensorInfo = 337 await test_driver.get_virtual_sensor_information(testDriverName); 338 const sensorPeriodInMs = (1 / sensorInfo.requestedSamplingFrequency) * 1000; 339 340 await Promise.all([ 341 test_driver.update_virtual_sensor(testDriverName, readings.next().value), 342 sensorWatcher.wait_for('reading') 343 ]); 344 const cachedTimeStamp1 = sensor.timestamp; 345 346 await update_virtual_sensor_until_reading( 347 t, readings, sensorWatcher.wait_for('reading'), testDriverName, 348 sensorPeriodInMs * 3); 349 const cachedTimeStamp2 = sensor.timestamp; 350 351 assert_greater_than(cachedTimeStamp2, cachedTimeStamp1); 352 }, `${sensorName}: sensor timestamp is updated when time passes.`); 353 354 sensor_test(async t => { 355 await test_driver.bidi.permissions.set_permission( 356 {descriptor: {name: permissionName}, state: 'granted'}); 357 358 await test_driver.create_virtual_sensor(testDriverName); 359 360 const sensor = new sensorType(); 361 t.add_cleanup(async () => { 362 sensor.stop(); 363 await test_driver.remove_virtual_sensor(testDriverName); 364 }); 365 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 366 assert_false(sensor.activated); 367 sensor.start(); 368 assert_false(sensor.activated); 369 370 await sensorWatcher.wait_for('activate'); 371 assert_true(sensor.activated); 372 373 sensor.stop(); 374 assert_false(sensor.activated); 375 }, `${sensorName}: Test that sensor can be successfully created and its\ 376 states are correct.`); 377 378 sensor_test(async t => { 379 await test_driver.bidi.permissions.set_permission( 380 {descriptor: {name: permissionName}, state: 'granted'}); 381 382 await test_driver.create_virtual_sensor(testDriverName); 383 384 const sensor = new sensorType(); 385 t.add_cleanup(async () => { 386 sensor.stop(); 387 await test_driver.remove_virtual_sensor(testDriverName); 388 }); 389 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 390 sensor.start(); 391 sensor.start(); 392 393 await sensorWatcher.wait_for('activate'); 394 assert_true(sensor.activated); 395 }, `${sensorName}: no exception is thrown when calling start() on already\ 396 started sensor.`); 397 398 sensor_test(async t => { 399 await test_driver.bidi.permissions.set_permission( 400 {descriptor: {name: permissionName}, state: 'granted'}); 401 402 await test_driver.create_virtual_sensor(testDriverName); 403 404 const sensor = new sensorType(); 405 t.add_cleanup(async () => { 406 sensor.stop(); 407 await test_driver.remove_virtual_sensor(testDriverName); 408 }); 409 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 410 sensor.start(); 411 412 await sensorWatcher.wait_for('activate'); 413 sensor.stop(); 414 sensor.stop(); 415 assert_false(sensor.activated); 416 }, `${sensorName}: no exception is thrown when calling stop() on already\ 417 stopped sensor.`); 418 419 sensor_test(async (t, readings, expectedReadings) => { 420 await test_driver.bidi.permissions.set_permission( 421 {descriptor: {name: permissionName}, state: 'granted'}); 422 423 await test_driver.create_virtual_sensor(testDriverName); 424 425 const sensor = new sensorType(); 426 t.add_cleanup(async () => { 427 sensor.stop(); 428 await test_driver.remove_virtual_sensor(testDriverName); 429 }); 430 const sensorWatcher = 431 new EventWatcher(t, sensor, ['activate', 'reading', 'error']); 432 sensor.start(); 433 434 await sensorWatcher.wait_for('activate'); 435 436 await Promise.all([ 437 test_driver.update_virtual_sensor(testDriverName, readings.next().value), 438 sensorWatcher.wait_for('reading') 439 ]); 440 441 assert_true(sensor.hasReading); 442 443 const expected = expectedReadings.next().value; 444 assert_sensor_reading_equals(sensor, expected); 445 446 const timestamp = sensor.timestamp; 447 sensor.stop(); 448 assert_false(sensor.hasReading); 449 assert_false(sensor.activated); 450 451 readings.reset(); 452 await test_driver.update_virtual_sensor( 453 testDriverName, readings.next().value); 454 455 sensor.start(); 456 457 // Starting |sensor| again will cause the backing virtual sensor to report 458 // the previous reading automatically. 459 await sensorWatcher.wait_for('activate'); 460 await sensorWatcher.wait_for('reading'); 461 462 assert_sensor_reading_equals(sensor, expected); 463 // Make sure that 'timestamp' is already initialized. 464 assert_greater_than(timestamp, 0); 465 // Check that the reading is updated. 466 assert_greater_than(sensor.timestamp, timestamp); 467 }, `${sensorName}: Test that fresh reading is fetched on start().`); 468 469 sensor_test(async (t, readings, expectedReadings) => { 470 await test_driver.bidi.permissions.set_permission( 471 {descriptor: {name: permissionName}, state: 'granted'}); 472 473 await test_driver.create_virtual_sensor(testDriverName); 474 475 const sensor = new sensorType(); 476 t.add_cleanup(async () => { 477 sensor.stop(); 478 await test_driver.remove_virtual_sensor(testDriverName); 479 }); 480 const sensorWatcher = new EventWatcher(t, sensor, ['activate', 'error']); 481 482 sensor.start(); 483 await sensorWatcher.wait_for('activate'); 484 485 assert_false(sensor.hasReading); 486 assert_sensor_reading_is_null(sensor); 487 488 const {minimize, restore} = window_state_context(t); 489 490 await minimize(); 491 assert_true(document.hidden); 492 assert_true(sensor.activated); 493 assert_false(sensor.hasReading); 494 assert_sensor_reading_is_null(sensor); 495 496 const hiddenEventPromise = new Promise(resolve => { 497 sensor.addEventListener('reading', t.step_func((event) => { 498 assert_false(document.hidden); 499 resolve(event); 500 }, {once: true})); 501 }); 502 503 const reading = readings.next().value; 504 await test_driver.update_virtual_sensor(testDriverName, reading); 505 506 const visibilityChangeEventPromise = 507 new EventWatcher(t, document, 'visibilitychange') 508 .wait_for('visibilitychange'); 509 510 const preRestoreTimestamp = performance.now(); 511 await restore(); 512 513 const readingEvent = await hiddenEventPromise; 514 515 assert_false(document.hidden); 516 assert_true(sensor.activated); 517 assert_true(sensor.hasReading); 518 assert_sensor_reading_equals(sensor, expectedReadings.next().value); 519 520 // Check that a reading sent while the page is hidden is stashed and 521 // triggers an update only when it is visible again: the original timestamp 522 // remains, but the event is emitted only after the "visibilitychange" 523 // event is fired. 524 assert_less_than( 525 sensor.timestamp, preRestoreTimestamp, 526 'Original sensor timestamp is used even if the update is delayed'); 527 assert_greater_than( 528 readingEvent.timeStamp, (await visibilityChangeEventPromise).timeStamp, 529 'Sensor "reading" event is always emitted after page visibility is restored'); 530 }, `${sensorName}: Readings are not delivered when the page has no visibility`); 531 532 sensor_test(async t => { 533 await test_driver.bidi.permissions.set_permission( 534 {descriptor: {name: permissionName}, state: 'granted'}); 535 536 await test_driver.create_virtual_sensor(testDriverName); 537 538 const fastSensor = new sensorType({frequency: 60}); 539 t.add_cleanup(() => { 540 fastSensor.stop(); 541 }); 542 let eventWatcher = new EventWatcher(t, fastSensor, ['activate']); 543 fastSensor.start(); 544 545 // Wait for |fastSensor| to be activated so that the call to 546 // getSamplingFrequency() below works. 547 await eventWatcher.wait_for('activate'); 548 549 let mockSensorInfo = 550 await test_driver.get_virtual_sensor_information(testDriverName); 551 552 // We need |fastSensorFrequency| because 60Hz might be higher than a sensor 553 // type's maximum allowed frequency. 554 const fastSensorFrequency = mockSensorInfo.requestedSamplingFrequency; 555 const slowSensorFrequency = fastSensorFrequency * 0.25; 556 557 const slowSensor = new sensorType({frequency: slowSensorFrequency}); 558 t.add_cleanup(() => { 559 slowSensor.stop(); 560 }); 561 t.add_cleanup(async () => { 562 // Remove the virtual sensor only after calling stop() on both sensors. 563 await test_driver.remove_virtual_sensor(testDriverName); 564 }); 565 eventWatcher = new EventWatcher(t, slowSensor, 'activate'); 566 slowSensor.start(); 567 568 // Wait for |slowSensor| to be activated before we check if the mock 569 // platform sensor's sampling frequency has changed. 570 await eventWatcher.wait_for('activate'); 571 mockSensorInfo = 572 await test_driver.get_virtual_sensor_information(testDriverName); 573 assert_equals( 574 mockSensorInfo.requestedSamplingFrequency, fastSensorFrequency); 575 576 // Now stop |fastSensor| and verify that the sampling frequency has dropped 577 // to the one |slowSensor| had requested. 578 fastSensor.stop(); 579 await wait_for_virtual_sensor_state(testDriverName, (info) => { 580 return info.requestedSamplingFrequency === slowSensorFrequency; 581 }); 582 }, `${sensorName}: frequency hint works.`); 583 584 sensor_test(async (t, readings, expectedReadings) => { 585 await test_driver.bidi.permissions.set_permission( 586 {descriptor: {name: permissionName}, state: 'granted'}); 587 588 await test_driver.create_virtual_sensor(testDriverName); 589 590 const sensor1 = new sensorType(); 591 const sensor2 = new sensorType(); 592 593 t.add_cleanup(async () => { 594 sensor1.stop(); 595 sensor2.stop(); 596 await test_driver.remove_virtual_sensor(testDriverName); 597 }); 598 599 return new Promise(async (resolve, reject) => { 600 sensor1.addEventListener('reading', () => { 601 sensor2.addEventListener('activate', () => { 602 try { 603 assert_true(sensor1.activated); 604 assert_true(sensor1.hasReading); 605 606 const expected = expectedReadings.next().value; 607 assert_sensor_reading_equals(sensor1, expected); 608 609 assert_true(sensor2.activated); 610 assert_sensor_reading_equals(sensor2, expected); 611 } catch (e) { 612 reject(e); 613 } 614 }, {once: true}); 615 sensor2.addEventListener('reading', () => { 616 try { 617 assert_true(sensor2.activated); 618 assert_true(sensor2.hasReading); 619 assert_sensor_reading_equals(sensor1, sensor2); 620 assert_equals(sensor1.timestamp, sensor2.timestamp); 621 resolve(); 622 } catch (e) { 623 reject(e); 624 } 625 }, {once: true}); 626 sensor2.start(); 627 }, {once: true}); 628 629 const eventWatcher = new EventWatcher(t, sensor1, ['activate']); 630 sensor1.start(); 631 await eventWatcher.wait_for('activate'); 632 await test_driver.update_virtual_sensor( 633 testDriverName, readings.next().value); 634 }); 635 }, `${sensorName}: Readings delivered by shared platform sensor are\ 636 immediately accessible to all sensors.`); 637 638 // Re-enable after https://github.com/w3c/sensors/issues/361 is fixed. 639 // promise_test(async () => { 640 // assert_throws_dom("NotSupportedError", 641 // () => { new sensorType({invalid: 1}) }); 642 // assert_throws_dom("NotSupportedError", 643 // () => { new sensorType({frequency: 60, invalid: 1}) }); 644 // if (!expectedRemappedReadings) { 645 // assert_throws_dom("NotSupportedError", 646 // () => { new sensorType({referenceFrame: "screen"}) }); 647 // } 648 // }, `${sensorName}: throw 'NotSupportedError' for an unsupported sensor\ 649 // option.`); 650 651 promise_test(async () => { 652 const invalidFreqs = ['invalid', NaN, Infinity, -Infinity, {}]; 653 invalidFreqs.map(freq => { 654 assert_throws_js( 655 TypeError, () => {new sensorType({frequency: freq})}, 656 `when freq is ${freq}`); 657 }); 658 }, `${sensorName}: throw 'TypeError' if frequency is invalid.`); 659 660 if (!readingData.expectedRemappedReadings) { 661 // The sensorType does not represent a spatial sensor. 662 return; 663 } 664 665 // TODO(https://github.com/web-platform-tests/wpt/issues/42724): Re-enable 666 // when there is a cross-platform way to set an orientation angle. 667 // sensor_test( 668 // async (t, readings, expectedReadings, expectedRemappedReadings) => { 669 // assert_implements_optional(screen.orientation.angle == 270, 670 // 'Remapped values expect a specific screen rotation.'); 671 // await test_driver.bidi.permissions.set_permission({descriptor: {name: 672 // permissionName}, state: 'granted'}); 673 674 // await test_driver.create_virtual_sensor(testDriverName); 675 676 // const sensor1 = new sensorType({frequency: 60}); 677 // const sensor2 = 678 // new sensorType({frequency: 60, referenceFrame: 'screen'}); 679 // t.add_cleanup(async () => { 680 // sensor1.stop(); 681 // sensor2.stop(); 682 // await test_driver.remove_virtual_sensor(testDriverName); 683 // }); 684 // const sensorWatcher1 = 685 // new EventWatcher(t, sensor1, ['activate', 'reading', 'error']); 686 // const sensorWatcher2 = 687 // new EventWatcher(t, sensor1, ['activate', 'reading', 'error']); 688 689 // sensor1.start(); 690 // sensor2.start(); 691 692 // await Promise.all([ 693 // sensorWatcher1.wait_for('activate'), 694 // sensorWatcher2.wait_for('activate') 695 // ]); 696 697 // await Promise.all([ 698 // test_driver.update_virtual_sensor(testDriverName, 699 // readings.next().value), sensorWatcher1.wait_for('reading'), 700 // sensorWatcher2.wait_for('reading') 701 // ]); 702 703 // const expected = expectedReadings.next().value; 704 // const expectedRemapped = expectedRemappedReadings.next().value; 705 // assert_sensor_reading_equals(sensor1, expected); 706 // assert_sensor_reading_equals(sensor2, expectedRemapped); 707 708 // sensor1.stop(); 709 // assert_sensor_reading_is_null(sensor1); 710 // assert_sensor_reading_equals(sensor2, expectedRemapped); 711 712 // sensor2.stop(); 713 // assert_sensor_reading_is_null(sensor2); 714 // }, 715 // `${sensorName}: sensor reading is correct when options.referenceFrame\ 716 // is 'screen'.`); 717 } 718 719 function runGenericSensorInsecureContext(sensorName) { 720 test(() => { 721 assert_false(sensorName in window, `${sensorName} must not be exposed`); 722 }, `${sensorName} is not exposed in an insecure context.`); 723 }