iioservice/daemon/events_handler_test.cc

// Copyright 2022 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <gtest/gtest.h>

#include <memory>
#include <utility>
#include <vector>

#include <base/notreached.h>
#include <base/rand_util.h>
#include <base/test/task_environment.h>
#include <libmems/test_fakes.h>
#include <mojo/public/cpp/bindings/receiver_set.h>

#include "iioservice/daemon/events_handler.h"
#include "iioservice/daemon/test_fakes.h"

namespace iioservice {

namespace {

constexpr int kNumFailures = 10;

class EventsHandlerTest : public ::testing::Test,
                          public cros::mojom::SensorDeviceEventsObserver {
 public:
  mojo::PendingRemote<cros::mojom::SensorDeviceEventsObserver> GetRemote() {
    mojo::PendingRemote<cros::mojom::SensorDeviceEventsObserver> remote;
    receiver_set_.Add(this, remote.InitWithNewPipeAndPassReceiver());
    return remote;
  }

  // cros::mojom::SensorDeviceEventsObserver overrides:
  void OnEventUpdated(cros::mojom::IioEventPtr event) override { NOTREACHED(); }
  void OnErrorOccurred(cros::mojom::ObserverErrorType type) override {
    NOTREACHED();
  }

 protected:
  void SetUp() override {
    device_ =
        std::make_unique<libmems::fakes::FakeIioDevice>(nullptr, "sx9310", 0);

    for (int i = 0; i < 4; ++i) {
      device_->AddEvent(std::make_unique<libmems::fakes::FakeIioEvent>(
          iio_chan_type::IIO_PROXIMITY, iio_event_type::IIO_EV_TYPE_THRESH,
          iio_event_direction::IIO_EV_DIR_EITHER, i));
    }

    handler_ = EventsHandler::Create(
        task_environment_.GetMainThreadTaskRunner(),
        task_environment_.GetMainThreadTaskRunner(), device_.get());
    EXPECT_TRUE(handler_);
  }

  void TearDown() override {
    handler_.reset();
    observers_.clear();

    base::RunLoop().RunUntilIdle();
  }

  base::test::SingleThreadTaskEnvironment task_environment_{
      base::test::TaskEnvironment::TimeSource::MOCK_TIME,
      base::test::TaskEnvironment::MainThreadType::IO};

  std::unique_ptr<libmems::fakes::FakeIioDevice> device_;

  EventsHandler::ScopedEventsHandler handler_ = {
      nullptr, EventsHandler::EventsHandlerDeleter};
  std::vector<std::unique_ptr<fakes::FakeEventsObserver>> observers_;
  mojo::ReceiverSet<cros::mojom::SensorDeviceEventsObserver> receiver_set_;
};

TEST_F(EventsHandlerTest, AddClient) {
  // No events in this test
  device_->SetPauseCallbackAtKthEvents(0, base::BindOnce([]() {}));

  handler_->AddClient({3}, GetRemote());
  handler_->AddClient({3}, GetRemote());  // Can be called multiple times.
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(receiver_set_.size(), 2);
}

// Add all clients into the event handler, and read all events. All events are
// checked when received by observers.
TEST_F(EventsHandlerTest, ReadEventsWithEnabledFakeIioEvents) {
  // Set the pause in the beginning to prevent reading events before all
  // clients added.
  device_->SetPauseCallbackAtKthEvents(0, base::BindOnce([]() {}));

  for (int i = 0; i < 4; ++i)
    EXPECT_FALSE(device_->GetEvent(i)->IsEnabled());

  std::multiset<std::pair<int, cros::mojom::ObserverErrorType>> failures;
  for (int i = 0; i < kNumFailures; ++i) {
    int k = base::RandInt(0, libmems::fakes::kEventNumber - 1);

    device_->AddFailedReadAtKthEvent(k);
    failures.insert(
        std::make_pair(k, cros::mojom::ObserverErrorType::READ_FAILED));
  }

  std::vector<std::set<int32_t>> clients = {
      {0},
      {0, 1},
  };

  for (size_t i = 0; i < clients.size(); ++i) {
    // The fake observer needs |max_freq| and |max_freq2| to calculate the
    // correct values of events
    auto fake_observer = std::make_unique<fakes::FakeEventsObserver>(
        device_.get(), failures, clients[i]);

    handler_->AddClient(
        std::vector<int32_t>(clients[i].begin(), clients[i].end()),
        fake_observer->GetRemote());

    observers_.emplace_back(std::move(fake_observer));
  }

  // TODO(chenghaoyang): pause and enable other FakeIioEvents.

  device_->ResumeReadingEvents();

  // Wait until all observers receive all events.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(device_->GetEvent(0)->IsEnabled());
  EXPECT_TRUE(device_->GetEvent(1)->IsEnabled());
  EXPECT_FALSE(device_->GetEvent(2)->IsEnabled());
  EXPECT_FALSE(device_->GetEvent(3)->IsEnabled());

  observers_.pop_back();

  // Wait until |device_| disables event index 1.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(device_->GetEvent(0)->IsEnabled());
  EXPECT_FALSE(device_->GetEvent(1)->IsEnabled());
  EXPECT_FALSE(device_->GetEvent(2)->IsEnabled());
  EXPECT_FALSE(device_->GetEvent(3)->IsEnabled());

  for (const auto& observer : observers_)
    EXPECT_TRUE(observer->FinishedObserving());
}

}  // namespace

}  // namespace iioservice