[sensors] Accelerometer sensor bindings implementation

third_party/WebKit/LayoutTests/sensor/resources/generic-tests.js

Index: third_party/WebKit/LayoutTests/sensor/resources/generic-tests.js
diff --git a/third_party/WebKit/LayoutTests/sensor/resources/generic-tests.js b/third_party/WebKit/LayoutTests/sensor/resources/generic-tests.js
new file mode 100644
index 0000000000000000000000000000000000000000..939ddc91fc6a17ae8980dfbea7b526955c0bc771
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/sensor/resources/generic-tests.js
@@ -0,0 +1,243 @@
+'use strict';
+
+function runGenericTests(sensorProto, updateReading, verifyReading) {

[Mikhail, 2016/11/03 08:25:45]

- 'runGenericSensorTest' would be more descriptive
- s/sensorProto/sensorType
- could you add a descriptive comment for this function since it's a kind of
API?

+  test(() => assert_throws(
+    new RangeError(),
+    () => new sensorProto({frequency: -60})),
+    'Test that negative frequency causes exception from constructor.');
+
+  sensor_test(sensor => {
+    sensor.mockSensorProvider.setGetSensorShouldFail(true);
+    let sensorObject = new sensorProto;
+    sensorObject.start();
+    return new Promise((resolve, reject) => {
+      sensorObject.onstatechange = event => {
+        if(sensorObject.state == 'errored') {
+            resolve();
+        }
+      };
+    });
+  }, 'Test that sensor state changes to "errored" when sensor is not supported.');
+
+  sensor_test(sensor => {
+    sensor.mockSensorProvider.setGetSensorShouldFail(true);
+    let sensorObject = new sensorProto();
+    sensorObject.start();
+    return new Promise((resolve, reject) => {
+      sensorObject.onerror = event => {
+        assert_equals(sensorObject.state, 'errored');
+        console.log(event.error.message);
+        assert_equals(event.error.name, 'NotFoundError');
+        resolve();
+      };
+    });
+  }, 'Test that "onerror" is send when sensor is not supported.');
+
+  sensor_test(sensor => {
+      let sensorObject = new sensorProto({frequency: 560});
+      sensorObject.start();
+
+      let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+        .then(mockSensor => {
+          mockSensor.setStartShouldFail(true);
+          return mockSensor.addConfigurationCalled(); })
+        .then(mockSensor => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onerror = event => {
+              assert_equals(sensorObject.state, 'errored');
+              assert_equals(event.error.name, 'OperationError');
+              resolve();
+            };
+          });
+        });
+      return testPromise;
+  }, 'Test that "onerror" is send when start() call has failed.');
+
+  sensor_test(sensor => {
+      let sensorObject = new sensorProto({frequency: 560});
+      sensorObject.start();
+
+      let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+          .then(mockSensor => { return mockSensor.addConfigurationCalled(); })
+          .then(mockSensor => {
+            return new Promise((resolve, reject) => {
+              sensorObject.onstatechange = event => {
+                if (sensorObject.state === 'idle') {
+                  resolve(mockSensor);
+                }
+                if (sensorObject.state === 'active') {
+                  let configuration = mockSensor.active_sensor_configurations_[0];
+                  assert_equals(configuration.frequency, 60);
+                  sensorObject.stop();
+                }
+              };
+            });
+          })
+          .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+      return testPromise;
+  }, 'Test that frequency is capped to 60.0 Hz.');
+
+  sensor_test(sensor => {
+  let sensorObject = new sensorProto({frequency: 60});
+  sensorObject.start();
+  let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+      .then((mockSensor) => {
+        return new Promise((resolve, reject) => {
+          sensorObject.onstatechange = event => {
+            if (sensorObject.state === 'idle') {
+              resolve(mockSensor);
+            }
+            if (sensorObject.state === 'active') {
+              sensorObject.stop();
+            }
+          };
+          sensorObject.onerror = reject;
+        });
+      })
+      .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+  return testPromise;
+  }, 'Test that sensor can be successfully created if sensor is supported.');
+
+  sensor_test(sensor => {
+    let sensorObject = new sensorProto();
+    sensorObject.start();
+    let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+        .then((mockSensor) => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onstatechange = event => {
+              if (sensorObject.state === 'idle') {
+                resolve(mockSensor);
+              }
+              if (sensorObject.state === 'active') {
+                sensorObject.stop();
+              }
+            };
+
+            sensorObject.onerror = reject;
+          });
+        })
+        .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+    return testPromise;
+  }, 'Test that sensor can be constructed with default configuration.');
+
+  sensor_test(sensor => {
+    let sensorObject = new sensorProto({frequency: 60});
+    sensorObject.start();
+
+    let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+        .then(mockSensor => { return mockSensor.addConfigurationCalled(); })
+        .then(mockSensor => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onstatechange = event => {
+              if (sensorObject.state === 'idle') {
+                resolve(mockSensor);
+              }
+              if (sensorObject.state === 'active') {
+                sensorObject.stop();
+              }
+            };
+          });
+        })
+        .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+
+    return testPromise;
+  }, 'Test that addConfiguration and removeConfiguration is called.');
+
+  sensor_test(sensor => {
+  let sensorObject = new sensorProto({frequency: 60});
+  sensorObject.start();
+  let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+      .then(mockSensor => {
+        return mockSensor.setUpdateSensorReadingFunction(updateReading);
+      })
+      .then((mockSensor) => {
+        return new Promise((resolve, reject) => {
+          sensorObject.onstatechange = event => {
+            if (sensorObject.state === 'idle') {
+              resolve(mockSensor);
+            }
+          };
+
+          sensorObject.onchange = e => {
+            assert_true(verifyReading(e.reading));
+            sensorObject.stop();
+          };
+
+          sensorObject.onerror = reject;
+        });
+      })
+      .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+
+  return testPromise;
+  }, 'Test that onChange is called and sensor reading is valid.');
+
+  sensor_test(sensor => {
+    let sensorObject = new sensorProto({frequency: 60});
+    sensorObject.start();
+    let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+        .then(mockSensor => {
+          return mockSensor.setUpdateSensorReadingFunction(updateReading);
+        })
+        .then((mockSensor) => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onstatechange = () => {
+              if (sensorObject.state === 'idle') {
+                assert_equals(sensorObject.reading, null);
+                resolve(mockSensor);
+              }
+            }
+
+            sensorObject.onchange = e => {
+              assert_true(verifyReading(e.reading));
+              sensorObject.stop();
+            }
+            sensorObject.onerror = reject;
+          });
+        })
+        .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+
+    return testPromise;
+  }, 'Test that sensor reading is not updated when sensor is stopped.');
+
+  sensor_test(sensor => {
+    let sensorObject = new sensorProto;
+    sensorObject.start();
+    let testPromise = sensor.mockSensorProvider.getCreatedSensor()
+        .then(mockSensor => {
+          return mockSensor.setUpdateSensorReadingFunction(updateReading);
+        })
+        .then((mockSensor) => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onchange = e => {
+              if (verifyReading(e.reading)) {
+                resolve(mockSensor);
+              }
+            }
+          sensorObject.onerror = reject;
+          });
+        })
+        .then((mockSensor) => {
+          testRunner.setPageVisibility("hidden");
+          return mockSensor.suspendCalled();
+        })
+        .then((mockSensor) => {
+          testRunner.setPageVisibility("visible");
+          return mockSensor.resumeCalled();
+        })
+        .then((mockSensor) => {
+          return new Promise((resolve, reject) => {
+            sensorObject.onstatechange = () => {
+              if (sensorObject.state === 'idle') {
+                resolve(mockSensor);
+              }
+            }
+            sensorObject.stop();
+            sensorObject.onerror = reject;
+          });
+        })
+        .then(mockSensor => { return mockSensor.removeConfigurationCalled(); });
+
+    return testPromise;
+  }, 'Test that sensor receives suspend / resume notifications when page'
+      + ' visibility changes.');
+}