[sensors] Add Generic Sensor platform unit tests.

device/generic_sensor/platform_sensor_provider_unittest.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "device/generic_sensor/mock_platform_sensor.h"
+#include "device/generic_sensor/mock_platform_sensor_provider.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace device {
+
+namespace {
+
+static const uint64_t kReadBufferSize = 32ULL;

[Mikhail, 2016/09/07 10:46:19]

that can be taken from mojom::SensorReadBuffer

[maksims (do not use this acc), 2016/09/09 10:39:06]

Done.

+
+const mojom::SensorType kAmbientLight = mojom::SensorType::AMBIENT_LIGHT;
+const mojom::SensorType kProximity = mojom::SensorType::PROXIMITY;
+const mojom::SensorType kAccelerometer = mojom::SensorType::ACCELEROMETER;
+const mojom::SensorType kGyroscope = mojom::SensorType::GYROSCOPE;
+const mojom::SensorType kPressure = mojom::SensorType::PRESSURE;

[Mikhail, 2016/09/07 10:46:19]

let's not hide the actual types, would 'using mojom::SensorType' suffice?

[maksims (do not use this acc), 2016/09/09 10:39:06]

Done.

+
+uint64_t GetBufferOffset(mojom::SensorType type) {
+  return (static_cast<uint64_t>(mojom::SensorType::LAST) -
+          static_cast<uint64_t>(type)) *
+         kReadBufferSize;
+}
+
+}  // namespace
+
+class PlatformSensorTestClient : public PlatformSensor::Client {
+ public:
+  PlatformSensorTestClient()
+      : notification_suspended_(false),
+        sensor_reading_changed_(false),
+        sensor_error_(false) {}
+
+  ~PlatformSensorTestClient() override {
+    if (sensor_)
+      sensor_->RemoveClient(this);
+  }
+
+  // PlatformSensor::Client override.
+  void OnSensorReadingChanged() override { sensor_reading_changed_ = true; }
+
+  void OnSensorError() override { sensor_error_ = true; }
+
+  bool IsNotificationSuspended() override { return notification_suspended_; }
+
+  void set_suspended(bool value) { notification_suspended_ = value; }
+
+  void set_sensor(scoped_refptr<PlatformSensor> sensor) {
+    sensor_ = sensor;
+    sensor_->AddClient(this);
+  }
+
+  bool IsSensorReadingChanged() { return sensor_reading_changed_; }
+
+  bool SensorHasError() { return sensor_error_; }
+
+  void remove_sensor(scoped_refptr<PlatformSensor> sensor) {
+    EXPECT_EQ(sensor, sensor_);
+    sensor_->RemoveClient(this);
+  }
+
+ private:
+  scoped_refptr<PlatformSensor> sensor_;
+  bool notification_suspended_;
+  bool sensor_reading_changed_;
+  bool sensor_error_;
+};
+
+class PlatformSensorProviderTest : public ::testing::Test {
+ public:
+  PlatformSensorProviderTest() {
+    sensor_client_.reset(new PlatformSensorTestClient());
+    sensor_provider_ = MockPlatformSensorProvider::GetInstance();
+    EXPECT_TRUE(sensor_provider_);
+  }
+
+ protected:
+  scoped_refptr<PlatformSensor> CreateSensor(mojom::SensorType type) {
+    return sensor_provider_->CreateSensor(type, kReadBufferSize,
+                                          GetBufferOffset(type));
+  }
+
+  PlatformSensorProvider* sensor_provider_;
+  std::unique_ptr<PlatformSensorTestClient> sensor_client_;
+};
+
+TEST_F(PlatformSensorProviderTest, CreateSensorsAndCheckType) {
+  scoped_refptr<PlatformSensor> sensor1 = sensor_provider_->CreateSensor(
+      kAmbientLight, kReadBufferSize, GetBufferOffset(kAmbientLight));
+  EXPECT_TRUE(sensor1);
+  EXPECT_EQ(kAmbientLight, sensor1->GetType());
+
+  scoped_refptr<PlatformSensor> sensor2 = sensor_provider_->CreateSensor(
+      kProximity, kReadBufferSize, GetBufferOffset(kProximity));
+  EXPECT_TRUE(sensor2);
+  EXPECT_EQ(kProximity, sensor2->GetType());
+
+  scoped_refptr<PlatformSensor> sensor3 = sensor_provider_->CreateSensor(
+      kAccelerometer, kReadBufferSize, GetBufferOffset(kAccelerometer));
+  EXPECT_TRUE(sensor3);
+  EXPECT_EQ(kAccelerometer, sensor3->GetType());
+
+  scoped_refptr<PlatformSensor> sensor4 = sensor_provider_->CreateSensor(
+      kGyroscope, kReadBufferSize, GetBufferOffset(kGyroscope));
+  EXPECT_TRUE(sensor4);
+  EXPECT_EQ(kGyroscope, sensor4->GetType());
+
+  scoped_refptr<PlatformSensor> sensor5 = sensor_provider_->CreateSensor(
+      kPressure, kReadBufferSize, GetBufferOffset(kPressure));
+  EXPECT_TRUE(sensor5);
+  EXPECT_EQ(kPressure, sensor5->GetType());
+}
+
+TEST_F(PlatformSensorProviderTest, CreateAndGetSensor) {
+  // Create Ambient Light sensor.
+  scoped_refptr<PlatformSensor> sensor1 = CreateSensor(kAmbientLight);
+  EXPECT_TRUE(sensor1);
+  EXPECT_EQ(kAmbientLight, sensor1->GetType());
+
+  // Try to get Gyroscope sensor, which has not been created yet.
+  scoped_refptr<PlatformSensor> sensor2 =
+      sensor_provider_->GetSensor(kGyroscope);
+  EXPECT_FALSE(sensor2);
+
+  // Get Ambient Light sensor.
+  scoped_refptr<PlatformSensor> sensor3 =
+      sensor_provider_->GetSensor(kAmbientLight);
+  EXPECT_TRUE(sensor3);
+
+  EXPECT_EQ(sensor1->GetType(), sensor3->GetType());
+
+  // Try to create a sensor with zero buffer and offset.
+  scoped_refptr<PlatformSensor> sensor4 =
+      sensor_provider_->CreateSensor(kGyroscope, 0, 0);
+  EXPECT_FALSE(sensor4);
+
+  scoped_refptr<PlatformSensor> sensor5 =
+      sensor_provider_->GetSensor(kGyroscope);
+  EXPECT_FALSE(sensor5);
+}
+
+// This test assumes that a mock sensor has a constant maximum frequency value
+// of 50 hz (different from the base sensor class that has a range from 0 to
+// 60) and tests whether a mock sensor can be started with a value range from 0
+// to 60.
+TEST_F(PlatformSensorProviderTest, StartListeningWithDifferentParameters) {
+  const double too_high_frequency = 60;
+  const double normal_frequency = 39;
+  scoped_refptr<PlatformSensor> sensor = CreateSensor(kAmbientLight);
+  MockPlatformSensor* mock_sensor =
+      static_cast<MockPlatformSensor*>(sensor.get());
+  EXPECT_TRUE(mock_sensor);
+  sensor_client_->set_sensor(sensor);
+
+  PlatformSensorConfiguration config(too_high_frequency);
+  EXPECT_EQ(too_high_frequency, config.frequency());
+  EXPECT_FALSE(mock_sensor->StartListening(sensor_client_.get(), config));
+  EXPECT_FALSE(mock_sensor->IsStarted());
+
+  config.set_frequency(normal_frequency);
+  EXPECT_EQ(normal_frequency, config.frequency());
+  EXPECT_TRUE(mock_sensor->StartListening(sensor_client_.get(), config));
+  EXPECT_TRUE(mock_sensor->IsStarted());
+
+  EXPECT_TRUE(mock_sensor->StopListening(sensor_client_.get(), config));
+  EXPECT_FALSE(mock_sensor->IsStarted());
+}
+
+// If a client is in a suspended mode, a NotifySensorReadingChanged()
+// notification must not be sent to the client but NotifySensorError() must be.
+TEST_F(PlatformSensorProviderTest, TestNotificationSuspended) {
+  const int num = 5;
+  scoped_refptr<PlatformSensor> sensor = CreateSensor(kGyroscope);
+  MockPlatformSensor* mock_sensor =
+      static_cast<MockPlatformSensor*>(sensor.get());
+
+  std::unique_ptr<PlatformSensorTestClient> clients[num];

[Mikhail, 2016/09/07 10:46:19]

here and below, pls. use std::vector<std::unique_ptr<PlatformSensorTestClient>>
instead.

+  for (int i = 0; i < num; i++) {
+    clients[i].reset(new PlatformSensorTestClient());
+    clients[i]->set_sensor(mock_sensor);
+  }
+
+  clients[1]->set_suspended(true);
+  mock_sensor->NotifySensorReadingChanged();
+  mock_sensor->NotifySensorError();
+  for (int i = 0; i < num; i++) {
+    if (i == 1) {
+      EXPECT_FALSE(clients[i]->IsSensorReadingChanged());
+      EXPECT_TRUE(clients[i]->SensorHasError());
+      continue;
+    }
+    EXPECT_TRUE(clients[i]->IsSensorReadingChanged());
+    EXPECT_TRUE(clients[i]->SensorHasError());
+  }
+
+  clients[1]->set_suspended(false);
+  mock_sensor->NotifySensorReadingChanged();
+  mock_sensor->NotifySensorError();
+  for (int i = 0; i < num; i++) {
+    EXPECT_TRUE(clients[i]->IsSensorReadingChanged());
+    EXPECT_TRUE(clients[i]->SensorHasError());
+  }
+}
+
+// Tests that when all clients are removed, config maps are removed as well.
+TEST_F(PlatformSensorProviderTest, TestAddRemoveClients) {
+  const int num = 5;
+  const double frq = 30;
+
+  scoped_refptr<PlatformSensor> sensor = CreateSensor(kAmbientLight);
+  MockPlatformSensor* mock_sensor =
+      static_cast<MockPlatformSensor*>(sensor.get());
+  EXPECT_TRUE(mock_sensor->GetConfigMap().empty());
+
+  std::unique_ptr<PlatformSensorTestClient> clients[num];
+  PlatformSensorConfiguration config(frq);
+  for (int i = 0; i < num; i++) {
+    clients[i].reset(new PlatformSensorTestClient());
+    clients[i]->set_sensor(mock_sensor);
+    EXPECT_TRUE(mock_sensor->StartListening(clients[i].get(), config));
+    EXPECT_TRUE(mock_sensor->IsStarted());
+  }
+  EXPECT_FALSE(mock_sensor->GetConfigMap().empty());
+
+  for (int i = 0; i < num; i++)
+    clients[i]->remove_sensor(mock_sensor);
+
+  EXPECT_TRUE(mock_sensor->GetConfigMap().empty());
+}
+
+// Tests a sensor cannot be updated if it has one suspended client.
+TEST_F(PlatformSensorProviderTest, TestUpdateSensorOneClient) {
+  const double frq = 30;
+
+  scoped_refptr<PlatformSensor> sensor = CreateSensor(kAmbientLight);
+  MockPlatformSensor* mock_sensor =
+      static_cast<MockPlatformSensor*>(sensor.get());
+  EXPECT_TRUE(mock_sensor->GetConfigMap().empty());
+
+  sensor_client_->set_sensor(mock_sensor);
+
+  PlatformSensorConfiguration config(frq);
+  mock_sensor->StartListening(sensor_client_.get(), config);
+
+  sensor_client_->set_suspended(true);
+  EXPECT_TRUE(sensor_client_->IsNotificationSuspended());
+
+  mock_sensor->UpdateSensor();
+  EXPECT_FALSE(mock_sensor->IsStarted());
+
+  sensor_client_->set_suspended(false);
+  EXPECT_FALSE(sensor_client_->IsNotificationSuspended());
+
+  mock_sensor->UpdateSensor();
+  EXPECT_TRUE(mock_sensor->IsStarted());
+}
+
+// Tests a sensor can be updated if it has one suspended client and other
+// clients are not suspended.
+TEST_F(PlatformSensorProviderTest, TestUpdateSensorManyClients) {
+  const int num = 5;
+  const double frq = 30;
+
+  scoped_refptr<PlatformSensor> sensor = CreateSensor(kAmbientLight);
+  MockPlatformSensor* mock_sensor =
+      static_cast<MockPlatformSensor*>(sensor.get());
+  EXPECT_TRUE(mock_sensor->GetConfigMap().empty());
+
+  sensor_client_->set_sensor(mock_sensor);
+  std::unique_ptr<PlatformSensorTestClient> clients[num];
+  for (int i = 0; i < num; i++) {
+    clients[i].reset(new PlatformSensorTestClient());
+    clients[i]->set_sensor(mock_sensor);
+  }
+
+  PlatformSensorConfiguration config(frq);
+  mock_sensor->StartListening(sensor_client_.get(), config);
+  for (int i = 0; i < num; i++) {
+    PlatformSensorConfiguration config(frq + i);
+    mock_sensor->StartListening(clients[i].get(), config);
+  }
+
+  sensor_client_->set_suspended(true);
+  EXPECT_TRUE(sensor_client_->IsNotificationSuspended());
+  for (int i = 0; i < num; i++) {
+    EXPECT_FALSE(clients[i]->IsNotificationSuspended());
+  }
+
+  mock_sensor->UpdateSensor();
+  EXPECT_TRUE(mock_sensor->IsStarted());
+
+  sensor_client_->set_suspended(false);
+  EXPECT_FALSE(sensor_client_->IsNotificationSuspended());
+  for (int i = 0; i < num; i++) {
+    EXPECT_FALSE(clients[i]->IsNotificationSuspended());
+  }
+
+  mock_sensor->UpdateSensor();
+  EXPECT_TRUE(mock_sensor->IsStarted());
+}
+
+}  // namespace device