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 | |
9 #include "device/generic_sensor/iio/platform_sensor_utils_iio.h" | |
10 #include "device/generic_sensor/iio/sensor_data_iio.h" | |
11 #include "device/generic_sensor/public/cpp/sensor_reading.h" | |
12 | |
13 #include "testing/gtest/include/gtest/gtest.h" | |
14 | |
15 namespace device { | |
16 | |
17 namespace { | |
18 | |
19 const base::FilePath::CharType* kDevice0Dir = FILE_PATH_LITERAL("device0"); | |
20 | |
21 const std::string kSensorFileNameTest1 = "sensor_data1"; | |
22 const std::string kSensorFileNameTest2 = "sensor_data2"; | |
23 const std::string kSensorFileNameTest3 = "sensor_data3"; | |
24 | |
25 const std::string kTestSensorFileNamesTest[3][5] = { | |
26 { | |
27 kSensorFileNameTest1, "sensor1_input", "sensor1_raw_input", "sensor1", | |
28 "sensor1_data_raw", | |
29 }, | |
30 { | |
31 "sensor2", kSensorFileNameTest2, "sensor2_raw_input", "sensor2_input", | |
32 "sensor2_data_raw", | |
33 }, | |
34 { | |
35 "sensor3", "sensor3_input", "sensor3_raw_input", "sensor3_data_raw", | |
36 kSensorFileNameTest3, | |
37 }, | |
38 }; | |
39 | |
40 void CreateFile(const base::FilePath& file) { | |
41 EXPECT_EQ(base::WriteFile(file, NULL, 0), 0); | |
Reilly Grant (use Gerrit)
2016/10/31 21:18:09
nit: nullptr
maksims (do not use this acc)
2016/11/01 08:14:08
Done.
| |
42 } | |
43 | |
44 void DeleteFile(const base::FilePath& file) { | |
45 EXPECT_TRUE(base::DeleteFile(file, false)); | |
46 } | |
47 | |
48 void WriteReadingFieldToFile(const base::FilePath& path, double value) { | |
49 const std::string str = base::DoubleToString(value); | |
50 int bytes_written = base::WriteFile(path, str.data(), str.size()); | |
51 EXPECT_EQ(static_cast<size_t>(bytes_written), str.size()); | |
52 } | |
53 | |
54 } // namespace | |
55 | |
56 class SensorReaderTest : public ::testing::Test { | |
57 public: | |
58 void SetUp() override { | |
59 ASSERT_TRUE(base_temp_dir_.CreateUniqueTempDir()); | |
60 base_dir_ = base_temp_dir_.GetPath(); | |
61 sensors_dir_ = base_dir_.Append(kDevice0Dir); | |
62 ASSERT_TRUE(base::CreateDirectory(sensors_dir_)); | |
63 } | |
64 | |
65 // Deletes base dir recursively. | |
66 void TearDown() override { ASSERT_TRUE(base_temp_dir_.Delete()); } | |
67 | |
68 // Initialize SensorDataIio with values for a sensor reader. | |
69 void InitSensorDataForTest(size_t rows, SensorDataIio* data) { | |
70 // Corresponds to maximum values in SensorReading. | |
71 // We must read only from up to three files. Thus - 3 sets of files | |
72 // should be fill in here. | |
73 const size_t max_rows = 3; | |
74 if (rows > 3) | |
75 rows = max_rows; | |
76 | |
77 data->base_path_sensor_iio = base_dir_.value().c_str(); | |
78 for (size_t i = 0; i < rows; ++i) { | |
79 std::vector<std::string> file_names( | |
80 kTestSensorFileNamesTest[i], | |
81 kTestSensorFileNamesTest[i] + arraysize(kTestSensorFileNamesTest[i])); | |
82 data->sensor_file_names.push_back(file_names); | |
Reilly Grant (use Gerrit)
2016/10/31 21:18:09
nit: Same here, swap is better.
maksims (do not use this acc)
2016/11/01 08:14:08
It doesn't make any sense, because I'll have to cr
| |
83 } | |
84 } | |
85 | |
86 // Check SensorReading values are properly read. | |
87 void CheckSensorDataFields(const SensorReading& data, | |
88 double value1, | |
89 double value2, | |
90 double value3) { | |
91 EXPECT_EQ(value1, data.values[0]); | |
92 EXPECT_EQ(value2, data.values[1]); | |
93 EXPECT_EQ(value3, data.values[2]); | |
94 } | |
95 | |
96 protected: | |
97 // Holds a path to a sensor dir that is located in |base_dir_| | |
98 base::FilePath sensors_dir_; | |
99 // Holds a path to a base dir. | |
100 base::FilePath base_dir_; | |
101 // Holds base dir where a sensor dir is located. | |
102 base::ScopedTempDir base_temp_dir_; | |
103 }; | |
104 | |
105 // Test a reader is not created if sensor read files | |
106 // do not exist. | |
107 TEST_F(SensorReaderTest, FileDoesNotExist) { | |
108 const char* kGiberishFiles[] = {"temp1", "temp2", "temp3", "temp4"}; | |
109 const size_t rows = 3; | |
110 // Create some gibberish files that we are not interested in. | |
111 for (unsigned int i = 0; i < arraysize(kGiberishFiles); ++i) { | |
112 base::FilePath some_file = sensors_dir_.Append(kGiberishFiles[i]); | |
113 CreateFile(some_file); | |
114 } | |
115 | |
116 SensorDataIio sensor_data; | |
117 InitSensorDataForTest(rows, &sensor_data); | |
118 | |
119 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
120 EXPECT_FALSE(reader); | |
121 } | |
122 | |
123 // Simulate a sensor, which has only one file to be read from. | |
124 TEST_F(SensorReaderTest, ReadValueFromOneFile) { | |
125 const size_t rows = 1; | |
126 const double value1 = 20; | |
127 const double zero_value = 0; | |
128 // Create a test sensor file, which must be found to be read from. | |
129 base::FilePath temp_sensor_file = sensors_dir_.Append(kSensorFileNameTest1); | |
130 CreateFile(temp_sensor_file); | |
131 | |
132 // Initialize sensor data for a reader. | |
133 SensorDataIio sensor_data; | |
134 InitSensorDataForTest(rows, &sensor_data); | |
135 | |
136 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
137 EXPECT_TRUE(reader); | |
138 | |
139 // Write a value to the file. | |
140 WriteReadingFieldToFile(temp_sensor_file, value1); | |
141 | |
142 // Fill SensorReading's first field with read value. Other fields must | |
143 // be 0. | |
144 SensorReading reading; | |
145 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
146 CheckSensorDataFields(reading, value1, zero_value, zero_value); | |
147 } | |
148 | |
149 // Simulate a sensor, which has two files to be read from. | |
150 TEST_F(SensorReaderTest, ReadValuesFromTwoFiles) { | |
151 const size_t rows = 2; | |
152 const double value1 = 20; | |
153 const double value2 = 50; | |
154 const double zero_value = 0; | |
155 // Create a test sensor file, which must be found. | |
156 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
157 CreateFile(temp_sensor_file1); | |
158 | |
159 // Create another test sensor file, which must be found. | |
160 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
161 CreateFile(temp_sensor_file2); | |
162 | |
163 // Initialize sensor data for a reader. | |
164 SensorDataIio sensor_data; | |
165 InitSensorDataForTest(rows, &sensor_data); | |
166 | |
167 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
168 EXPECT_TRUE(reader); | |
169 | |
170 // Write a value to the file. | |
171 WriteReadingFieldToFile(temp_sensor_file1, value1); | |
172 WriteReadingFieldToFile(temp_sensor_file2, value2); | |
173 | |
174 // Fill SensorReading's two first fields with read value. Last field must | |
175 // be 0. | |
176 SensorReading reading; | |
177 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
178 CheckSensorDataFields(reading, value1, value2, zero_value); | |
179 } | |
180 | |
181 // Simulate a sensor, which has the files to be read from. | |
182 // After read is successful, remove one of the files and try | |
183 // to read again. Reading must fail then. | |
184 TEST_F(SensorReaderTest, ReadValuesFromThreeFilesAndFail) { | |
185 const size_t rows = 4; | |
186 const double value1 = 20; | |
187 const double value2 = 50; | |
188 const double value3 = 80; | |
189 const double zero_value = 0; | |
190 // Create a test sensor file, which must be found. | |
191 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
192 CreateFile(temp_sensor_file1); | |
193 | |
194 // Create another test sensor file, which must be found. | |
195 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
196 CreateFile(temp_sensor_file2); | |
197 | |
198 // Create third test sensor file, which must be found. | |
199 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
200 CreateFile(temp_sensor_file3); | |
201 | |
202 // Initialize sensor data for a reader. | |
203 SensorDataIio sensor_data; | |
204 InitSensorDataForTest(rows, &sensor_data); | |
205 | |
206 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
207 EXPECT_TRUE(reader); | |
208 | |
209 // Write a value to the file. | |
210 WriteReadingFieldToFile(temp_sensor_file1, value1); | |
211 WriteReadingFieldToFile(temp_sensor_file2, value2); | |
212 WriteReadingFieldToFile(temp_sensor_file3, value3); | |
213 | |
214 // Fill SensorReading's values with data from files. | |
215 SensorReading reading; | |
216 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
217 CheckSensorDataFields(reading, value1, value2, value3); | |
218 | |
219 SensorReading reading2; | |
220 DeleteFile(temp_sensor_file2); | |
221 EXPECT_FALSE(reader->ReadSensorReading(&reading2)); | |
222 CheckSensorDataFields(reading2, zero_value, zero_value, zero_value); | |
223 } | |
224 | |
225 // Fill in SensorDataIio with three arrays of files that must be found | |
226 // before creating a sensor reader. If even one file is not found, | |
227 // a sensor reader must not be created. As soon as all the files are found, | |
228 // check the reader is created. | |
229 TEST_F(SensorReaderTest, SensorReadFilesDoNotExist) { | |
230 const size_t rows = 3; | |
231 // Create a test sensor file, which must be found. Other | |
232 // files will not be created and the test must fail to create a reader. | |
233 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
234 CreateFile(temp_sensor_file1); | |
235 | |
236 // Initialize sensor data for a reader. | |
237 SensorDataIio sensor_data; | |
238 InitSensorDataForTest(rows, &sensor_data); | |
239 | |
240 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
241 EXPECT_FALSE(reader); | |
242 | |
243 // Create one more file. The reader mustn't be created as long as it | |
244 // expects three files to be found. | |
245 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
246 CreateFile(temp_sensor_file2); | |
247 | |
248 reader.reset(); | |
249 reader = SensorReader::Create(sensor_data); | |
250 EXPECT_FALSE(reader); | |
251 | |
252 // Create last file. | |
253 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
254 CreateFile(temp_sensor_file3); | |
255 | |
256 reader.reset(); | |
257 reader = SensorReader::Create(sensor_data); | |
258 EXPECT_TRUE(reader); | |
259 } | |
260 | |
261 } // namespace device | |
OLD | NEW |