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]; | |
Reilly Grant (use Gerrit)
2016/11/14 18:36:11
nit: Indentation issue.
| |
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) => { | |
Reilly Grant (use Gerrit)
2016/11/14 18:36:11
nit: Parenthesis not necessary around mockSensor h
| |
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"); | |
Reilly Grant (use Gerrit)
2016/11/14 18:36:11
nit: 'hidden'
| |
208 return mockSensor.suspendCalled(); | |
209 }) | |
210 .then((mockSensor) => { | |
211 testRunner.setPageVisibility("visible"); | |
Reilly Grant (use Gerrit)
2016/11/14 18:36:11
nit: '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 |