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_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 SensorDataIio with values for a sensor reader. |
| 68 void InitSensorDataForTest(size_t rows, 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(); |
| 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 // Check SensorReading values are properly read. |
| 85 void CheckSensorDataFields(const SensorReading& data, |
| 86 double value1, |
| 87 double value2, |
| 88 double value3) { |
| 89 EXPECT_EQ(value1, data.values[0]); |
| 90 EXPECT_EQ(value2, data.values[1]); |
| 91 EXPECT_EQ(value3, data.values[2]); |
| 92 } |
| 93 |
| 94 protected: |
| 95 // Holds a path to a sensor dir that is located in |base_dir_| |
| 96 base::FilePath sensors_dir_; |
| 97 // Holds a path to a base dir. |
| 98 base::FilePath base_dir_; |
| 99 // Holds base dir where a sensor dir is located. |
| 100 base::ScopedTempDir base_temp_dir_; |
| 101 }; |
| 102 |
| 103 // Test a reader is not created if sensor read files |
| 104 // do not exist. |
| 105 TEST_F(SensorReaderTest, FileDoesNotExist) { |
| 106 const char* kGiberishFiles[] = {"temp1", "temp2", "temp3", "temp4"}; |
| 107 const size_t rows = 3; |
| 108 // Create some gibberish files that we are not interested in. |
| 109 for (unsigned int i = 0; i < arraysize(kGiberishFiles); ++i) { |
| 110 base::FilePath some_file = sensors_dir_.Append(kGiberishFiles[i]); |
| 111 CreateFile(some_file); |
| 112 } |
| 113 |
| 114 SensorDataIio sensor_data; |
| 115 InitSensorDataForTest(rows, &sensor_data); |
| 116 |
| 117 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); |
| 118 EXPECT_FALSE(reader); |
| 119 } |
| 120 |
| 121 // Simulate a sensor, which has only one file to be read from. |
| 122 TEST_F(SensorReaderTest, ReadValueFromOneFile) { |
| 123 const size_t rows = 1; |
| 124 const double value1 = 20; |
| 125 const double zero_value = 0; |
| 126 // Create a test sensor file, which must be found to be read from. |
| 127 base::FilePath temp_sensor_file = sensors_dir_.Append(kSensorFileNameTest1); |
| 128 CreateFile(temp_sensor_file); |
| 129 |
| 130 // Initialize sensor data for a reader. |
| 131 SensorDataIio sensor_data; |
| 132 InitSensorDataForTest(rows, &sensor_data); |
| 133 |
| 134 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); |
| 135 EXPECT_TRUE(reader); |
| 136 |
| 137 // Write a value to the file. |
| 138 WriteReadingFieldToFile(temp_sensor_file, value1); |
| 139 |
| 140 // Fill SensorReading's first field with read value. Other fields must |
| 141 // be 0. |
| 142 SensorReading reading; |
| 143 EXPECT_TRUE(reader->ReadSensorReading(&reading)); |
| 144 CheckSensorDataFields(reading, value1, zero_value, zero_value); |
| 145 } |
| 146 |
| 147 // Simulate a sensor, which has two files to be read from. |
| 148 TEST_F(SensorReaderTest, ReadValuesFromTwoFiles) { |
| 149 const size_t rows = 2; |
| 150 const double value1 = 20; |
| 151 const double value2 = 50; |
| 152 const double zero_value = 0; |
| 153 // Create a test sensor file, which must be found. |
| 154 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); |
| 155 CreateFile(temp_sensor_file1); |
| 156 |
| 157 // Create another test sensor file, which must be found. |
| 158 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); |
| 159 CreateFile(temp_sensor_file2); |
| 160 |
| 161 // Initialize sensor data for a reader. |
| 162 SensorDataIio sensor_data; |
| 163 InitSensorDataForTest(rows, &sensor_data); |
| 164 |
| 165 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); |
| 166 EXPECT_TRUE(reader); |
| 167 |
| 168 // Write a value to the file. |
| 169 WriteReadingFieldToFile(temp_sensor_file1, value1); |
| 170 WriteReadingFieldToFile(temp_sensor_file2, value2); |
| 171 |
| 172 // Fill SensorReading's two first fields with read value. Last field must |
| 173 // be 0. |
| 174 SensorReading reading; |
| 175 EXPECT_TRUE(reader->ReadSensorReading(&reading)); |
| 176 CheckSensorDataFields(reading, value1, value2, zero_value); |
| 177 } |
| 178 |
| 179 // Simulate a sensor, which has the files to be read from. |
| 180 // After read is successful, remove one of the files and try |
| 181 // to read again. Reading must fail then. |
| 182 TEST_F(SensorReaderTest, ReadValuesFromThreeFilesAndFail) { |
| 183 const size_t rows = 4; |
| 184 const double value1 = 20; |
| 185 const double value2 = 50; |
| 186 const double value3 = 80; |
| 187 const double zero_value = 0; |
| 188 // Create a test sensor file, which must be found. |
| 189 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); |
| 190 CreateFile(temp_sensor_file1); |
| 191 |
| 192 // Create another test sensor file, which must be found. |
| 193 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); |
| 194 CreateFile(temp_sensor_file2); |
| 195 |
| 196 // Create third test sensor file, which must be found. |
| 197 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); |
| 198 CreateFile(temp_sensor_file3); |
| 199 |
| 200 // Initialize sensor data for a reader. |
| 201 SensorDataIio sensor_data; |
| 202 InitSensorDataForTest(rows, &sensor_data); |
| 203 |
| 204 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); |
| 205 EXPECT_TRUE(reader); |
| 206 |
| 207 // Write a value to the file. |
| 208 WriteReadingFieldToFile(temp_sensor_file1, value1); |
| 209 WriteReadingFieldToFile(temp_sensor_file2, value2); |
| 210 WriteReadingFieldToFile(temp_sensor_file3, value3); |
| 211 |
| 212 // Fill SensorReading's values with data from files. |
| 213 SensorReading reading; |
| 214 EXPECT_TRUE(reader->ReadSensorReading(&reading)); |
| 215 CheckSensorDataFields(reading, value1, value2, value3); |
| 216 |
| 217 SensorReading reading2; |
| 218 DeleteFile(temp_sensor_file2); |
| 219 EXPECT_FALSE(reader->ReadSensorReading(&reading2)); |
| 220 CheckSensorDataFields(reading2, zero_value, zero_value, zero_value); |
| 221 } |
| 222 |
| 223 // Fill in SensorDataIio with three arrays of files that must be found |
| 224 // before creating a sensor reader. If even one file is not found, |
| 225 // a sensor reader must not be created. As soon as all the files are found, |
| 226 // check the reader is created. |
| 227 TEST_F(SensorReaderTest, SensorReadFilesDoNotExist) { |
| 228 const size_t rows = 3; |
| 229 // Create a test sensor file, which must be found. Other |
| 230 // files will not be created and the test must fail to create a reader. |
| 231 base::FilePath temp_sensor_file1 = sensors_dir_.Append(kSensorFileNameTest1); |
| 232 CreateFile(temp_sensor_file1); |
| 233 |
| 234 // Initialize sensor data for a reader. |
| 235 SensorDataIio sensor_data; |
| 236 InitSensorDataForTest(rows, &sensor_data); |
| 237 |
| 238 std::unique_ptr<SensorReader> reader = SensorReader::Create(sensor_data); |
| 239 EXPECT_FALSE(reader); |
| 240 |
| 241 // Create one more file. The reader mustn't be created as long as it |
| 242 // expects three files to be found. |
| 243 base::FilePath temp_sensor_file2 = sensors_dir_.Append(kSensorFileNameTest2); |
| 244 CreateFile(temp_sensor_file2); |
| 245 |
| 246 reader.reset(); |
| 247 reader = SensorReader::Create(sensor_data); |
| 248 EXPECT_FALSE(reader); |
| 249 |
| 250 // Create last file. |
| 251 base::FilePath temp_sensor_file3 = sensors_dir_.Append(kSensorFileNameTest3); |
| 252 CreateFile(temp_sensor_file3); |
| 253 |
| 254 reader.reset(); |
| 255 reader = SensorReader::Create(sensor_data); |
| 256 EXPECT_TRUE(reader); |
| 257 } |
| 258 |
| 259 } // namespace device |
OLD | NEW |