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