OLD | NEW |
1 'use strict'; | 1 'use strict'; |
2 | 2 |
3 // Run a set of tests for a given |sensorType|. |updateReading| is | 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| | 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 | 5 // is called so that the value read in JavaScript are the values expected (the o
nes |
6 // sent by |updateReading|). | 6 // sent by |updateReading|). |
7 function runGenericSensorTests(sensorType, updateReading, verifyReading) { | 7 function runGenericSensorTests(sensorType, updateReading, verifyReading) { |
8 sensor_test(sensor => { | 8 sensor_test(sensor => { |
9 sensor.mockSensorProvider.setGetSensorShouldFail(true); | 9 sensor.mockSensorProvider.setGetSensorShouldFail(true); |
10 let sensorObject = new sensorType; | 10 let sensorObject = new sensorType; |
11 sensorObject.start(); | 11 sensorObject.start(); |
12 return new Promise((resolve, reject) => { | 12 return new Promise((resolve, reject) => { |
13 let wrapper = new CallbackWrapper(event => { | 13 let wrapper = new CallbackWrapper(event => { |
14 assert_equals(sensorObject.state, 'errored'); | 14 assert_false(sensorObject.activated); |
15 assert_equals(event.error.name, 'NotReadableError'); | 15 assert_equals(event.error.name, 'NotReadableError'); |
16 sensorObject.onerror = null; | 16 sensorObject.onerror = null; |
17 resolve(); | 17 resolve(); |
18 }, reject); | 18 }, reject); |
19 | 19 |
20 sensorObject.onerror = wrapper.callback; | 20 sensorObject.onerror = wrapper.callback; |
21 }); | 21 }); |
22 }, 'Test that "onerror" is send when sensor is not supported.'); | 22 }, 'Test that "onerror" is send when sensor is not supported.'); |
23 | 23 |
24 sensor_test(sensor => { | 24 sensor_test(sensor => { |
25 let sensorObject = new sensorType({frequency: 560}); | 25 let sensorObject = new sensorType({frequency: 560}); |
26 sensorObject.start(); | 26 sensorObject.start(); |
27 | 27 |
28 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 28 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
29 .then(mockSensor => { | 29 .then(mockSensor => { |
30 mockSensor.setStartShouldFail(true); | 30 mockSensor.setStartShouldFail(true); |
31 return mockSensor.addConfigurationCalled(); }) | 31 return mockSensor.addConfigurationCalled(); }) |
32 .then(mockSensor => { | 32 .then(mockSensor => { |
33 return new Promise((resolve, reject) => { | 33 return new Promise((resolve, reject) => { |
34 let wrapper = new CallbackWrapper(event => { | 34 let wrapper = new CallbackWrapper(event => { |
35 assert_equals(sensorObject.state, 'errored'); | 35 assert_false(sensorObject.activated); |
36 assert_equals(event.error.name, 'OperationError'); | 36 assert_equals(event.error.name, 'NotReadableError'); |
37 sensorObject.onerror = null; | 37 sensorObject.onerror = null; |
38 resolve(); | 38 resolve(); |
39 }, reject); | 39 }, reject); |
40 | 40 |
41 sensorObject.onerror = wrapper.callback; | 41 sensorObject.onerror = wrapper.callback; |
42 }); | 42 }); |
43 }); | 43 }); |
44 return testPromise; | 44 return testPromise; |
45 }, 'Test that "onerror" is send when start() call has failed.'); | 45 }, 'Test that "onerror" is send when start() call has failed.'); |
46 | 46 |
47 sensor_test(sensor => { | 47 sensor_test(sensor => { |
48 let sensorObject = new sensorType({frequency: 560}); | 48 let sensorObject = new sensorType({frequency: 560}); |
49 sensorObject.start(); | 49 sensorObject.start(); |
50 | 50 |
51 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 51 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
52 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 52 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
53 .then(mockSensor => { | 53 .then(mockSensor => { |
54 return new Promise((resolve, reject) => { | 54 return new Promise((resolve, reject) => { |
55 let wrapper = new CallbackWrapper(() => { | 55 let wrapper = new CallbackWrapper(() => { |
56 let configuration = mockSensor.active_sensor_configurations_[0]; | 56 let configuration = mockSensor.active_sensor_configurations_[0]; |
57 assert_equals(configuration.frequency, 60); | 57 assert_equals(configuration.frequency, 60); |
58 sensorObject.stop(); | 58 sensorObject.stop(); |
59 assert_equals(sensorObject.state, 'idle'); | 59 assert_false(sensorObject.activated); |
60 resolve(mockSensor); | 60 resolve(mockSensor); |
61 }, reject); | 61 }, reject); |
62 sensorObject.onactivate = wrapper.callback; | 62 sensorObject.onactivate = wrapper.callback; |
63 sensorObject.onerror = reject; | 63 sensorObject.onerror = reject; |
64 }); | 64 }); |
65 }) | 65 }) |
66 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }
); | 66 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }
); |
67 return testPromise; | 67 return testPromise; |
68 }, 'Test that frequency is capped to 60.0 Hz.'); | 68 }, 'Test that frequency is capped to 60.0 Hz.'); |
69 | 69 |
70 sensor_test(sensor => { | 70 sensor_test(sensor => { |
71 let maxSupportedFrequency = 15; | 71 let maxSupportedFrequency = 15; |
72 sensor.mockSensorProvider.setMaximumSupportedFrequency(maxSupportedFrequency
); | 72 sensor.mockSensorProvider.setMaximumSupportedFrequency(maxSupportedFrequency
); |
73 let sensorObject = new sensorType({frequency: 50}); | 73 let sensorObject = new sensorType({frequency: 50}); |
74 sensorObject.start(); | 74 sensorObject.start(); |
75 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 75 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
76 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 76 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
77 .then(mockSensor => { | 77 .then(mockSensor => { |
78 return new Promise((resolve, reject) => { | 78 return new Promise((resolve, reject) => { |
79 let wrapper = new CallbackWrapper(() => { | 79 let wrapper = new CallbackWrapper(() => { |
80 let configuration = mockSensor.active_sensor_configurations_[0]; | 80 let configuration = mockSensor.active_sensor_configurations_[0]; |
81 assert_equals(configuration.frequency, maxSupportedFrequency); | 81 assert_equals(configuration.frequency, maxSupportedFrequency); |
82 sensorObject.stop(); | 82 sensorObject.stop(); |
83 assert_equals(sensorObject.state, 'idle'); | 83 assert_false(sensorObject.activated); |
84 resolve(mockSensor); | 84 resolve(mockSensor); |
85 }, reject); | 85 }, reject); |
86 sensorObject.onactivate = wrapper.callback; | 86 sensorObject.onactivate = wrapper.callback; |
87 sensorObject.onerror = reject; | 87 sensorObject.onerror = reject; |
88 }); | 88 }); |
89 }) | 89 }) |
90 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 90 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
91 return testPromise; | 91 return testPromise; |
92 }, 'Test that frequency is capped to the maximum supported from frequency.'); | 92 }, 'Test that frequency is capped to the maximum supported from frequency.'); |
93 | 93 |
94 sensor_test(sensor => { | 94 sensor_test(sensor => { |
95 let minSupportedFrequency = 2; | 95 let minSupportedFrequency = 2; |
96 sensor.mockSensorProvider.setMinimumSupportedFrequency(minSupportedFrequency
); | 96 sensor.mockSensorProvider.setMinimumSupportedFrequency(minSupportedFrequency
); |
97 let sensorObject = new sensorType({frequency: -1}); | 97 let sensorObject = new sensorType({frequency: -1}); |
98 sensorObject.start(); | 98 sensorObject.start(); |
99 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 99 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
100 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 100 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
101 .then(mockSensor => { | 101 .then(mockSensor => { |
102 return new Promise((resolve, reject) => { | 102 return new Promise((resolve, reject) => { |
103 let wrapper = new CallbackWrapper(() => { | 103 let wrapper = new CallbackWrapper(() => { |
104 let configuration = mockSensor.active_sensor_configurations_[0]; | 104 let configuration = mockSensor.active_sensor_configurations_[0]; |
105 assert_equals(configuration.frequency, minSupportedFrequency); | 105 assert_equals(configuration.frequency, minSupportedFrequency); |
106 sensorObject.stop(); | 106 sensorObject.stop(); |
107 assert_equals(sensorObject.state, 'idle'); | 107 assert_false(sensorObject.activated); |
108 resolve(mockSensor); | 108 resolve(mockSensor); |
109 }, reject); | 109 }, reject); |
110 sensorObject.onactivate = wrapper.callback; | 110 sensorObject.onactivate = wrapper.callback; |
111 sensorObject.onerror = reject; | 111 sensorObject.onerror = reject; |
112 }); | 112 }); |
113 }) | 113 }) |
114 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 114 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
115 return testPromise; | 115 return testPromise; |
116 }, 'Test that frequency is limited to the minimum supported from frequency.'); | 116 }, 'Test that frequency is limited to the minimum supported from frequency.'); |
117 | 117 |
118 sensor_test(sensor => { | 118 sensor_test(sensor => { |
119 let sensorObject = new sensorType({frequency: 60}); | 119 let sensorObject = new sensorType({frequency: 60}); |
120 assert_equals(sensorObject.state, 'unconnected'); | 120 assert_false(sensorObject.activated); |
121 sensorObject.start(); | 121 sensorObject.start(); |
122 assert_equals(sensorObject.state, 'activating'); | 122 assert_false(sensorObject.activated); |
123 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 123 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
124 .then((mockSensor) => { | 124 .then((mockSensor) => { |
125 return new Promise((resolve, reject) => { | 125 return new Promise((resolve, reject) => { |
126 let wrapper = new CallbackWrapper(() => { | 126 let wrapper = new CallbackWrapper(() => { |
127 assert_equals(sensorObject.state, 'activated'); | 127 assert_true(sensorObject.activated); |
128 sensorObject.stop(); | 128 sensorObject.stop(); |
129 assert_equals(sensorObject.state, 'idle'); | 129 assert_false(sensorObject.activated); |
130 resolve(mockSensor); | 130 resolve(mockSensor); |
131 }, reject); | 131 }, reject); |
132 sensorObject.onactivate = wrapper.callback; | 132 sensorObject.onactivate = wrapper.callback; |
133 sensorObject.onerror = reject; | 133 sensorObject.onerror = reject; |
134 }); | 134 }); |
135 }) | 135 }) |
136 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 136 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
137 return testPromise; | 137 return testPromise; |
138 }, 'Test that sensor can be successfully created and its states are correct.')
; | 138 }, 'Test that sensor can be successfully created and its states are correct.')
; |
139 | 139 |
140 sensor_test(sensor => { | 140 sensor_test(sensor => { |
141 let sensorObject = new sensorType(); | 141 let sensorObject = new sensorType(); |
142 sensorObject.start(); | 142 sensorObject.start(); |
143 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 143 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
144 .then((mockSensor) => { | 144 .then((mockSensor) => { |
145 return new Promise((resolve, reject) => { | 145 return new Promise((resolve, reject) => { |
146 let wrapper = new CallbackWrapper(() => { | 146 let wrapper = new CallbackWrapper(() => { |
147 assert_equals(sensorObject.state, 'activated'); | 147 assert_true(sensorObject.activated); |
148 sensorObject.stop(); | 148 sensorObject.stop(); |
149 assert_equals(sensorObject.state, 'idle'); | 149 assert_false(sensorObject.activated); |
150 resolve(mockSensor); | 150 resolve(mockSensor); |
151 }, reject); | 151 }, reject); |
152 | 152 |
153 sensorObject.onactivate = wrapper.callback; | 153 sensorObject.onactivate = wrapper.callback; |
154 sensorObject.onerror = reject; | 154 sensorObject.onerror = reject; |
155 }); | 155 }); |
156 }) | 156 }) |
157 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 157 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
158 return testPromise; | 158 return testPromise; |
159 }, 'Test that sensor can be constructed with default configuration.'); | 159 }, 'Test that sensor can be constructed with default configuration.'); |
160 | 160 |
161 sensor_test(sensor => { | 161 sensor_test(sensor => { |
162 let sensorObject = new sensorType({frequency: 60}); | 162 let sensorObject = new sensorType({frequency: 60}); |
163 sensorObject.start(); | 163 sensorObject.start(); |
164 | 164 |
165 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 165 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
166 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) | 166 .then(mockSensor => { return mockSensor.addConfigurationCalled(); }) |
167 .then(mockSensor => { | 167 .then(mockSensor => { |
168 return new Promise((resolve, reject) => { | 168 return new Promise((resolve, reject) => { |
169 let wrapper = new CallbackWrapper(() => { | 169 let wrapper = new CallbackWrapper(() => { |
170 assert_equals(sensorObject.state, 'activated'); | 170 assert_true(sensorObject.activated); |
171 sensorObject.stop(); | 171 sensorObject.stop(); |
172 assert_equals(sensorObject.state, 'idle'); | 172 assert_false(sensorObject.activated); |
173 resolve(mockSensor); | 173 resolve(mockSensor); |
174 }, reject); | 174 }, reject); |
175 sensorObject.onactivate = wrapper.callback; | 175 sensorObject.onactivate = wrapper.callback; |
176 sensorObject.onerror = reject; | 176 sensorObject.onerror = reject; |
177 }); | 177 }); |
178 }) | 178 }) |
179 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); | 179 .then(mockSensor => { return mockSensor.removeConfigurationCalled(); }); |
180 | 180 |
181 return testPromise; | 181 return testPromise; |
182 }, 'Test that addConfiguration and removeConfiguration is called.'); | 182 }, 'Test that addConfiguration and removeConfiguration is called.'); |
(...skipping 110 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
293 return testPromise; | 293 return testPromise; |
294 }, 'Test that sensor reading is correct.'); | 294 }, 'Test that sensor reading is correct.'); |
295 | 295 |
296 function checkFrequencyHintWorks(sensor) { | 296 function checkFrequencyHintWorks(sensor) { |
297 let fastSensor = new sensorType({frequency: 30}); | 297 let fastSensor = new sensorType({frequency: 30}); |
298 let slowSensor = new sensorType({frequency: 9}); | 298 let slowSensor = new sensorType({frequency: 9}); |
299 slowSensor.start(); | 299 slowSensor.start(); |
300 | 300 |
301 let testPromise = sensor.mockSensorProvider.getCreatedSensor() | 301 let testPromise = sensor.mockSensorProvider.getCreatedSensor() |
302 .then(mockSensor => { | 302 .then(mockSensor => { |
303 mockSensor.setExpectsModifiedReading(true); | |
304 return mockSensor.setUpdateSensorReadingFunction(updateReading); | 303 return mockSensor.setUpdateSensorReadingFunction(updateReading); |
305 }) | 304 }) |
306 .then(mockSensor => { | 305 .then(mockSensor => { |
307 return new Promise((resolve, reject) => { | 306 return new Promise((resolve, reject) => { |
308 let fastSensorNotifiedCounter = 0; | 307 let fastSensorNotifiedCounter = 0; |
309 let slowSensorNotifiedCounter = 0; | 308 let slowSensorNotifiedCounter = 0; |
310 let readingUpdatesCounter = 0; | 309 let readingUpdatesCounter = 0; |
311 | 310 |
312 let fastSensorWrapper = new CallbackWrapper(() => { | 311 let fastSensorWrapper = new CallbackWrapper(() => { |
313 fastSensorNotifiedCounter++; | 312 fastSensorNotifiedCounter++; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
346 | 345 |
347 sensor_test(sensor => { | 346 sensor_test(sensor => { |
348 return checkFrequencyHintWorks(sensor); | 347 return checkFrequencyHintWorks(sensor); |
349 }, 'Test that frequency hint works (onchange reporting).'); | 348 }, 'Test that frequency hint works (onchange reporting).'); |
350 | 349 |
351 sensor_test(sensor => { | 350 sensor_test(sensor => { |
352 sensor.mockSensorProvider.setContinuousReportingMode(); | 351 sensor.mockSensorProvider.setContinuousReportingMode(); |
353 return checkFrequencyHintWorks(sensor); | 352 return checkFrequencyHintWorks(sensor); |
354 }, 'Test that frequency hint works (continuous reporting).'); | 353 }, 'Test that frequency hint works (continuous reporting).'); |
355 } | 354 } |
OLD | NEW |