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 | |
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[][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, NULL, 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::ScopedTempDir sensors_dir; | |
Mikhail
2016/10/19 13:10:13
pls use just 'base::CreateDirectory(path)' instead
maksims (do not use this acc)
2016/10/19 13:25:57
Done.
| |
60 ASSERT_TRUE(sensors_dir.Set(base_temp_dir_.GetPath().Append(kDevice0Dir))); | |
61 sensors_dir_ = sensors_dir.Take(); | |
62 } | |
63 | |
64 void TearDown() override { ASSERT_TRUE(base_temp_dir_.Delete()); } | |
65 | |
66 void InitSensorDataForTest(const base::FilePath& base_dir, | |
67 size_t rows, | |
68 SensorDataIio* 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_iio = base_dir.value().c_str(); | |
Mikhail
2016/10/19 13:10:13
data->base_path_sensor_iio will contain garbage af
maksims (do not use this acc)
2016/10/19 13:25:57
Done.
| |
77 for (size_t i = 0; i < rows; ++i) { | |
78 data->sensor_file_names[i] = &kTestSensorFileNamesTest[i][0]; | |
79 } | |
80 data->sensor_file_names_cols = arraysize(*kTestSensorFileNamesTest); | |
81 data->sensor_file_names_rows = rows; | |
82 } | |
83 | |
84 void CheckSensorDataFields(const SensorReading& data, | |
85 double value1, | |
86 double value2, | |
87 double value3) { | |
88 EXPECT_EQ(value1, data.values[0]); | |
89 EXPECT_EQ(value2, data.values[1]); | |
90 EXPECT_EQ(value3, data.values[2]); | |
91 } | |
92 | |
93 protected: | |
94 base::FilePath sensors_dir_; | |
95 base::ScopedTempDir base_temp_dir_; | |
96 }; | |
97 | |
98 TEST_F(SensorReaderTest, FileDoesNotExist) { | |
99 const char* kGiberishFiles[] = {"temp1", "temp2", "temp3", "temp4"}; | |
100 const size_t rows = 3; | |
101 // Create some gibberish files that we are not interested in. | |
102 for (unsigned int i = 0; i < arraysize(kGiberishFiles); ++i) { | |
103 base::FilePath some_file = sensors_dir_.Append(kGiberishFiles[i]); | |
104 CreateFile(some_file); | |
105 } | |
106 | |
107 SensorDataIio sensor_data; | |
108 InitSensorDataForTest(base_temp_dir_.GetPath(), rows, &sensor_data); | |
109 | |
110 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
111 EXPECT_FALSE(reader); | |
112 } | |
113 | |
114 TEST_F(SensorReaderTest, ReadValueFromOneFile) { | |
115 const size_t rows = 1; | |
116 const double value1 = 20; | |
117 const double zero_value = 0; | |
118 // Create a test sensor file, which must be found to be read from. | |
119 base::FilePath temp_sensor_file = sensors_dir_.Append(kSensorFileNameTest1); | |
120 CreateFile(temp_sensor_file); | |
121 | |
122 // Initialize sensor data for a reader. | |
123 SensorDataIio sensor_data; | |
124 InitSensorDataForTest(base_temp_dir_.GetPath(), rows, &sensor_data); | |
125 | |
126 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
127 EXPECT_TRUE(reader); | |
128 | |
129 // Write a value to the file. | |
130 WriteReadingFieldToFile(temp_sensor_file, value1); | |
131 | |
132 // Fill SensorReading's first field with read value. Other fields must | |
133 // be 0. | |
134 SensorReading reading; | |
135 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
136 CheckSensorDataFields(reading, value1, zero_value, zero_value); | |
137 } | |
138 | |
139 TEST_F(SensorReaderTest, ReadValuesFromTwoFiles) { | |
140 const size_t rows = 2; | |
141 const double value1 = 20; | |
142 const double value2 = 50; | |
143 const double zero_value = 0; | |
144 // Create a test sensor file, which must be found. | |
145 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
146 CreateFile(temp_sensor_file1); | |
147 | |
148 // Create another test sensor file, which must be found. | |
149 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
150 CreateFile(temp_sensor_file2); | |
151 | |
152 // Initialize sensor data for a reader. | |
153 SensorDataIio sensor_data; | |
154 InitSensorDataForTest(base_temp_dir_.GetPath(), rows, &sensor_data); | |
155 | |
156 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
157 EXPECT_TRUE(reader); | |
158 | |
159 // Write a value to the file. | |
160 WriteReadingFieldToFile(temp_sensor_file1, value1); | |
161 WriteReadingFieldToFile(temp_sensor_file2, value2); | |
162 | |
163 // Fill SensorReading's two first fields with read value. Last field must | |
164 // be 0. | |
165 SensorReading reading; | |
166 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
167 CheckSensorDataFields(reading, value1, value2, zero_value); | |
168 } | |
169 | |
170 TEST_F(SensorReaderTest, ReadValuesFromThreeFilesAndFail) { | |
171 const size_t rows = 4; | |
172 const double value1 = 20; | |
173 const double value2 = 50; | |
174 const double value3 = 80; | |
175 const double zero_value = 0; | |
176 // Create a test sensor file, which must be found. | |
177 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
178 CreateFile(temp_sensor_file1); | |
179 | |
180 // Create another test sensor file, which must be found. | |
181 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
182 CreateFile(temp_sensor_file2); | |
183 | |
184 // Create third test sensor file, which must be found. | |
185 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
186 CreateFile(temp_sensor_file3); | |
187 | |
188 // Initialize sensor data for a reader. | |
189 SensorDataIio sensor_data; | |
190 InitSensorDataForTest(base_temp_dir_.GetPath(), rows, &sensor_data); | |
191 | |
192 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
193 EXPECT_TRUE(reader); | |
194 | |
195 // Write a value to the file. | |
196 WriteReadingFieldToFile(temp_sensor_file1, value1); | |
197 WriteReadingFieldToFile(temp_sensor_file2, value2); | |
198 WriteReadingFieldToFile(temp_sensor_file3, value3); | |
199 | |
200 // Fill SensorReading's values with data from files. | |
201 SensorReading reading; | |
202 EXPECT_TRUE(reader->ReadSensorReading(&reading)); | |
203 CheckSensorDataFields(reading, value1, value2, value3); | |
204 | |
205 SensorReading reading2; | |
206 DeleteFile(temp_sensor_file2); | |
207 EXPECT_FALSE(reader->ReadSensorReading(&reading2)); | |
208 CheckSensorDataFields(reading2, zero_value, zero_value, zero_value); | |
209 } | |
210 | |
211 TEST_F(SensorReaderTest, SensorReadFilesDoNotExist) { | |
212 const size_t rows = 3; | |
213 // Create a test sensor file, which must be found. Other | |
214 // files will not be created and the test must fail to create a reader. | |
215 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); | |
216 CreateFile(temp_sensor_file1); | |
217 | |
218 // Initialize sensor data for a reader. | |
219 SensorDataIio sensor_data; | |
220 InitSensorDataForTest(base_temp_dir_.GetPath(), rows, &sensor_data); | |
221 | |
222 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); | |
223 EXPECT_FALSE(reader); | |
224 | |
225 // Create one more file. The reader mustn't be created as long as it | |
226 // expects three files to be found. | |
227 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); | |
228 CreateFile(temp_sensor_file2); | |
229 | |
230 reader.reset(); | |
231 reader = SensorReader::Create(sensor_data); | |
232 EXPECT_FALSE(reader); | |
233 | |
234 // Create last file. | |
235 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); | |
236 CreateFile(temp_sensor_file3); | |
237 | |
238 reader.reset(); | |
239 reader = SensorReader::Create(sensor_data); | |
240 EXPECT_TRUE(reader); | |
241 } | |
242 | |
243 } // namespace device | |
OLD | NEW |