| 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/bind.h" | |
| 6 #include "base/message_loop/message_loop.h" | |
| 7 #include "base/run_loop.h" | |
| 8 | |
| 9 #include "device/generic_sensor/fake_platform_sensor.h" | |
| 10 #include "device/generic_sensor/fake_platform_sensor_provider.h" | |
| 11 #include "device/generic_sensor/public/interfaces/sensor_provider.mojom.h" | |
| 12 | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 namespace device { | |
| 16 | |
| 17 using mojom::SensorInitParams; | |
| 18 using mojom::SensorType; | |
| 19 | |
| 20 class TestSensorCreateCallback { | |
| 21 public: | |
| 22 TestSensorCreateCallback() | |
| 23 : callback_(base::Bind(&TestSensorCreateCallback::SetResult, | |
| 24 base::Unretained(this))) {} | |
| 25 | |
| 26 scoped_refptr<PlatformSensor> WaitForResult() { | |
| 27 run_loop_.Run(); | |
| 28 scoped_refptr<PlatformSensor> sensor = sensor_; | |
| 29 sensor_ = nullptr; | |
| 30 return sensor; | |
| 31 } | |
| 32 | |
| 33 const PlatformSensorProvider::CreateSensorCallback& callback() const { | |
| 34 return callback_; | |
| 35 } | |
| 36 | |
| 37 private: | |
| 38 void SetResult(scoped_refptr<PlatformSensor> sensor) { | |
| 39 sensor_ = sensor; | |
| 40 run_loop_.Quit(); | |
| 41 } | |
| 42 | |
| 43 const PlatformSensorProvider::CreateSensorCallback callback_; | |
| 44 base::RunLoop run_loop_; | |
| 45 scoped_refptr<PlatformSensor> sensor_; | |
| 46 }; | |
| 47 | |
| 48 class PlatformSensorTestClient : public PlatformSensor::Client { | |
| 49 public: | |
| 50 PlatformSensorTestClient() | |
| 51 : notification_suspended_(false), | |
| 52 sensor_reading_changed_(false), | |
| 53 sensor_error_(false) {} | |
| 54 | |
| 55 ~PlatformSensorTestClient() override { | |
| 56 if (sensor_) | |
| 57 sensor_->RemoveClient(this); | |
| 58 } | |
| 59 | |
| 60 // PlatformSensor::Client override. | |
| 61 void OnSensorReadingChanged() override { sensor_reading_changed_ = true; } | |
| 62 | |
| 63 void OnSensorError() override { sensor_error_ = true; } | |
| 64 | |
| 65 bool IsNotificationSuspended() override { return notification_suspended_; } | |
| 66 | |
| 67 void set_notification_suspended(bool value) { | |
| 68 notification_suspended_ = value; | |
| 69 } | |
| 70 | |
| 71 void SetSensor(scoped_refptr<PlatformSensor> sensor) { | |
| 72 sensor_ = sensor; | |
| 73 sensor_->AddClient(this); | |
| 74 } | |
| 75 | |
| 76 bool sensor_reading_changed() const { return sensor_reading_changed_; } | |
| 77 | |
| 78 bool sensor_error() const { return sensor_error_; } | |
| 79 | |
| 80 private: | |
| 81 scoped_refptr<PlatformSensor> sensor_; | |
| 82 bool notification_suspended_; | |
| 83 bool sensor_reading_changed_; | |
| 84 bool sensor_error_; | |
| 85 }; | |
| 86 | |
| 87 class PlatformSensorProviderTest : public ::testing::Test { | |
| 88 public: | |
| 89 PlatformSensorProviderTest() | |
| 90 : provider_(new FakePlatformSensorProvider()), | |
| 91 sensor_client_(new PlatformSensorTestClient()), | |
| 92 message_loop_(new base::MessageLoopForIO) {} | |
| 93 | |
| 94 protected: | |
| 95 scoped_refptr<PlatformSensor> CreateSensor( | |
| 96 mojom::SensorType type, | |
| 97 TestSensorCreateCallback* callback) { | |
| 98 provider_->CreateSensor(type, callback->callback()); | |
| 99 return callback->WaitForResult(); | |
| 100 } | |
| 101 | |
| 102 std::unique_ptr<FakePlatformSensorProvider> provider_; | |
| 103 std::unique_ptr<PlatformSensorTestClient> sensor_client_; | |
| 104 std::unique_ptr<base::MessageLoop> message_loop_; | |
| 105 }; | |
| 106 | |
| 107 TEST_F(PlatformSensorProviderTest, CreateSensorsAndCheckType) { | |
| 108 { | |
| 109 TestSensorCreateCallback callback; | |
| 110 scoped_refptr<PlatformSensor> sensor = | |
| 111 CreateSensor(SensorType::AMBIENT_LIGHT, &callback); | |
| 112 EXPECT_TRUE(sensor); | |
| 113 EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor->GetType()); | |
| 114 } | |
| 115 | |
| 116 { | |
| 117 TestSensorCreateCallback callback; | |
| 118 scoped_refptr<PlatformSensor> sensor = | |
| 119 CreateSensor(SensorType::PROXIMITY, &callback); | |
| 120 EXPECT_TRUE(sensor); | |
| 121 EXPECT_EQ(SensorType::PROXIMITY, sensor->GetType()); | |
| 122 } | |
| 123 | |
| 124 { | |
| 125 TestSensorCreateCallback callback; | |
| 126 scoped_refptr<PlatformSensor> sensor = | |
| 127 CreateSensor(SensorType::ACCELEROMETER, &callback); | |
| 128 EXPECT_TRUE(sensor); | |
| 129 EXPECT_EQ(SensorType::ACCELEROMETER, sensor->GetType()); | |
| 130 } | |
| 131 | |
| 132 { | |
| 133 TestSensorCreateCallback callback; | |
| 134 scoped_refptr<PlatformSensor> sensor = | |
| 135 CreateSensor(SensorType::LINEAR_ACCELERATION, &callback); | |
| 136 EXPECT_TRUE(sensor); | |
| 137 EXPECT_EQ(SensorType::LINEAR_ACCELERATION, sensor->GetType()); | |
| 138 } | |
| 139 | |
| 140 { | |
| 141 TestSensorCreateCallback callback; | |
| 142 scoped_refptr<PlatformSensor> sensor = | |
| 143 CreateSensor(SensorType::GYROSCOPE, &callback); | |
| 144 EXPECT_TRUE(sensor); | |
| 145 EXPECT_EQ(SensorType::GYROSCOPE, sensor->GetType()); | |
| 146 } | |
| 147 | |
| 148 { | |
| 149 TestSensorCreateCallback callback; | |
| 150 scoped_refptr<PlatformSensor> sensor = | |
| 151 CreateSensor(SensorType::MAGNETOMETER, &callback); | |
| 152 EXPECT_TRUE(sensor); | |
| 153 EXPECT_EQ(SensorType::MAGNETOMETER, sensor->GetType()); | |
| 154 } | |
| 155 | |
| 156 { | |
| 157 TestSensorCreateCallback callback; | |
| 158 scoped_refptr<PlatformSensor> sensor = | |
| 159 CreateSensor(SensorType::PRESSURE, &callback); | |
| 160 EXPECT_TRUE(sensor); | |
| 161 EXPECT_EQ(SensorType::PRESSURE, sensor->GetType()); | |
| 162 } | |
| 163 | |
| 164 { | |
| 165 TestSensorCreateCallback callback; | |
| 166 scoped_refptr<PlatformSensor> sensor = | |
| 167 CreateSensor(SensorType::ABSOLUTE_ORIENTATION, &callback); | |
| 168 EXPECT_TRUE(sensor); | |
| 169 EXPECT_EQ(SensorType::ABSOLUTE_ORIENTATION, sensor->GetType()); | |
| 170 } | |
| 171 | |
| 172 { | |
| 173 TestSensorCreateCallback callback; | |
| 174 scoped_refptr<PlatformSensor> sensor = | |
| 175 CreateSensor(SensorType::RELATIVE_ORIENTATION, &callback); | |
| 176 EXPECT_TRUE(sensor); | |
| 177 EXPECT_EQ(SensorType::RELATIVE_ORIENTATION, sensor->GetType()); | |
| 178 } | |
| 179 } | |
| 180 | |
| 181 TEST_F(PlatformSensorProviderTest, CreateAndGetSensor) { | |
| 182 // Create Ambient Light sensor. | |
| 183 TestSensorCreateCallback callback1; | |
| 184 scoped_refptr<PlatformSensor> sensor1 = | |
| 185 CreateSensor(SensorType::AMBIENT_LIGHT, &callback1); | |
| 186 EXPECT_TRUE(sensor1); | |
| 187 EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType()); | |
| 188 | |
| 189 // Try to get Gyroscope sensor, which has not been created yet. | |
| 190 scoped_refptr<PlatformSensor> sensor2 = | |
| 191 provider_->GetSensor(SensorType::GYROSCOPE); | |
| 192 EXPECT_FALSE(sensor2); | |
| 193 | |
| 194 // Get Ambient Light sensor. | |
| 195 scoped_refptr<PlatformSensor> sensor3 = | |
| 196 provider_->GetSensor(SensorType::AMBIENT_LIGHT); | |
| 197 EXPECT_TRUE(sensor3); | |
| 198 | |
| 199 EXPECT_EQ(sensor1->GetType(), sensor3->GetType()); | |
| 200 } | |
| 201 | |
| 202 TEST_F(PlatformSensorProviderTest, CreateAndRemoveSensors) { | |
| 203 TestSensorCreateCallback callback1; | |
| 204 scoped_refptr<PlatformSensor> sensor1 = | |
| 205 CreateSensor(SensorType::AMBIENT_LIGHT, &callback1); | |
| 206 EXPECT_TRUE(sensor1); | |
| 207 | |
| 208 TestSensorCreateCallback callback2; | |
| 209 scoped_refptr<PlatformSensor> sensor2 = | |
| 210 CreateSensor(SensorType::PROXIMITY, &callback2); | |
| 211 EXPECT_TRUE(sensor2); | |
| 212 | |
| 213 EXPECT_TRUE(provider_->HasSensors()); | |
| 214 | |
| 215 EXPECT_CALL(*provider_, AllSensorsRemoved()).Times(1); | |
| 216 | |
| 217 sensor1 = nullptr; | |
| 218 sensor2 = nullptr; | |
| 219 | |
| 220 EXPECT_FALSE(provider_->HasSensors()); | |
| 221 } | |
| 222 | |
| 223 TEST_F(PlatformSensorProviderTest, TestSensorLeaks) { | |
| 224 // Create Ambient Light sensor. | |
| 225 TestSensorCreateCallback callback1; | |
| 226 scoped_refptr<PlatformSensor> sensor1 = | |
| 227 CreateSensor(SensorType::AMBIENT_LIGHT, &callback1); | |
| 228 EXPECT_TRUE(sensor1); | |
| 229 EXPECT_EQ(SensorType::AMBIENT_LIGHT, sensor1->GetType()); | |
| 230 | |
| 231 // Sensor should be automatically destroyed. | |
| 232 sensor1 = nullptr; | |
| 233 scoped_refptr<PlatformSensor> sensor2 = | |
| 234 provider_->GetSensor(SensorType::AMBIENT_LIGHT); | |
| 235 EXPECT_FALSE(sensor2); | |
| 236 } | |
| 237 | |
| 238 // This test assumes that a mock sensor has a constant maximum frequency value | |
| 239 // of 50 hz (different from the base sensor class that has a range from 0 to | |
| 240 // 60) and tests whether a mock sensor can be started with a value range from 0 | |
| 241 // to 60. | |
| 242 TEST_F(PlatformSensorProviderTest, StartListeningWithDifferentParameters) { | |
| 243 const double too_high_frequency = 60; | |
| 244 const double normal_frequency = 39; | |
| 245 TestSensorCreateCallback callback; | |
| 246 scoped_refptr<PlatformSensor> sensor = | |
| 247 CreateSensor(SensorType::AMBIENT_LIGHT, &callback); | |
| 248 FakePlatformSensor* fake_sensor = | |
| 249 static_cast<FakePlatformSensor*>(sensor.get()); | |
| 250 EXPECT_TRUE(fake_sensor); | |
| 251 sensor_client_->SetSensor(sensor); | |
| 252 | |
| 253 PlatformSensorConfiguration config(too_high_frequency); | |
| 254 EXPECT_EQ(too_high_frequency, config.frequency()); | |
| 255 EXPECT_FALSE(fake_sensor->StartListening(sensor_client_.get(), config)); | |
| 256 EXPECT_FALSE(fake_sensor->started()); | |
| 257 | |
| 258 config.set_frequency(normal_frequency); | |
| 259 EXPECT_EQ(normal_frequency, config.frequency()); | |
| 260 EXPECT_TRUE(fake_sensor->StartListening(sensor_client_.get(), config)); | |
| 261 EXPECT_TRUE(fake_sensor->started()); | |
| 262 | |
| 263 EXPECT_TRUE(fake_sensor->StopListening(sensor_client_.get(), config)); | |
| 264 EXPECT_FALSE(fake_sensor->started()); | |
| 265 } | |
| 266 | |
| 267 // If a client is in a suspended mode, a NotifySensorReadingChanged() | |
| 268 // notification must not be sent to the client but NotifySensorError() must be. | |
| 269 TEST_F(PlatformSensorProviderTest, TestNotificationSuspended) { | |
| 270 const int num = 5; | |
| 271 TestSensorCreateCallback callback; | |
| 272 scoped_refptr<PlatformSensor> sensor = | |
| 273 CreateSensor(SensorType::GYROSCOPE, &callback); | |
| 274 FakePlatformSensor* fake_sensor = | |
| 275 static_cast<FakePlatformSensor*>(sensor.get()); | |
| 276 | |
| 277 std::vector<std::unique_ptr<PlatformSensorTestClient>> clients; | |
| 278 for (int i = 0; i < num; i++) { | |
| 279 std::unique_ptr<PlatformSensorTestClient> client( | |
| 280 new PlatformSensorTestClient()); | |
| 281 client->SetSensor(fake_sensor); | |
| 282 clients.push_back(std::move(client)); | |
| 283 } | |
| 284 | |
| 285 clients.front()->set_notification_suspended(true); | |
| 286 fake_sensor->NotifySensorReadingChanged(); | |
| 287 fake_sensor->NotifySensorError(); | |
| 288 for (auto const& client : clients) { | |
| 289 if (client == clients.front()) { | |
| 290 EXPECT_FALSE(client->sensor_reading_changed()); | |
| 291 EXPECT_TRUE(client->sensor_error()); | |
| 292 continue; | |
| 293 } | |
| 294 EXPECT_TRUE(client->sensor_reading_changed()); | |
| 295 EXPECT_TRUE(client->sensor_error()); | |
| 296 } | |
| 297 | |
| 298 clients.front()->set_notification_suspended(false); | |
| 299 fake_sensor->NotifySensorReadingChanged(); | |
| 300 fake_sensor->NotifySensorError(); | |
| 301 for (auto const& client : clients) { | |
| 302 EXPECT_TRUE(client->sensor_reading_changed()); | |
| 303 EXPECT_TRUE(client->sensor_error()); | |
| 304 } | |
| 305 } | |
| 306 | |
| 307 // Tests that when all clients are removed, config maps are removed as well. | |
| 308 TEST_F(PlatformSensorProviderTest, TestAddRemoveClients) { | |
| 309 const int num = 5; | |
| 310 | |
| 311 TestSensorCreateCallback callback; | |
| 312 scoped_refptr<PlatformSensor> sensor = | |
| 313 CreateSensor(SensorType::AMBIENT_LIGHT, &callback); | |
| 314 FakePlatformSensor* fake_sensor = | |
| 315 static_cast<FakePlatformSensor*>(sensor.get()); | |
| 316 EXPECT_TRUE(fake_sensor->config_map().empty()); | |
| 317 | |
| 318 std::vector<std::unique_ptr<PlatformSensorTestClient>> clients; | |
| 319 PlatformSensorConfiguration config(30); | |
| 320 for (int i = 0; i < num; i++) { | |
| 321 std::unique_ptr<PlatformSensorTestClient> client( | |
| 322 new PlatformSensorTestClient()); | |
| 323 client->SetSensor(fake_sensor); | |
| 324 EXPECT_TRUE(fake_sensor->StartListening(client.get(), config)); | |
| 325 EXPECT_TRUE(fake_sensor->started()); | |
| 326 | |
| 327 clients.push_back(std::move(client)); | |
| 328 } | |
| 329 EXPECT_FALSE(fake_sensor->config_map().empty()); | |
| 330 | |
| 331 for (const auto& client : clients) | |
| 332 fake_sensor->RemoveClient(client.get()); | |
| 333 | |
| 334 EXPECT_TRUE(fake_sensor->config_map().empty()); | |
| 335 } | |
| 336 | |
| 337 // Tests a sensor cannot be updated if it has one suspended client. | |
| 338 TEST_F(PlatformSensorProviderTest, TestUpdateSensorOneClient) { | |
| 339 TestSensorCreateCallback callback; | |
| 340 scoped_refptr<PlatformSensor> sensor = | |
| 341 CreateSensor(SensorType::AMBIENT_LIGHT, &callback); | |
| 342 FakePlatformSensor* fake_sensor = | |
| 343 static_cast<FakePlatformSensor*>(sensor.get()); | |
| 344 EXPECT_TRUE(fake_sensor->config_map().empty()); | |
| 345 | |
| 346 sensor_client_->SetSensor(fake_sensor); | |
| 347 | |
| 348 PlatformSensorConfiguration config(30); | |
| 349 fake_sensor->StartListening(sensor_client_.get(), config); | |
| 350 | |
| 351 sensor_client_->set_notification_suspended(true); | |
| 352 EXPECT_TRUE(sensor_client_->IsNotificationSuspended()); | |
| 353 | |
| 354 fake_sensor->UpdateSensor(); | |
| 355 EXPECT_FALSE(fake_sensor->started()); | |
| 356 | |
| 357 sensor_client_->set_notification_suspended(false); | |
| 358 EXPECT_FALSE(sensor_client_->IsNotificationSuspended()); | |
| 359 | |
| 360 fake_sensor->UpdateSensor(); | |
| 361 EXPECT_TRUE(fake_sensor->started()); | |
| 362 } | |
| 363 | |
| 364 // Tests a sensor can be updated if it has one suspended client and other | |
| 365 // clients are not suspended. | |
| 366 TEST_F(PlatformSensorProviderTest, TestUpdateSensorManyClients) { | |
| 367 const int num = 5; | |
| 368 | |
| 369 TestSensorCreateCallback callback; | |
| 370 scoped_refptr<PlatformSensor> sensor = | |
| 371 CreateSensor(SensorType::AMBIENT_LIGHT, &callback); | |
| 372 FakePlatformSensor* fake_sensor = | |
| 373 static_cast<FakePlatformSensor*>(sensor.get()); | |
| 374 EXPECT_TRUE(fake_sensor->config_map().empty()); | |
| 375 | |
| 376 sensor_client_->SetSensor(fake_sensor); | |
| 377 std::vector<std::unique_ptr<PlatformSensorTestClient>> clients; | |
| 378 for (int i = 0; i < num; i++) { | |
| 379 std::unique_ptr<PlatformSensorTestClient> client( | |
| 380 new PlatformSensorTestClient()); | |
| 381 client->SetSensor(fake_sensor); | |
| 382 clients.push_back(std::move(client)); | |
| 383 } | |
| 384 | |
| 385 double sensor_frequency = 30; | |
| 386 PlatformSensorConfiguration config(sensor_frequency++); | |
| 387 fake_sensor->StartListening(sensor_client_.get(), config); | |
| 388 for (const auto& client : clients) { | |
| 389 PlatformSensorConfiguration config(sensor_frequency++); | |
| 390 fake_sensor->StartListening(client.get(), config); | |
| 391 } | |
| 392 | |
| 393 sensor_client_->set_notification_suspended(true); | |
| 394 EXPECT_TRUE(sensor_client_->IsNotificationSuspended()); | |
| 395 for (const auto& client : clients) | |
| 396 EXPECT_FALSE(client->IsNotificationSuspended()); | |
| 397 | |
| 398 fake_sensor->UpdateSensor(); | |
| 399 EXPECT_TRUE(fake_sensor->started()); | |
| 400 | |
| 401 sensor_client_->set_notification_suspended(false); | |
| 402 EXPECT_FALSE(sensor_client_->IsNotificationSuspended()); | |
| 403 for (const auto& client : clients) | |
| 404 EXPECT_FALSE(client->IsNotificationSuspended()); | |
| 405 | |
| 406 fake_sensor->UpdateSensor(); | |
| 407 EXPECT_TRUE(fake_sensor->started()); | |
| 408 } | |
| 409 | |
| 410 } // namespace device | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2865263002:
Move //device/generic_sensor to be part of the internal implementation of the Device Service. (Closed)
