OLD | NEW |
| (Empty) |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/files/file_util.h" | |
6 #include "base/files/scoped_temp_dir.h" | |
7 #include "base/strings/string_number_conversions.h" | |
8 #include "device/generic_sensor/linux/platform_sensor_utils_linux.h" | |
9 #include "device/generic_sensor/linux/sensor_data_linux.h" | |
10 #include "device/generic_sensor/public/cpp/sensor_reading.h" | |
11 | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 | |
14 namespace device { | |
15 | |
16 namespace { | |
17 | |
18 const base::FilePath::CharType* kDevice0Dir = FILE_PATH_LITERAL("device0"); | |
19 | |
20 const char kSensorFileNameTest1[] = "sensor_data1"; | |
21 const char kSensorFileNameTest2[] = "sensor_data2"; | |
22 const char kSensorFileNameTest3[] = "sensor_data3"; | |
23 | |
24 const char* kTestSensorFileNamesTest[3][5] = { | |
25 { | |
26 kSensorFileNameTest1, "sensor1_input", "sensor1_raw_input", "sensor1", | |
27 "sensor1_data_raw", | |
28 }, | |
29 { | |
30 "sensor2", kSensorFileNameTest2, "sensor2_raw_input", "sensor2_input", | |
31 "sensor2_data_raw", | |
32 }, | |
33 { | |
34 "sensor3", "sensor3_input", "sensor3_raw_input", "sensor3_data_raw", | |
35 kSensorFileNameTest3, | |
36 }, | |
37 }; | |
38 | |
39 const char kTestSensorFileNameScaling[] = "test_scaling"; | |
40 | |
41 void CreateFile(const base::FilePath& file) { | |
42 EXPECT_EQ(base::WriteFile(file, nullptr, 0), 0); | |
43 } | |
44 | |
45 void DeleteFile(const base::FilePath& file) { | |
46 EXPECT_TRUE(base::DeleteFile(file, false)); | |
47 } | |
48 | |
49 void WriteValueToFile(const base::FilePath& path, double value) { | |
50 const std::string str = base::DoubleToString(value); | |
51 int bytes_written = base::WriteFile(path, str.data(), str.size()); | |
52 EXPECT_EQ(static_cast<size_t>(bytes_written), str.size()); | |
53 } | |
54 | |
55 } // namespace | |
56 | |
57 class SensorReaderTest : public ::testing::Test { | |
58 public: | |
59 void SetUp() override { | |
60 ASSERT_TRUE(base_temp_dir_.CreateUniqueTempDir()); | |
61 base_dir_ = base_temp_dir_.GetPath(); | |
62 sensors_dir_ = base_dir_.Append(kDevice0Dir); | |
63 ASSERT_TRUE(base::CreateDirectory(sensors_dir_)); | |
64 } | |
65 | |
66 // Deletes base dir recursively. | |
67 void TearDown() override { ASSERT_TRUE(base_temp_dir_.Delete()); } | |
68 | |
69 // Initialize SensorDataLinux with values for a sensor reader. | |
70 void InitSensorDataForTest( | |
71 size_t rows, | |
72 const SensorDataLinux::ReaderFunctor& apply_scaling_func, | |
73 SensorDataLinux* data) { | |
74 // Corresponds to maximum values in SensorReading. | |
75 // We must read only from up to three files. Thus - 3 sets of files | |
76 // should be fill in here. | |
77 const size_t max_rows = 3; | |
78 if (rows > 3) | |
79 rows = max_rows; | |
80 | |
81 data->apply_scaling_func = apply_scaling_func; | |
82 data->sensor_scale_name = kTestSensorFileNameScaling; | |
83 data->base_path_sensor_linux = base_dir_.value().c_str(); | |
84 for (size_t i = 0; i < rows; ++i) { | |
85 std::vector<std::string> file_names( | |
86 kTestSensorFileNamesTest[i], | |
87 kTestSensorFileNamesTest[i] + arraysize(kTestSensorFileNamesTest[i])); | |
88 data->sensor_file_names.push_back(std::move(file_names)); | |
89 } | |
90 } | |
91 | |
92 // Check SensorReading values are properly read. | |
93 void CheckSensorDataFields(const SensorReading& data, | |
94 double value1, | |
95 double value2, | |
96 double value3) { | |
97 EXPECT_EQ(value1, data.values[0]); | |
98 EXPECT_EQ(value2, data.values[1]); | |
99 EXPECT_EQ(value3, data.values[2]); | |
100 } | |
101 | |
102 protected: | |
103 // Holds a path to a sensor dir that is located in |base_dir_| | |
104 base::FilePath sensors_dir_; | |
105 // Holds a path to a base dir. | |
106 base::FilePath base_dir_; | |
107 // Holds base dir where a sensor dir is located. | |
108 base::ScopedTempDir base_temp_dir_; | |
109 }; | |
110 | |
111 // Test a reader is not created if sensor read files | |
112 // do not exist. | |
113 TEST_F(SensorReaderTest, FileDoesNotExist) { | |
114 const char* kGiberishFiles[] = {"temp1", "temp2", "temp3", "temp4"}; | |
115 const size_t rows = 3; | |
116 const double scaling_value = 0.1234; | |
117 // Create some gibberish files that we are not interested in. | |
118 for (unsigned int i = 0; i < arraysize(kGiberishFiles); ++i) { | |
119 base::FilePath some_file = sensors_dir_.Append(kGiberishFiles[i]); | |
120 CreateFile(some_file); | |
121 } | |
122 | |
123 // Create a file with a scaling value. | |
124 base::FilePath temp_sensor_scale_file = | |
125 sensors_dir_.Append(kTestSensorFileNameScaling); | |
126 CreateFile(temp_sensor_scale_file); | |
127 // Write a scaling value to the file. | |
128 WriteValueToFile(temp_sensor_scale_file, scaling_value); | |
129 | |
130 SensorDataLinux sensor_data; | |
131 SensorDataLinux::ReaderFunctor empty_func; | |
132 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
133 | |
134 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
135 EXPECT_FALSE(reader); | |
136 } | |
137 | |
138 // Test a reader is still created if a file with a scaling value | |
139 // does not exist. | |
140 TEST_F(SensorReaderTest, ScalingFileDoesNotExist) { | |
141 const size_t rows = 1; | |
142 // Create a test sensor file, which must be found. | |
143 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
144 CreateFile(temp_sensor_file1); | |
145 | |
146 SensorDataLinux sensor_data; | |
147 SensorDataLinux::ReaderFunctor empty_func; | |
148 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
149 | |
150 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
151 EXPECT_TRUE(reader); | |
152 } | |
153 | |
154 // Test a reader is not created if a scaling file exists, but cannot be read | |
155 // from. | |
156 TEST_F(SensorReaderTest, CannotReadFromScalingFile) { | |
157 const size_t rows = 1; | |
158 // Create a test sensor file, which must be found. | |
159 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
160 CreateFile(temp_sensor_file1); | |
161 | |
162 // Create a file with a scaling value, which must be found. | |
163 base::FilePath temp_sensor_scale_file = | |
164 sensors_dir_.Append(kTestSensorFileNameScaling); | |
165 CreateFile(temp_sensor_scale_file); | |
166 | |
167 SensorDataLinux sensor_data; | |
168 SensorDataLinux::ReaderFunctor empty_func; | |
169 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
170 | |
171 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
172 EXPECT_FALSE(reader); | |
173 } | |
174 | |
175 // Simulate a sensor, which has only one file to be read from. | |
176 TEST_F(SensorReaderTest, ReadValueFromOneFile) { | |
177 const size_t rows = 1; | |
178 const double value1 = 20; | |
179 const double zero_value = 0; | |
180 // Create a test sensor file, which must be found to be read from. | |
181 base::FilePath temp_sensor_file = sensors_dir_.Append(kSensorFileNameTest1); | |
182 CreateFile(temp_sensor_file); | |
183 | |
184 // Initialize sensor data for a reader. | |
185 SensorDataLinux sensor_data; | |
186 SensorDataLinux::ReaderFunctor empty_func; | |
187 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
188 | |
189 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
190 EXPECT_TRUE(reader); | |
191 | |
192 // Write a value to the file. | |
193 WriteValueToFile(temp_sensor_file, value1); | |
194 | |
195 // Fill SensorReading's first field with read value. Other fields must | |
196 // be 0. | |
197 SensorReading reading; | |
198 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
199 CheckSensorDataFields(reading, value1, zero_value, zero_value); | |
200 } | |
201 | |
202 // Simulate a sensor, which has two files to be read from. | |
203 TEST_F(SensorReaderTest, ReadValuesFromTwoFiles) { | |
204 const size_t rows = 2; | |
205 const double value1 = 20; | |
206 const double value2 = 50; | |
207 const double zero_value = 0; | |
208 // Create a test sensor file, which must be found. | |
209 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
210 CreateFile(temp_sensor_file1); | |
211 | |
212 // Create another test sensor file, which must be found. | |
213 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
214 CreateFile(temp_sensor_file2); | |
215 | |
216 // Initialize sensor data for a reader. | |
217 SensorDataLinux sensor_data; | |
218 SensorDataLinux::ReaderFunctor empty_func; | |
219 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
220 | |
221 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
222 EXPECT_TRUE(reader); | |
223 | |
224 // Write a value to the file. | |
225 WriteValueToFile(temp_sensor_file1, value1); | |
226 WriteValueToFile(temp_sensor_file2, value2); | |
227 | |
228 // Fill SensorReading's two first fields with read value. Last field must | |
229 // be 0. | |
230 SensorReading reading; | |
231 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
232 CheckSensorDataFields(reading, value1, value2, zero_value); | |
233 } | |
234 | |
235 // Simulate a sensor, which has the files to be read from. | |
236 // After read is successful, remove one of the files and try | |
237 // to read again. Reading must fail then. | |
238 TEST_F(SensorReaderTest, ReadValuesFromThreeFilesAndFail) { | |
239 const size_t rows = 4; | |
240 const double value1 = 20; | |
241 const double value2 = 50; | |
242 const double value3 = 80; | |
243 const double zero_value = 0; | |
244 // Create a test sensor file, which must be found. | |
245 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
246 CreateFile(temp_sensor_file1); | |
247 | |
248 // Create another test sensor file, which must be found. | |
249 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
250 CreateFile(temp_sensor_file2); | |
251 | |
252 // Create third test sensor file, which must be found. | |
253 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
254 CreateFile(temp_sensor_file3); | |
255 | |
256 // Initialize sensor data for a reader. | |
257 SensorDataLinux sensor_data; | |
258 SensorDataLinux::ReaderFunctor empty_func; | |
259 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
260 | |
261 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
262 EXPECT_TRUE(reader); | |
263 | |
264 // Write values to the files. | |
265 WriteValueToFile(temp_sensor_file1, value1); | |
266 WriteValueToFile(temp_sensor_file2, value2); | |
267 WriteValueToFile(temp_sensor_file3, value3); | |
268 | |
269 // Fill SensorReading's values with data from files. | |
270 SensorReading reading; | |
271 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
272 CheckSensorDataFields(reading, value1, value2, value3); | |
273 | |
274 SensorReading reading2; | |
275 DeleteFile(temp_sensor_file2); | |
276 EXPECT_FALSE(reader->ReadSensorReading(&reading2)); | |
277 CheckSensorDataFields(reading2, zero_value, zero_value, zero_value); | |
278 } | |
279 | |
280 // Fill in SensorDataLinux with three arrays of files that must be found | |
281 // before creating a sensor reader. If even one file is not found, | |
282 // a sensor reader must not be created. As soon as all the files are found, | |
283 // check the reader is created. | |
284 TEST_F(SensorReaderTest, SensorReadFilesDoNotExist) { | |
285 const size_t rows = 3; | |
286 // Create a test sensor file, which must be found. Other | |
287 // files will not be created and the test must fail to create a reader. | |
288 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
289 CreateFile(temp_sensor_file1); | |
290 | |
291 // Initialize sensor data for a reader. | |
292 SensorDataLinux sensor_data; | |
293 SensorDataLinux::ReaderFunctor empty_func; | |
294 InitSensorDataForTest(rows, empty_func, &sensor_data); | |
295 | |
296 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
297 EXPECT_FALSE(reader); | |
298 | |
299 // Create one more file. The reader mustn't be created as long as it | |
300 // expects three files to be found. | |
301 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
302 CreateFile(temp_sensor_file2); | |
303 | |
304 reader.reset(); | |
305 reader = SensorReader::Create(sensor_data); | |
306 EXPECT_FALSE(reader); | |
307 | |
308 // Create last file. | |
309 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
310 CreateFile(temp_sensor_file3); | |
311 | |
312 reader.reset(); | |
313 reader = SensorReader::Create(sensor_data); | |
314 EXPECT_TRUE(reader); | |
315 } | |
316 | |
317 // Fill in SensorDataLinux with three arrays of files that must be found | |
318 // before creating a sensor reader. Create a file with a scaling value that | |
319 // must be applied. Pass a func to a SensorReader that will be used to | |
320 // apply scalings. | |
321 TEST_F(SensorReaderTest, CheckSensorReadingScalingApplied) { | |
322 const size_t rows = 3; | |
323 const double value1 = 20; | |
324 const double value2 = 50; | |
325 const double value3 = 80; | |
326 const double scaling_value = 0.1234; | |
327 // Create a file with a scaling value, which must be found. | |
328 base::FilePath temp_sensor_scale_file = | |
329 sensors_dir_.Append(kTestSensorFileNameScaling); | |
330 CreateFile(temp_sensor_scale_file); | |
331 | |
332 // Create a test sensor file, which must be found. Other | |
333 // files will not be created and the test must fail to create a reader. | |
334 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
335 CreateFile(temp_sensor_file1); | |
336 | |
337 // Create one more file. The reader mustn't be created as long as it | |
338 // expects three files to be found. | |
339 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
340 CreateFile(temp_sensor_file2); | |
341 | |
342 // Create last file. | |
343 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
344 CreateFile(temp_sensor_file3); | |
345 | |
346 // Write value to the files. | |
347 WriteValueToFile(temp_sensor_file1, value1); | |
348 WriteValueToFile(temp_sensor_file2, value2); | |
349 WriteValueToFile(temp_sensor_file3, value3); | |
350 WriteValueToFile(temp_sensor_scale_file, scaling_value); | |
351 | |
352 // Initialize sensor data for a reader. | |
353 SensorDataLinux sensor_data; | |
354 SensorDataLinux::ReaderFunctor apply_scaling_func = | |
355 base::Bind([](double scaling_value_in_reader, SensorReading& reading) { | |
356 reading.values[0] = scaling_value_in_reader * reading.values[0]; | |
357 reading.values[1] = -scaling_value_in_reader * reading.values[1]; | |
358 reading.values[2] = scaling_value_in_reader * reading.values[2]; | |
359 }); | |
360 InitSensorDataForTest(rows, apply_scaling_func, &sensor_data); | |
361 | |
362 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
363 EXPECT_TRUE(reader); | |
364 | |
365 // Fill SensorReading's values with data from files. | |
366 SensorReading reading; | |
367 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
368 CheckSensorDataFields(reading, value1 * scaling_value, | |
369 value2 * (-scaling_value), value3 * scaling_value); | |
370 } | |
371 | |
372 } // namespace device | |
OLD | NEW |