power_manager/powerd/system/arc_timer_manager_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2018 The Chromium OS 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 "power_manager/powerd/system/arc_timer_manager.h"

 #include <time.h>

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

 #include <base/bind.h>
 #include <base/callback_helpers.h>
 #include <base/files/file_descriptor_watcher_posix.h>
 #include <base/macros.h>
 #include <base/run_loop.h>
 #include <chromeos/dbus/service_constants.h>
 #include <gtest/gtest.h>
 #include <sys/socket.h>

 #include "power_manager/common/test_main_loop_runner.h"
 #include "power_manager/powerd/system/dbus_wrapper_stub.h"

 namespace power_manager {
 namespace system {

 namespace {

 bool CreateSocketPair(base::ScopedFD* one, base::ScopedFD* two) {
   int raw_socks[2];
   if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks) != 0) {
     PLOG(ERROR) << "Failed to create socket pair";
     return false;
   }
   one->reset(raw_socks[0]);
   two->reset(raw_socks[1]);
   return true;
 }

 std::vector<base::ScopedFD> WriteCreateTimersDBusRequest(
     const std::string& tag,
     const std::vector<clockid_t>& clocks,
     dbus::MessageWriter* writer) {
   // Create D-Bus arguments i.e. tag followed by array of
   // {int32_t clock_id, base::ScopedFD expiration_fd}.
   writer->AppendString(tag);
   dbus::MessageWriter array_writer(nullptr);
   writer->OpenArray("(ih)", &array_writer);
   std::vector<base::ScopedFD> result;
   for (clockid_t clock_id : clocks) {
     // Create a socket pair for each clock. One socket will be part of the
     // mojo argument and will be used by the host to indicate when the timer
     // expires. The other socket will be used to detect the expiration of the
     // timer by epolling / reading.
     base::ScopedFD read_fd;
     base::ScopedFD write_fd;
     if (!CreateSocketPair(&read_fd, &write_fd)) {
       LOG(ERROR) << "Failed to create socket pair for ARC timers";
       return result;
     }
     result.push_back(std::move(read_fd));

     dbus::MessageWriter struct_writer(nullptr);
     array_writer.OpenStruct(&struct_writer);
     struct_writer.AppendInt32(static_cast<int32_t>(clock_id));
     struct_writer.AppendFileDescriptor(write_fd.get());
     array_writer.CloseContainer(&struct_writer);
   }
   writer->CloseContainer(&array_writer);
   return result;
 }

 std::vector<ArcTimerManager::TimerId> ReadTimerIds(
     std::unique_ptr<dbus::Response> response) {
   dbus::MessageReader reader(response.get());
   dbus::MessageReader array_reader(nullptr);
   std::vector<ArcTimerManager::TimerId> result;
   if (!reader.PopArray(&array_reader)) {
     LOG(ERROR) << "No timer ids returned";
     return result;
   }
   std::vector<ArcTimerManager::TimerId> timer_ids;
   while (array_reader.HasMoreData()) {
     ArcTimerManager::TimerId timer_id;
     if (!array_reader.PopInt32(&timer_id)) {
       LOG(ERROR) << "Failed to pop timer id";
       return result;
     }
     result.push_back(timer_id);
   }
   return result;
 }

 bool IsResponseValid(dbus::Response* response) {
   return response && response->GetMessageType() ==
                          dbus::Message::MessageType::MESSAGE_METHOD_RETURN;
 }

 // Returns true iff |a| and |b| are of the same size and all entries in |a| are
 // different from |b|.
 bool AreTimerIdsIdenticalSizeButDistinct(
     const std::vector<ArcTimerManager::TimerId>& a,
     const std::vector<ArcTimerManager::TimerId>& b) {
   if (a.size() != b.size())
     return false;

   for (auto id : a) {
     if (std::find(b.begin(), b.end(), id) != b.end())
       return false;
   }
   return true;
 }

 }  // namespace

 class ArcTimerManagerTest : public ::testing::Test {
  public:
   ArcTimerManagerTest() {
     arc_timer_manager_.set_for_testing_(true);
     arc_timer_manager_.Init(&dbus_wrapper_);
   }
   ArcTimerManagerTest(const ArcTimerManagerTest&) = delete;
   ArcTimerManagerTest& operator=(const ArcTimerManagerTest&) = delete;

  protected:
   bool CreateTimers(const std::string& tag,
                     const std::vector<clockid_t>& clocks) WARN_UNUSED_RESULT {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  power_manager::kCreateArcTimersMethod);
     dbus::MessageWriter writer(&method_call);
     std::vector<base::ScopedFD> read_fds =
         WriteCreateTimersDBusRequest(tag, clocks, &writer);
     size_t clocks_size = clocks.size();
     if (read_fds.size() != clocks_size) {
       LOG(ERROR) << "Failed to create D-Bus request";
       return false;
     }

     std::unique_ptr<dbus::Response> response =
         dbus_wrapper_.CallExportedMethodSync(&method_call);
     if (!IsResponseValid(response.get())) {
       LOG(ERROR) << power_manager::kCreateArcTimersMethod << " call failed";
       return false;
     }

     // Parse timer ids returned from the response.
     std::vector<ArcTimerManager::TimerId> timer_ids =
         ReadTimerIds(std::move(response));
     if (timer_ids.size() != clocks_size) {
       LOG(ERROR) << "Expected timer ids size=" << clocks_size
                  << " got size=" << timer_ids.size();
       return false;
     }

     // Map each clock id to its corresponding timer id. Also, map each timer id
     // to its corresponding read fd that will indicate timer expiration.
     auto timer_id_iter = timer_ids.begin();
     auto read_fd_iter = read_fds.begin();
     auto arc_timer_store = std::make_unique<ArcTimerStore>();
     for (clockid_t clock_id : clocks) {
       VLOG(1) << "Adding entry for clock=" << clock_id
               << " timer id=" << *timer_id_iter;
       if (!arc_timer_store->AddTimerEntry(clock_id, *timer_id_iter,
                                           std::move(*read_fd_iter))) {
         return false;
       }
       timer_id_iter++;
       read_fd_iter++;
     }
     // It's okay to overwrite a |tag|'s value here to support tests that
     // create-delete-create with the same tag.
     arc_timer_stores_[tag] = std::move(arc_timer_store);
     return true;
   }

   bool StartTimer(const std::string& tag,
                   clockid_t clock_id,
                   base::TimeTicks absolute_expiration_time) WARN_UNUSED_RESULT {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  power_manager::kStartArcTimerMethod);

     if (arc_timer_stores_.find(tag) == arc_timer_stores_.end()) {
       LOG(ERROR) << "Tag=" << tag << " not created";
       return false;
     }
     const auto& arc_timer_store = arc_timer_stores_[tag];

     // Write timer id corresponding to |clock_id| and 64-bit expiration time
     // ticks value as a DBus message.
     dbus::MessageWriter writer(&method_call);
     ArcTimerManager::TimerId timer_id = arc_timer_store->GetTimerId(clock_id);
     if (timer_id < 0) {
       LOG(ERROR) << "Timer for clock=" << clock_id << " not created";
       return false;
     }
     writer.AppendInt32(timer_id);
     writer.AppendInt64(
         (absolute_expiration_time - base::TimeTicks()).InMicroseconds());
     std::unique_ptr<dbus::Response> response =
         dbus_wrapper_.CallExportedMethodSync(&method_call);
     if (!IsResponseValid(response.get())) {
       LOG(ERROR) << power_manager::kStartArcTimerMethod << " call failed";
       return false;
     }
     return true;
   }

   // Returns true iff the read descriptor of a timer is signalled. If the
   // signalling is incorrect returns false. Blocks otherwise.
   bool WaitForExpiration(const std::string& tag,
                          clockid_t clock_id) WARN_UNUSED_RESULT {
     if (arc_timer_stores_.find(tag) == arc_timer_stores_.end()) {
       LOG(ERROR) << "Tag=" << tag << " not created";
       return false;
     }
     const auto& arc_timer_store = arc_timer_stores_[tag];

     if (!arc_timer_store->HasTimer(clock_id)) {
       LOG(ERROR) << "Timer of type=" << clock_id << " not present";
       return false;
     }

     // Wait for the host to indicate expiration by watching the read end of the
     // socket pair.
     int timer_read_fd = arc_timer_store->GetTimerReadFd(clock_id);
     if (timer_read_fd < 0) {
       LOG(ERROR) << "Clock=" << clock_id << " fd not present";
       return false;
     }

     TestMainLoopRunner runner;
     // Set up a watcher to watch for the timer's read fd to become readable.
     std::unique_ptr<base::FileDescriptorWatcher::Controller> watcher;
     watcher = base::FileDescriptorWatcher::WatchReadable(
         timer_read_fd,
         base::BindRepeating(
             [](TestMainLoopRunner* runner,
                std::unique_ptr<base::FileDescriptorWatcher::Controller>*
                    watcher) {
               VLOG(1) << "Fd readable";
               *watcher = nullptr;
               runner->StopLoop();
             },
             &runner, &watcher));

     // Start run loop and error out if the fd isn't readable after a timeout.
     if (!runner.StartLoop(base::TimeDelta::FromSeconds(30))) {
       LOG(ERROR) << "Timed out waiting for expiration";
       return false;
     }

     // The timer expects 8 bytes to be written from the host upon expiration.
     // The read data signifies the number of expirations. The powerd
     // implementation always returns one expiration.
     uint64_t timer_data = 0;
     ssize_t bytes_read = read(timer_read_fd, &timer_data, sizeof(timer_data));
     if ((bytes_read != sizeof(timer_data)) || (timer_data != 1)) {
       LOG(ERROR) << "Bad expiration data: bytes_read=" << bytes_read
                  << " timer_data=" << timer_data;
       return false;
     }
     return true;
   }

   bool DeleteTimers(const std::string& tag) WARN_UNUSED_RESULT {
     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
                                  power_manager::kDeleteArcTimersMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(tag);
     std::unique_ptr<dbus::Response> response =
         dbus_wrapper_.CallExportedMethodSync(&method_call);
     if (!IsResponseValid(response.get())) {
       return false;
     }
     return true;
   }

  protected:
   ArcTimerManager arc_timer_manager_;

  private:
   // Stores clock ids and their corresponding file descriptors. These file
   // descriptors indicate when a timer corresponding to the clock has expired on
   // a read.
   class ArcTimerStore {
    public:
     ArcTimerStore() = default;
     ArcTimerStore(const ArcTimerStore&) = delete;
     ArcTimerStore& operator=(const ArcTimerStore&) = delete;

     bool AddTimerEntry(clockid_t clock_id,
                        ArcTimerManager::TimerId timer_id,
                        base::ScopedFD read_fd) {
       if (!timer_ids_.emplace(clock_id, timer_id).second) {
         LOG(ERROR) << "Failed to set timer id for clock=" << clock_id;
         return false;
       }
       if (!arc_timers_.emplace(timer_id, std::move(read_fd)).second) {
         LOG(ERROR) << "Failed to store read fd for timer id=" << timer_id;
         return false;
       }
       return true;
     }

     void ClearTimers() {
       timer_ids_.clear();
       arc_timers_.clear();
     }

     int GetTimerReadFd(clockid_t clock_id) {
       return HasTimer(clock_id) ? arc_timers_[GetTimerId(clock_id)].get() : -1;
     }

     bool HasTimer(clockid_t clock_id) const {
       ArcTimerManager::TimerId timer_id = GetTimerId(clock_id);
       return timer_id >= 0 && arc_timers_.find(timer_id) != arc_timers_.end();
     }

     ArcTimerManager::TimerId GetTimerId(clockid_t clock_id) const {
       auto it = timer_ids_.find(clock_id);
       return it == timer_ids_.end() ? -1 : it->second;
     }

    private:
     // Map of clock id to timer id of the associated timer created.
     std::map<clockid_t, ArcTimerManager::TimerId> timer_ids_;

     // Map of timer id to the read fd that will indicate expiration of the
     // timer.
     std::map<ArcTimerManager::TimerId, base::ScopedFD> arc_timers_;

   };

   // Mapping of a client's tag and the |ArcTimerStore| to use with it.
   std::map<std::string, std::unique_ptr<ArcTimerStore>> arc_timer_stores_;

   DBusWrapperStub dbus_wrapper_;
 };

 TEST_F(ArcTimerManagerTest, CreateAndStartTimer) {
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM};
   const std::string kTag = "Test";
   ASSERT_TRUE(CreateTimers(kTag, clocks));
   ASSERT_TRUE(StartTimer(
       kTag, CLOCK_BOOTTIME_ALARM,
       base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
   ASSERT_TRUE(WaitForExpiration(kTag, CLOCK_BOOTTIME_ALARM));
 }

 TEST_F(ArcTimerManagerTest, CreateAndDeleteTimers) {
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM};
   const std::string kTag = "Test";
   ASSERT_TRUE(CreateTimers(kTag, clocks));
   // |DeleteTimers| returns success for an unregistered tag.
   ASSERT_TRUE(DeleteTimers("Foo"));
   // Delete created timers and then try to start a timer. The call should fail
   // as the timer doesn't exist.
   ASSERT_TRUE(DeleteTimers(kTag));
   ASSERT_FALSE(StartTimer(
       kTag, CLOCK_BOOTTIME_ALARM,
       base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
 }

 TEST_F(ArcTimerManagerTest, CheckInvalidCreateTimersArgs) {
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM,
                                    CLOCK_REALTIME_ALARM};
   // Creating timers should fail when duplicate clock ids are passed in.
   ASSERT_FALSE(CreateTimers("Test", clocks));
 }

 TEST_F(ArcTimerManagerTest, CheckInvalidStartTimerArgs) {
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
   const std::string kTag = "Test";
   ASSERT_TRUE(CreateTimers(kTag, clocks));
   // Starting timer for unregistered clock id should fail.
   ASSERT_FALSE(StartTimer(
       kTag, CLOCK_BOOTTIME_ALARM,
       base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
 }

 TEST_F(ArcTimerManagerTest, CheckMultipleCreateTimers) {
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
   const std::string kTag = "Test1";
   ASSERT_TRUE(CreateTimers(kTag, clocks));
   std::vector<ArcTimerManager::TimerId> first_create_ids =
       arc_timer_manager_.GetTimerIdsForTesting(kTag);

   // Creating timers with a registered tag should delete the old timers
   // associated with the tag and succeed. Check that the delete succeeded by
   // checking that the new timer ids are different from the old timer ids.
   ASSERT_TRUE(CreateTimers(kTag, clocks));
   std::vector<ArcTimerManager::TimerId> second_create_ids =
       arc_timer_manager_.GetTimerIdsForTesting(kTag);
   ASSERT_TRUE(
       AreTimerIdsIdenticalSizeButDistinct(first_create_ids, second_create_ids));

   // Creating timers after deleting old timers should succeed.
   ASSERT_TRUE(DeleteTimers(kTag));
   ASSERT_TRUE(CreateTimers(kTag, clocks));

   // Create timers with a different tag should also succeed.
   ASSERT_TRUE(CreateTimers("Test2", clocks));
 }

 TEST_F(ArcTimerManagerTest, CheckDeleteAndStartOther) {
   // Create timers with two different tags. Delete the first tag and check if
   // the second tag's timers still start.
   std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
   const std::string kTag1 = "Test1";
   ASSERT_TRUE(CreateTimers(kTag1, clocks));
   const std::string kTag2 = "Test2";
   ASSERT_TRUE(CreateTimers(kTag2, clocks));
   ASSERT_TRUE(DeleteTimers(kTag1));
   ASSERT_TRUE(StartTimer(
       kTag2, CLOCK_REALTIME_ALARM,
       base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
   ASSERT_TRUE(WaitForExpiration(kTag2, CLOCK_REALTIME_ALARM));
 }

 }  // namespace system
 }  // namespace power_manager
	// Copyright 2018 The Chromium OS 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 "power_manager/powerd/system/arc_timer_manager.h"

	#include <time.h>

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

	#include <base/bind.h>
	#include <base/callback_helpers.h>
	#include <base/files/file_descriptor_watcher_posix.h>
	#include <base/macros.h>
	#include <base/run_loop.h>
	#include <chromeos/dbus/service_constants.h>
	#include <gtest/gtest.h>
	#include <sys/socket.h>

	#include "power_manager/common/test_main_loop_runner.h"
	#include "power_manager/powerd/system/dbus_wrapper_stub.h"

	namespace power_manager {
	namespace system {

	namespace {

	bool CreateSocketPair(base::ScopedFD* one, base::ScopedFD* two) {
	int raw_socks[2];
	if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, raw_socks) != 0) {
	PLOG(ERROR) << "Failed to create socket pair";
	return false;
	}
	one->reset(raw_socks[0]);
	two->reset(raw_socks[1]);
	return true;
	}

	std::vector<base::ScopedFD> WriteCreateTimersDBusRequest(
	const std::string& tag,
	const std::vector<clockid_t>& clocks,
	dbus::MessageWriter* writer) {
	// Create D-Bus arguments i.e. tag followed by array of
	// {int32_t clock_id, base::ScopedFD expiration_fd}.
	writer->AppendString(tag);
	dbus::MessageWriter array_writer(nullptr);
	writer->OpenArray("(ih)", &array_writer);
	std::vector<base::ScopedFD> result;
	for (clockid_t clock_id : clocks) {
	// Create a socket pair for each clock. One socket will be part of the
	// mojo argument and will be used by the host to indicate when the timer
	// expires. The other socket will be used to detect the expiration of the
	// timer by epolling / reading.
	base::ScopedFD read_fd;
	base::ScopedFD write_fd;
	if (!CreateSocketPair(&read_fd, &write_fd)) {
	LOG(ERROR) << "Failed to create socket pair for ARC timers";
	return result;
	}
	result.push_back(std::move(read_fd));

	dbus::MessageWriter struct_writer(nullptr);
	array_writer.OpenStruct(&struct_writer);
	struct_writer.AppendInt32(static_cast<int32_t>(clock_id));
	struct_writer.AppendFileDescriptor(write_fd.get());
	array_writer.CloseContainer(&struct_writer);
	}
	writer->CloseContainer(&array_writer);
	return result;
	}

	std::vector<ArcTimerManager::TimerId> ReadTimerIds(
	std::unique_ptr<dbus::Response> response) {
	dbus::MessageReader reader(response.get());
	dbus::MessageReader array_reader(nullptr);
	std::vector<ArcTimerManager::TimerId> result;
	if (!reader.PopArray(&array_reader)) {
	LOG(ERROR) << "No timer ids returned";
	return result;
	}
	std::vector<ArcTimerManager::TimerId> timer_ids;
	while (array_reader.HasMoreData()) {
	ArcTimerManager::TimerId timer_id;
	if (!array_reader.PopInt32(&timer_id)) {
	LOG(ERROR) << "Failed to pop timer id";
	return result;
	}
	result.push_back(timer_id);
	}
	return result;
	}

	bool IsResponseValid(dbus::Response* response) {
	return response && response->GetMessageType() ==
	dbus::Message::MessageType::MESSAGE_METHOD_RETURN;
	}

	// Returns true iff \|a\| and \|b\| are of the same size and all entries in \|a\| are
	// different from \|b\|.
	bool AreTimerIdsIdenticalSizeButDistinct(
	const std::vector<ArcTimerManager::TimerId>& a,
	const std::vector<ArcTimerManager::TimerId>& b) {
	if (a.size() != b.size())
	return false;

	for (auto id : a) {
	if (std::find(b.begin(), b.end(), id) != b.end())
	return false;
	}
	return true;
	}

	} // namespace

	class ArcTimerManagerTest : public ::testing::Test {
	public:
	ArcTimerManagerTest() {
	arc_timer_manager_.set_for_testing_(true);
	arc_timer_manager_.Init(&dbus_wrapper_);
	}
	ArcTimerManagerTest(const ArcTimerManagerTest&) = delete;
	ArcTimerManagerTest& operator=(const ArcTimerManagerTest&) = delete;

	protected:
	bool CreateTimers(const std::string& tag,
	const std::vector<clockid_t>& clocks) WARN_UNUSED_RESULT {
	dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
	power_manager::kCreateArcTimersMethod);
	dbus::MessageWriter writer(&method_call);
	std::vector<base::ScopedFD> read_fds =
	WriteCreateTimersDBusRequest(tag, clocks, &writer);
	size_t clocks_size = clocks.size();
	if (read_fds.size() != clocks_size) {
	LOG(ERROR) << "Failed to create D-Bus request";
	return false;
	}

	std::unique_ptr<dbus::Response> response =
	dbus_wrapper_.CallExportedMethodSync(&method_call);
	if (!IsResponseValid(response.get())) {
	LOG(ERROR) << power_manager::kCreateArcTimersMethod << " call failed";
	return false;
	}

	// Parse timer ids returned from the response.
	std::vector<ArcTimerManager::TimerId> timer_ids =
	ReadTimerIds(std::move(response));
	if (timer_ids.size() != clocks_size) {
	LOG(ERROR) << "Expected timer ids size=" << clocks_size
	<< " got size=" << timer_ids.size();
	return false;
	}

	// Map each clock id to its corresponding timer id. Also, map each timer id
	// to its corresponding read fd that will indicate timer expiration.
	auto timer_id_iter = timer_ids.begin();
	auto read_fd_iter = read_fds.begin();
	auto arc_timer_store = std::make_unique<ArcTimerStore>();
	for (clockid_t clock_id : clocks) {
	VLOG(1) << "Adding entry for clock=" << clock_id
	<< " timer id=" << *timer_id_iter;
	if (!arc_timer_store->AddTimerEntry(clock_id, *timer_id_iter,
	std::move(*read_fd_iter))) {
	return false;
	}
	timer_id_iter++;
	read_fd_iter++;
	}
	// It's okay to overwrite a \|tag\|'s value here to support tests that
	// create-delete-create with the same tag.
	arc_timer_stores_[tag] = std::move(arc_timer_store);
	return true;
	}

	bool StartTimer(const std::string& tag,
	clockid_t clock_id,
	base::TimeTicks absolute_expiration_time) WARN_UNUSED_RESULT {
	dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
	power_manager::kStartArcTimerMethod);

	if (arc_timer_stores_.find(tag) == arc_timer_stores_.end()) {
	LOG(ERROR) << "Tag=" << tag << " not created";
	return false;
	}
	const auto& arc_timer_store = arc_timer_stores_[tag];

	// Write timer id corresponding to \|clock_id\| and 64-bit expiration time
	// ticks value as a DBus message.
	dbus::MessageWriter writer(&method_call);
	ArcTimerManager::TimerId timer_id = arc_timer_store->GetTimerId(clock_id);
	if (timer_id < 0) {
	LOG(ERROR) << "Timer for clock=" << clock_id << " not created";
	return false;
	}
	writer.AppendInt32(timer_id);
	writer.AppendInt64(
	(absolute_expiration_time - base::TimeTicks()).InMicroseconds());
	std::unique_ptr<dbus::Response> response =
	dbus_wrapper_.CallExportedMethodSync(&method_call);
	if (!IsResponseValid(response.get())) {
	LOG(ERROR) << power_manager::kStartArcTimerMethod << " call failed";
	return false;
	}
	return true;
	}

	// Returns true iff the read descriptor of a timer is signalled. If the
	// signalling is incorrect returns false. Blocks otherwise.
	bool WaitForExpiration(const std::string& tag,
	clockid_t clock_id) WARN_UNUSED_RESULT {
	if (arc_timer_stores_.find(tag) == arc_timer_stores_.end()) {
	LOG(ERROR) << "Tag=" << tag << " not created";
	return false;
	}
	const auto& arc_timer_store = arc_timer_stores_[tag];

	if (!arc_timer_store->HasTimer(clock_id)) {
	LOG(ERROR) << "Timer of type=" << clock_id << " not present";
	return false;
	}

	// Wait for the host to indicate expiration by watching the read end of the
	// socket pair.
	int timer_read_fd = arc_timer_store->GetTimerReadFd(clock_id);
	if (timer_read_fd < 0) {
	LOG(ERROR) << "Clock=" << clock_id << " fd not present";
	return false;
	}

	TestMainLoopRunner runner;
	// Set up a watcher to watch for the timer's read fd to become readable.
	std::unique_ptr<base::FileDescriptorWatcher::Controller> watcher;
	watcher = base::FileDescriptorWatcher::WatchReadable(
	timer_read_fd,
	base::BindRepeating(
	[](TestMainLoopRunner* runner,
	std::unique_ptr<base::FileDescriptorWatcher::Controller>*
	watcher) {
	VLOG(1) << "Fd readable";
	*watcher = nullptr;
	runner->StopLoop();
	},
	&runner, &watcher));

	// Start run loop and error out if the fd isn't readable after a timeout.
	if (!runner.StartLoop(base::TimeDelta::FromSeconds(30))) {
	LOG(ERROR) << "Timed out waiting for expiration";
	return false;
	}

	// The timer expects 8 bytes to be written from the host upon expiration.
	// The read data signifies the number of expirations. The powerd
	// implementation always returns one expiration.
	uint64_t timer_data = 0;
	ssize_t bytes_read = read(timer_read_fd, &timer_data, sizeof(timer_data));
	if ((bytes_read != sizeof(timer_data)) \|\| (timer_data != 1)) {
	LOG(ERROR) << "Bad expiration data: bytes_read=" << bytes_read
	<< " timer_data=" << timer_data;
	return false;
	}
	return true;
	}

	bool DeleteTimers(const std::string& tag) WARN_UNUSED_RESULT {
	dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
	power_manager::kDeleteArcTimersMethod);
	dbus::MessageWriter writer(&method_call);
	writer.AppendString(tag);
	std::unique_ptr<dbus::Response> response =
	dbus_wrapper_.CallExportedMethodSync(&method_call);
	if (!IsResponseValid(response.get())) {
	return false;
	}
	return true;
	}

	protected:
	ArcTimerManager arc_timer_manager_;

	private:
	// Stores clock ids and their corresponding file descriptors. These file
	// descriptors indicate when a timer corresponding to the clock has expired on
	// a read.
	class ArcTimerStore {
	public:
	ArcTimerStore() = default;
	ArcTimerStore(const ArcTimerStore&) = delete;
	ArcTimerStore& operator=(const ArcTimerStore&) = delete;

	bool AddTimerEntry(clockid_t clock_id,
	ArcTimerManager::TimerId timer_id,
	base::ScopedFD read_fd) {
	if (!timer_ids_.emplace(clock_id, timer_id).second) {
	LOG(ERROR) << "Failed to set timer id for clock=" << clock_id;
	return false;
	}
	if (!arc_timers_.emplace(timer_id, std::move(read_fd)).second) {
	LOG(ERROR) << "Failed to store read fd for timer id=" << timer_id;
	return false;
	}
	return true;
	}

	void ClearTimers() {
	timer_ids_.clear();
	arc_timers_.clear();
	}

	int GetTimerReadFd(clockid_t clock_id) {
	return HasTimer(clock_id) ? arc_timers_[GetTimerId(clock_id)].get() : -1;
	}

	bool HasTimer(clockid_t clock_id) const {
	ArcTimerManager::TimerId timer_id = GetTimerId(clock_id);
	return timer_id >= 0 && arc_timers_.find(timer_id) != arc_timers_.end();
	}

	ArcTimerManager::TimerId GetTimerId(clockid_t clock_id) const {
	auto it = timer_ids_.find(clock_id);
	return it == timer_ids_.end() ? -1 : it->second;
	}

	private:
	// Map of clock id to timer id of the associated timer created.
	std::map<clockid_t, ArcTimerManager::TimerId> timer_ids_;

	// Map of timer id to the read fd that will indicate expiration of the
	// timer.
	std::map<ArcTimerManager::TimerId, base::ScopedFD> arc_timers_;

	};

	// Mapping of a client's tag and the \|ArcTimerStore\| to use with it.
	std::map<std::string, std::unique_ptr<ArcTimerStore>> arc_timer_stores_;

	DBusWrapperStub dbus_wrapper_;
	};

	TEST_F(ArcTimerManagerTest, CreateAndStartTimer) {
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM};
	const std::string kTag = "Test";
	ASSERT_TRUE(CreateTimers(kTag, clocks));
	ASSERT_TRUE(StartTimer(
	kTag, CLOCK_BOOTTIME_ALARM,
	base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
	ASSERT_TRUE(WaitForExpiration(kTag, CLOCK_BOOTTIME_ALARM));
	}

	TEST_F(ArcTimerManagerTest, CreateAndDeleteTimers) {
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM};
	const std::string kTag = "Test";
	ASSERT_TRUE(CreateTimers(kTag, clocks));
	// \|DeleteTimers\| returns success for an unregistered tag.
	ASSERT_TRUE(DeleteTimers("Foo"));
	// Delete created timers and then try to start a timer. The call should fail
	// as the timer doesn't exist.
	ASSERT_TRUE(DeleteTimers(kTag));
	ASSERT_FALSE(StartTimer(
	kTag, CLOCK_BOOTTIME_ALARM,
	base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
	}

	TEST_F(ArcTimerManagerTest, CheckInvalidCreateTimersArgs) {
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM, CLOCK_BOOTTIME_ALARM,
	CLOCK_REALTIME_ALARM};
	// Creating timers should fail when duplicate clock ids are passed in.
	ASSERT_FALSE(CreateTimers("Test", clocks));
	}

	TEST_F(ArcTimerManagerTest, CheckInvalidStartTimerArgs) {
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
	const std::string kTag = "Test";
	ASSERT_TRUE(CreateTimers(kTag, clocks));
	// Starting timer for unregistered clock id should fail.
	ASSERT_FALSE(StartTimer(
	kTag, CLOCK_BOOTTIME_ALARM,
	base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
	}

	TEST_F(ArcTimerManagerTest, CheckMultipleCreateTimers) {
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
	const std::string kTag = "Test1";
	ASSERT_TRUE(CreateTimers(kTag, clocks));
	std::vector<ArcTimerManager::TimerId> first_create_ids =
	arc_timer_manager_.GetTimerIdsForTesting(kTag);

	// Creating timers with a registered tag should delete the old timers
	// associated with the tag and succeed. Check that the delete succeeded by
	// checking that the new timer ids are different from the old timer ids.
	ASSERT_TRUE(CreateTimers(kTag, clocks));
	std::vector<ArcTimerManager::TimerId> second_create_ids =
	arc_timer_manager_.GetTimerIdsForTesting(kTag);
	ASSERT_TRUE(
	AreTimerIdsIdenticalSizeButDistinct(first_create_ids, second_create_ids));

	// Creating timers after deleting old timers should succeed.
	ASSERT_TRUE(DeleteTimers(kTag));
	ASSERT_TRUE(CreateTimers(kTag, clocks));

	// Create timers with a different tag should also succeed.
	ASSERT_TRUE(CreateTimers("Test2", clocks));
	}

	TEST_F(ArcTimerManagerTest, CheckDeleteAndStartOther) {
	// Create timers with two different tags. Delete the first tag and check if
	// the second tag's timers still start.
	std::vector<clockid_t> clocks = {CLOCK_REALTIME_ALARM};
	const std::string kTag1 = "Test1";
	ASSERT_TRUE(CreateTimers(kTag1, clocks));
	const std::string kTag2 = "Test2";
	ASSERT_TRUE(CreateTimers(kTag2, clocks));
	ASSERT_TRUE(DeleteTimers(kTag1));
	ASSERT_TRUE(StartTimer(
	kTag2, CLOCK_REALTIME_ALARM,
	base::TimeTicks::Now() + base::TimeDelta::FromMilliseconds(1)));
	ASSERT_TRUE(WaitForExpiration(kTag2, CLOCK_REALTIME_ALARM));
	}

	} // namespace system
	} // namespace power_manager