platform_sensor_provider_winrt_unittest.cc 4.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107
  1. // Copyright 2019 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. #include "services/device/generic_sensor/platform_sensor_provider_winrt.h"
  5. #include "base/run_loop.h"
  6. #include "base/test/bind.h"
  7. #include "base/test/task_environment.h"
  8. #include "services/device/generic_sensor/platform_sensor_reader_win_base.h"
  9. #include "testing/gmock/include/gmock/gmock.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. namespace device {
  12. // Mock for PlatformSensorReaderWinBase, used to ensure the actual
  13. // Windows.Devices.Sensor API isn't called.
  14. class MockSensorReader : public PlatformSensorReaderWinBase {
  15. public:
  16. MockSensorReader() = default;
  17. ~MockSensorReader() override = default;
  18. MOCK_METHOD1(SetClient, void(Client* client));
  19. MOCK_CONST_METHOD0(GetMinimalReportingInterval, base::TimeDelta());
  20. MOCK_METHOD1(StartSensor,
  21. bool(const PlatformSensorConfiguration& configuration));
  22. MOCK_METHOD0(StopSensor, void());
  23. };
  24. // Mock for SensorReaderFactory, injected into
  25. // PlatformSensorProviderWinrt so it will create MockSensorReaders instead
  26. // of the real PlatformSensorReaderWinBase which calls into the WinRT APIs.
  27. class MockSensorReaderFactory : public SensorReaderFactory {
  28. public:
  29. MockSensorReaderFactory() = default;
  30. ~MockSensorReaderFactory() override = default;
  31. MOCK_METHOD1(
  32. CreateSensorReader,
  33. std::unique_ptr<PlatformSensorReaderWinBase>(mojom::SensorType type));
  34. };
  35. // Tests that PlatformSensorProviderWinrt can successfully be instantiated
  36. // and passes the correct result to the CreateSensor callback.
  37. TEST(PlatformSensorProviderTestWinrt, SensorCreationReturnCheck) {
  38. base::test::TaskEnvironment task_environment;
  39. auto mock_sensor_reader_factory =
  40. std::make_unique<testing::NiceMock<MockSensorReaderFactory>>();
  41. // Return valid PlatformSensorReaderWinBase instances for gyroscope and
  42. // accelerometer to represent them as supported/present. Return nullptr
  43. // for ambient light to represent it as not present/supported.
  44. EXPECT_CALL(*mock_sensor_reader_factory.get(),
  45. CreateSensorReader(mojom::SensorType::AMBIENT_LIGHT))
  46. .WillOnce(testing::Invoke([](mojom::SensorType) { return nullptr; }));
  47. EXPECT_CALL(*mock_sensor_reader_factory.get(),
  48. CreateSensorReader(mojom::SensorType::GYROSCOPE))
  49. .WillOnce(testing::Invoke([](mojom::SensorType) {
  50. return std::make_unique<testing::NiceMock<MockSensorReader>>();
  51. }));
  52. EXPECT_CALL(*mock_sensor_reader_factory.get(),
  53. CreateSensorReader(mojom::SensorType::ACCELEROMETER))
  54. .WillOnce(testing::Invoke([](mojom::SensorType) {
  55. return std::make_unique<testing::NiceMock<MockSensorReader>>();
  56. }));
  57. auto provider = std::make_unique<PlatformSensorProviderWinrt>();
  58. provider->SetSensorReaderFactoryForTesting(
  59. std::move(mock_sensor_reader_factory));
  60. // CreateSensor is async so use a RunLoop to wait for completion.
  61. absl::optional<base::RunLoop> run_loop;
  62. bool expect_sensor_valid = false;
  63. base::RepeatingCallback<void(scoped_refptr<PlatformSensor> sensor)>
  64. create_sensor_callback =
  65. base::BindLambdaForTesting([&](scoped_refptr<PlatformSensor> sensor) {
  66. if (expect_sensor_valid)
  67. EXPECT_TRUE(sensor);
  68. else
  69. EXPECT_FALSE(sensor);
  70. run_loop->Quit();
  71. });
  72. run_loop.emplace();
  73. provider->CreateSensor(mojom::SensorType::AMBIENT_LIGHT,
  74. base::BindOnce(create_sensor_callback));
  75. run_loop->Run();
  76. expect_sensor_valid = true;
  77. run_loop.emplace();
  78. provider->CreateSensor(mojom::SensorType::GYROSCOPE,
  79. base::BindOnce(create_sensor_callback));
  80. run_loop->Run();
  81. // Linear acceleration is a fusion sensor built on top of accelerometer,
  82. // this should trigger the CreateSensorReader(ACCELEROMETER) call.
  83. expect_sensor_valid = true;
  84. run_loop.emplace();
  85. provider->CreateSensor(mojom::SensorType::LINEAR_ACCELERATION,
  86. base::BindOnce(create_sensor_callback));
  87. run_loop->Run();
  88. }
  89. } // namespace device