OLD | NEW |
(Empty) | |
| 1 'use strict'; |
| 2 |
| 3 // Run a set of tests for a given |sensorType|. |updateReading| is |
| 4 // a called by the test to provide the mock values for sensor. |verifyReading| |
| 5 // is called so that the value read in JavaScript are the values expected (the o
nes |
| 6 // sent by |updateReading|). |
| 7 function runGenericSensorTests(sensorType, updateReading, verifyReading) { |
| 8 test(() => assert_throws( |
| 9 new RangeError(), |
| 10 () => new sensorType({frequency: -60})), |
| 11 'Test that negative frequency causes exception from constructor.'); |
| 12 |
| 13 sensor_test(sensor => { |
| 14 sensor.mockSensorProvider.setGetSensorShouldFail(true); |
| 15 let sensorObject = new sensorType; |
| 16 sensorObject.start(); |
| 17 return new Promise((resolve, reject) => { |
| 18 let wrapper = new CallbackWrapper(event => { |
| 19 assert_equals(sensorObject.state, 'errored'); |
| 20 console.log(event.error.message); |
| 21 assert_equals(event.error.name, 'NotFoundError'); |
| 22 sensorObject.onerror = null; |
| 23 resolve(); |
| 24 }, reject); |
| 25 |
| 26 sensorObject.onerror = wrapper.callback; |
| 27 }); |
| 28 }, 'Test that "onerror" is send when sensor is not supported.'); |
| 29 |
| 30 sensor_test(sensor => { |
| 31 let sensorObject = new sensorType({frequency: 560}); |
| 32 sensorObject.start(); |
| 33 |
| 34 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 35 .then(mockSensor => { |
| 36 mockSensor.setStartShouldFail(true); |
| 37 return mockSensor.addConfigurationCalled(); }) |
| 38 .then(mockSensor => { |
| 39 return new Promise((resolve, reject) => { |
| 40 let wrapper = new CallbackWrapper(event => { |
| 41 assert_equals(sensorObject.state, 'errored'); |
| 42 assert_equals(event.error.name, 'OperationError'); |
| 43 sensorObject.onerror = null; |
| 44 resolve(); |
| 45 }, reject); |
| 46 |
| 47 sensorObject.onerror = wrapper.callback; |
| 48 }); |
| 49 }); |
| 50 return testPromise; |
| 51 }, 'Test that "onerror" is send when start() call has failed.'); |
| 52 |
| 53 sensor_test(sensor => { |
| 54 let sensorObject = new sensorType({frequency: 560}); |
| 55 sensorObject.start(); |
| 56 |
| 57 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 58 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
| 59 .then(mockSensor => { |
| 60 return new Promise((resolve, reject) => { |
| 61 let wrapper = new CallbackWrapper(() => { |
| 62 let configuration = mockSensor.active_sensor_configurations_[0]; |
| 63 assert_equals(configuration.frequency, 60); |
| 64 sensorObject.stop(); |
| 65 assert_equals(sensorObject.state, 'idle'); |
| 66 resolve(mockSensor); |
| 67 }, reject); |
| 68 sensorObject.onactivate = wrapper.callback; |
| 69 sensorObject.onerror = reject; |
| 70 }); |
| 71 }) |
| 72 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }
); |
| 73 return testPromise; |
| 74 }, 'Test that frequency is capped to 60.0 Hz.'); |
| 75 |
| 76 sensor_test(sensor => { |
| 77 let maxSupportedFrequency = 15; |
| 78 sensor.mockSensorProvider.setMaximumSupportedFrequency(maxSupportedFrequency
); |
| 79 let sensorObject = new sensorType({frequency: 50}); |
| 80 sensorObject.start(); |
| 81 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 82 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
| 83 .then(mockSensor => { |
| 84 return new Promise((resolve, reject) => { |
| 85 let wrapper = new CallbackWrapper(() => { |
| 86 let configuration = mockSensor.active_sensor_configurations_[0]; |
| 87 assert_equals(configuration.frequency, maxSupportedFrequency); |
| 88 sensorObject.stop(); |
| 89 assert_equals(sensorObject.state, 'idle'); |
| 90 resolve(mockSensor); |
| 91 }, reject); |
| 92 sensorObject.onactivate = wrapper.callback; |
| 93 sensorObject.onerror = reject; |
| 94 }); |
| 95 }) |
| 96 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 97 return testPromise; |
| 98 }, 'Test that frequency is capped to the maximum supported from frequency.'); |
| 99 |
| 100 sensor_test(sensor => { |
| 101 let sensorObject = new sensorType({frequency: 60}); |
| 102 sensorObject.start(); |
| 103 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 104 .then((mockSensor) => { |
| 105 return new Promise((resolve, reject) => { |
| 106 let wrapper = new CallbackWrapper(() => { |
| 107 assert_equals(sensorObject.state, 'active'); |
| 108 sensorObject.stop(); |
| 109 assert_equals(sensorObject.state, 'idle'); |
| 110 resolve(mockSensor); |
| 111 }, reject); |
| 112 sensorObject.onactivate = wrapper.callback; |
| 113 sensorObject.onerror = reject; |
| 114 }); |
| 115 }) |
| 116 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 117 return testPromise; |
| 118 }, 'Test that sensor can be successfully created if sensor is supported.'); |
| 119 |
| 120 sensor_test(sensor => { |
| 121 let sensorObject = new sensorType(); |
| 122 sensorObject.start(); |
| 123 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 124 .then((mockSensor) => { |
| 125 return new Promise((resolve, reject) => { |
| 126 let wrapper = new CallbackWrapper(() => { |
| 127 assert_equals(sensorObject.state, 'active'); |
| 128 sensorObject.stop(); |
| 129 assert_equals(sensorObject.state, 'idle'); |
| 130 resolve(mockSensor); |
| 131 }, reject); |
| 132 |
| 133 sensorObject.onactivate = wrapper.callback; |
| 134 sensorObject.onerror = reject; |
| 135 }); |
| 136 }) |
| 137 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 138 return testPromise; |
| 139 }, 'Test that sensor can be constructed with default configuration.'); |
| 140 |
| 141 sensor_test(sensor => { |
| 142 let sensorObject = new sensorType({frequency: 60}); |
| 143 sensorObject.start(); |
| 144 |
| 145 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 146 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
| 147 .then(mockSensor => { |
| 148 return new Promise((resolve, reject) => { |
| 149 let wrapper = new CallbackWrapper(() => { |
| 150 assert_equals(sensorObject.state, 'active'); |
| 151 sensorObject.stop(); |
| 152 assert_equals(sensorObject.state, 'idle'); |
| 153 resolve(mockSensor); |
| 154 }, reject); |
| 155 sensorObject.onactivate = wrapper.callback; |
| 156 sensorObject.onerror = reject; |
| 157 }); |
| 158 }) |
| 159 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 160 |
| 161 return testPromise; |
| 162 }, 'Test that addConfiguration and removeConfiguration is called.'); |
| 163 |
| 164 sensor_test(sensor => { |
| 165 let sensorObject = new sensorType({frequency: 60}); |
| 166 sensorObject.start(); |
| 167 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 168 .then(mockSensor => { |
| 169 return mockSensor.setUpdateSensorReadingFunction(updateReading); |
| 170 }) |
| 171 .then((mockSensor) => { |
| 172 return new Promise((resolve, reject) => { |
| 173 let wrapper = new CallbackWrapper(() => { |
| 174 assert_true(verifyReading(sensorObject.reading)); |
| 175 sensorObject.stop(); |
| 176 assert_equals(sensorObject.reading, null); |
| 177 resolve(mockSensor); |
| 178 }, reject); |
| 179 |
| 180 sensorObject.onchange = wrapper.callback; |
| 181 sensorObject.onerror = reject; |
| 182 }); |
| 183 }) |
| 184 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 185 |
| 186 return testPromise; |
| 187 }, 'Test that onChange is called and sensor reading is valid.'); |
| 188 |
| 189 sensor_test(sensor => { |
| 190 let sensorObject = new sensorType; |
| 191 sensorObject.start(); |
| 192 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 193 .then(mockSensor => { |
| 194 return mockSensor.setUpdateSensorReadingFunction(updateReading); |
| 195 }) |
| 196 .then(mockSensor => { |
| 197 return new Promise((resolve, reject) => { |
| 198 sensorObject.onchange = () => { |
| 199 if (verifyReading(sensorObject.reading)) { |
| 200 resolve(mockSensor); |
| 201 } |
| 202 } |
| 203 sensorObject.onerror = reject; |
| 204 }); |
| 205 }) |
| 206 .then(mockSensor => { |
| 207 testRunner.setPageVisibility('hidden'); |
| 208 return mockSensor.suspendCalled(); |
| 209 }) |
| 210 .then(mockSensor => { |
| 211 testRunner.setPageVisibility('visible'); |
| 212 return mockSensor.resumeCalled(); |
| 213 }) |
| 214 .then(mockSensor => { |
| 215 return new Promise((resolve, reject) => { |
| 216 sensorObject.stop(); |
| 217 resolve(mockSensor); |
| 218 sensorObject.onerror = reject; |
| 219 }); |
| 220 }) |
| 221 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 222 |
| 223 return testPromise; |
| 224 }, 'Test that sensor receives suspend / resume notifications when page' |
| 225 + ' visibility changes.'); |
| 226 |
| 227 sensor_test(sensor => { |
| 228 let sensor1 = new sensorType({frequency: 60}); |
| 229 sensor1.start(); |
| 230 |
| 231 let sensor2 = new sensorType({frequency: 20}); |
| 232 sensor2.start(); |
| 233 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
| 234 .then(mockSensor => { |
| 235 return mockSensor.setUpdateSensorReadingFunction(update_sensor_reading); |
| 236 }) |
| 237 .then((mockSensor) => { |
| 238 return new Promise((resolve, reject) => { |
| 239 let wrapper = new CallbackWrapper(() => { |
| 240 // Reading value is correct. |
| 241 assert_true(verifyReading(sensor1.reading)); |
| 242 |
| 243 // Both sensors share the same reading instance. |
| 244 let reading = sensor1.reading; |
| 245 assert_equals(reading, sensor2.reading); |
| 246 |
| 247 // After first sensor stops its reading is null, reading for second |
| 248 // sensor sensor remains. |
| 249 sensor1.stop(); |
| 250 assert_equals(sensor1.reading, null); |
| 251 assert_true(verifyReading(sensor2.reading)); |
| 252 |
| 253 sensor2.stop(); |
| 254 assert_equals(sensor2.reading, null); |
| 255 |
| 256 // Cached reading remains. |
| 257 assert_true(verifyReading(reading)); |
| 258 resolve(mockSensor); |
| 259 }, reject); |
| 260 |
| 261 sensor1.onchange = wrapper.callback; |
| 262 sensor1.onerror = reject; |
| 263 sensor2.onerror = reject; |
| 264 }); |
| 265 }) |
| 266 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
| 267 |
| 268 return testPromise; |
| 269 }, 'Test that sensor reading is correct.'); |
| 270 } |
OLD | NEW |