| // Copyright 2022 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 "permission_broker/usb_driver_tracker.h" |
| |
| #include <string> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #include <gtest/gtest-death-test.h> |
| |
| #include <base/containers/contains.h> |
| #include <base/files/file_descriptor_watcher_posix.h> |
| #include <base/files/file_util.h> |
| #include <base/files/scoped_file.h> |
| #include <base/files/scoped_temp_dir.h> |
| #include <base/test/task_environment.h> |
| |
| using ::testing::DoAll; |
| using ::testing::Return; |
| |
| namespace permission_broker { |
| |
| namespace { |
| |
| static constexpr int kMaxNumClients = 2; |
| static constexpr uint8_t kIface0 = 0; |
| static constexpr uint8_t kIface1 = 1; |
| static constexpr uint8_t kIface2 = 2; |
| static constexpr int kClient0 = 0; |
| static constexpr int kClient1 = 1; |
| |
| ACTION_P(QuitRunLoop, run_loop) { |
| run_loop->Quit(); |
| } |
| |
| } // namespace |
| |
| class MockUsbDriverTracker : public UsbDriverTracker { |
| public: |
| MockUsbDriverTracker() { |
| ON_CALL(*this, WatchLifelineFd) |
| .WillByDefault([this](const std::string& client_id, int lifeline_fd) { |
| // The injection for WatchLifelineFd is not only for mocking return |
| // null case, but also to register HandleClosedFd with mock object so |
| // mocked methods can be called when HandleClosedFd is invoked when |
| // lifeline_fd closes. |
| return base::FileDescriptorWatcher::WatchReadable( |
| lifeline_fd, |
| base::BindRepeating(&UsbDriverTracker::HandleClosedFd, |
| weak_ptr_factory_.GetWeakPtr(), client_id)); |
| }); |
| ON_CALL(*this, ConnectInterface).WillByDefault(Return(true)); |
| ON_CALL(*this, DisconnectInterface).WillByDefault(Return(true)); |
| } |
| MockUsbDriverTracker(const MockUsbDriverTracker&) = delete; |
| MockUsbDriverTracker& operator=(const MockUsbDriverTracker&) = delete; |
| ~MockUsbDriverTracker() override = default; |
| |
| MOCK_METHOD(std::unique_ptr<base::FileDescriptorWatcher::Controller>, |
| WatchLifelineFd, |
| (const std::string&, int), |
| (override)); |
| MOCK_METHOD(bool, DisconnectInterface, (int, uint8_t), (override)); |
| MOCK_METHOD(bool, ConnectInterface, (int, uint8_t), (override)); |
| }; |
| |
| class UsbDriverTrackerTest : public testing::Test { |
| public: |
| UsbDriverTrackerTest() = default; |
| UsbDriverTrackerTest(const UsbDriverTrackerTest&) = delete; |
| UsbDriverTrackerTest& operator=(const UsbDriverTrackerTest&) = delete; |
| ~UsbDriverTrackerTest() override = default; |
| |
| void SetUp() override { |
| ASSERT_TRUE(CreateTemporaryFile(&temp_file_path_)); |
| for (int client = 0; client < kMaxNumClients; client++) { |
| ASSERT_TRUE(base::CreatePipe(/*read_fd*/ &pipe_fds_[client][0], |
| /*write_fd*/ &pipe_fds_[client][1], |
| /*non_blocking*/ true)); |
| } |
| } |
| |
| void TearDown() override { |
| testing::Mock::VerifyAndClearExpectations(&usb_driver_tracker_); |
| // Doing this to use mock CleanUpTracking to avoid warning message of |
| // connect ioctl() failure from the destructor when there is left record in |
| // the end of the test. |
| usb_driver_tracker_.CleanUpTracking(); |
| } |
| |
| std::string SetupClient(int client, |
| const base::FilePath& path, |
| std::vector<uint8_t>& ifaces) { |
| EXPECT_LT(client, kMaxNumClients); |
| return SetupClientWithLifelineFd(pipe_fds_[client][0].get(), path, ifaces); |
| } |
| |
| std::string SetupClientWithLifelineFd(int lifeline_fd, |
| const base::FilePath& path, |
| std::vector<uint8_t>& ifaces) { |
| EXPECT_CALL(usb_driver_tracker_, WatchLifelineFd).Times(1); |
| |
| auto maybe_client_id = |
| usb_driver_tracker_.RegisterClient(lifeline_fd, path); |
| EXPECT_TRUE(maybe_client_id.has_value()); |
| |
| const auto& client_id = maybe_client_id.value(); |
| EXPECT_EQ(client_id.size(), 32); // hex representation of a 128-bit token. |
| EXPECT_TRUE(base::Contains(usb_driver_tracker_.dev_fds_, client_id)); |
| EXPECT_EQ(usb_driver_tracker_.dev_fds_[client_id].path, path); |
| |
| for (auto iface : ifaces) { |
| usb_driver_tracker_.dev_fds_[client_id].interfaces.push_back(iface); |
| usb_driver_tracker_.dev_ifaces_[path][iface] = client_id; |
| } |
| |
| return client_id; |
| } |
| |
| protected: |
| testing::NiceMock<MockUsbDriverTracker> usb_driver_tracker_; |
| base::ScopedFD pipe_fds_[kMaxNumClients][2]; |
| base::FilePath temp_file_path_; |
| |
| private: |
| base::test::TaskEnvironment task_environment_ = base::test::TaskEnvironment( |
| base::test::TaskEnvironment::MainThreadType::IO); |
| }; |
| |
| class UsbDriverTrackerDeathTest : public UsbDriverTrackerTest { |
| public: |
| void SetUp() override { |
| testing::FLAGS_gtest_death_test_style = "threadsafe"; |
| UsbDriverTrackerTest::SetUp(); |
| } |
| }; |
| |
| TEST_F(UsbDriverTrackerTest, RegisterClientSuccess) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| const auto& path = temp_file_path_; |
| SetupClient(kClient0, path, client_0_ifaces); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, RegisterClientOpenPathFail) { |
| auto path = base::FilePath("notexist"); |
| auto maybe_client_id = |
| usb_driver_tracker_.RegisterClient(pipe_fds_[kClient0][0].get(), path); |
| ASSERT_FALSE(maybe_client_id.has_value()); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_fds_.size()); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, RegisterClientDupLifelineFdFail) { |
| const auto& path = temp_file_path_; |
| auto maybe_client_id = usb_driver_tracker_.RegisterClient(-1, path); |
| ASSERT_FALSE(maybe_client_id.has_value()); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_fds_.size()); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, RegisterClientWatchLifelineFdFail) { |
| const auto& path = temp_file_path_; |
| EXPECT_CALL(usb_driver_tracker_, WatchLifelineFd) |
| .WillOnce(Return(testing::ByMove(nullptr))); |
| auto maybe_client_id = |
| usb_driver_tracker_.RegisterClient(pipe_fds_[kClient0][0].get(), path); |
| ASSERT_FALSE(maybe_client_id.has_value()); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_fds_.size()); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, RegisterClientDifferentIds) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| std::vector<uint8_t> client_1_ifaces = {}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| auto client_1_id = SetupClient(kClient1, path, client_1_ifaces); |
| ASSERT_NE(client_0_id, client_1_id); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, CleanUpTracking) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| std::vector<uint8_t> client_1_ifaces = {kIface1}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| auto client_1_id = SetupClient(kClient1, path, client_1_ifaces); |
| EXPECT_CALL(usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), kIface0)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_1_id].fd.get(), kIface1)) |
| .WillOnce(Return(true)); |
| usb_driver_tracker_.CleanUpTracking(); |
| ASSERT_EQ(usb_driver_tracker_.dev_fds_.size(), 0); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, CleanUpTrackingConnectInterfaceFail) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| std::vector<uint8_t> client_1_ifaces = {kIface1}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| auto client_1_id = SetupClient(kClient1, path, client_1_ifaces); |
| EXPECT_CALL(usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), kIface0)) |
| .WillOnce(Return(false)); |
| EXPECT_CALL(usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_1_id].fd.get(), kIface1)) |
| .WillOnce(Return(false)); |
| usb_driver_tracker_.CleanUpTracking(); |
| // Even reattach IOCTL fails, the client's tracking should be cleared. |
| ASSERT_EQ(usb_driver_tracker_.dev_fds_.size(), 0); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, HandleClosedFd) { |
| base::RunLoop run_loop; |
| std::vector<uint8_t> client_0_ifaces = {kIface0, kIface1, kIface2}; |
| std::string client_0_id; |
| const auto& path = temp_file_path_; |
| |
| { |
| base::ScopedFD pipe_fds[2]; |
| ASSERT_TRUE(base::CreatePipe(/*read_fd*/ &pipe_fds[0], |
| /*write_fd*/ &pipe_fds[1], |
| /*non_blocking*/ true)); |
| client_0_id = |
| SetupClientWithLifelineFd(pipe_fds[0].get(), path, client_0_ifaces); |
| for (auto iface : client_0_ifaces) { |
| EXPECT_CALL( |
| usb_driver_tracker_, |
| ConnectInterface(usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), |
| iface)) |
| .WillOnce(DoAll(QuitRunLoop(&run_loop), Return(true))); |
| } |
| } |
| run_loop.Run(); |
| ASSERT_FALSE(usb_driver_tracker_.IsClientIdTracked(client_0_id)); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, HandleClosedFdConnectInterfaceError) { |
| base::RunLoop run_loop; |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| std::string client_0_id; |
| const auto& path = temp_file_path_; |
| |
| { |
| base::ScopedFD pipe_fds[2]; |
| ASSERT_TRUE(base::CreatePipe(/*read_fd*/ &pipe_fds[0], |
| /*write_fd*/ &pipe_fds[1], |
| /*non_blocking*/ true)); |
| client_0_id = |
| SetupClientWithLifelineFd(pipe_fds[0].get(), path, client_0_ifaces); |
| EXPECT_CALL( |
| usb_driver_tracker_, |
| ConnectInterface(usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), |
| kIface0)) |
| .WillOnce(DoAll(QuitRunLoop(&run_loop), Return(false))); |
| } |
| // After client closes, even reattach IOCTL fails, the client's tracking |
| // should be cleared. |
| run_loop.Run(); |
| ASSERT_FALSE(usb_driver_tracker_.IsClientIdTracked(client_0_id)); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, HandleClosedFdUnTrackedClientId) { |
| std::string untracked_client_id = "abc"; |
| usb_driver_tracker_.HandleClosedFd(untracked_client_id); |
| ASSERT_EQ(usb_driver_tracker_.dev_fds_.size(), 0); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_.size(), 0); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, HandleClosedFdTwoClientsOnDifferentPaths) { |
| base::RunLoop run_loop[kMaxNumClients]; |
| std::vector<uint8_t> client_ifaces[kMaxNumClients] = { |
| {kIface0, kIface1}, // kClient0 ifaces |
| {kIface1, kIface0}, // kClient1 ifaces |
| }; |
| std::string client_id[kMaxNumClients]; |
| |
| base::FilePath another_file_path; |
| ASSERT_TRUE(CreateTemporaryFile(&another_file_path)); |
| |
| base::FilePath paths[kMaxNumClients] = { |
| temp_file_path_, // kClient0 path |
| another_file_path, // kClient1 path |
| }; |
| ASSERT_NE(paths[kClient0], paths[kClient1]); |
| |
| { |
| base::ScopedFD pipe_fds[kMaxNumClients][2]; |
| for (auto client = 0; client < kMaxNumClients; client++) { |
| ASSERT_TRUE(base::CreatePipe(/*read_fd*/ &pipe_fds[client][0], |
| /*write_fd*/ &pipe_fds[client][1], |
| /*non_blocking*/ true)); |
| client_id[client] = SetupClientWithLifelineFd( |
| pipe_fds[client][0].get(), paths[client], client_ifaces[client]); |
| for (auto iface : client_ifaces[client]) { |
| EXPECT_CALL( |
| usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_id[client]].fd.get(), |
| iface)) |
| .WillOnce(DoAll(QuitRunLoop(&run_loop[client]), Return(true))); |
| } |
| } |
| } |
| for (auto client = 0; client < kMaxNumClients; client++) { |
| run_loop[client].Run(); |
| ASSERT_FALSE(usb_driver_tracker_.IsClientIdTracked(client_id[client])); |
| ASSERT_FALSE( |
| base::Contains(usb_driver_tracker_.dev_ifaces_, paths[client])); |
| } |
| ASSERT_EQ(0, usb_driver_tracker_.dev_fds_.size()); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_ifaces_.size()); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, HandleClosedFdTwoClientsOnSamePath) { |
| base::RunLoop run_loop[kMaxNumClients]; |
| std::vector<uint8_t> client_ifaces[kMaxNumClients] = { |
| {kIface0, kIface1}, // kClient0 ifaces |
| {kIface2}, // kClient1 ifaces |
| }; |
| std::string client_id[kMaxNumClients]; |
| const auto& path = temp_file_path_; |
| |
| { |
| base::ScopedFD pipe_fds[kMaxNumClients][2]; |
| for (auto client = 0; client < kMaxNumClients; client++) { |
| ASSERT_TRUE(base::CreatePipe(/*read_fd*/ &pipe_fds[client][0], |
| /*write_fd*/ &pipe_fds[client][1], |
| /*non_blocking*/ true)); |
| client_id[client] = SetupClientWithLifelineFd( |
| pipe_fds[client][0].get(), path, client_ifaces[client]); |
| for (auto iface : client_ifaces[client]) { |
| EXPECT_CALL( |
| usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_id[client]].fd.get(), |
| iface)) |
| .WillOnce(DoAll(QuitRunLoop(&run_loop[client]), Return(true))); |
| } |
| } |
| } |
| for (auto client = 0; client < kMaxNumClients; client++) { |
| run_loop[client].Run(); |
| ASSERT_FALSE(usb_driver_tracker_.IsClientIdTracked(client_id[client])); |
| } |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_fds_.size()); |
| ASSERT_EQ(0, usb_driver_tracker_.dev_ifaces_.size()); |
| } |
| TEST_F(UsbDriverTrackerTest, RecordInterfaceDetached) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| usb_driver_tracker_.RecordInterfaceDetached(client_0_id, path, kIface0); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_[path][kIface0], client_0_id); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ClearDetachedInterfaceRecord) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_TRUE(usb_driver_tracker_.dev_ifaces_[path][kIface0] == client_0_id); |
| usb_driver_tracker_.ClearDetachedInterfaceRecord(client_0_id, path, kIface0); |
| ASSERT_FALSE(base::Contains(usb_driver_tracker_.dev_ifaces_, path)); |
| } |
| |
| TEST_F(UsbDriverTrackerDeathTest, RecordInterfaceDetachedUntrackedClient) { |
| std::string untracked_client_id = "abc"; |
| const auto& path = temp_file_path_; |
| ASSERT_DEBUG_DEATH(usb_driver_tracker_.RecordInterfaceDetached( |
| untracked_client_id, path, kIface0), |
| ""); |
| } |
| |
| TEST_F(UsbDriverTrackerDeathTest, RecordInterfaceDetachedIfaceWatched) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_DEBUG_DEATH( |
| usb_driver_tracker_.RecordInterfaceDetached(client_0_id, path, kIface0), |
| ""); |
| } |
| |
| TEST_F(UsbDriverTrackerDeathTest, ClearDetachedInterfaceRecordUntrackedClient) { |
| std::string untracked_client_id = "abc"; |
| const auto& path = temp_file_path_; |
| ASSERT_DEBUG_DEATH(usb_driver_tracker_.ClearDetachedInterfaceRecord( |
| untracked_client_id, path, kIface0), |
| ""); |
| } |
| |
| TEST_F(UsbDriverTrackerDeathTest, ClearDetachedInterfaceRecordUnknownPath) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| base::FilePath unknown_file_path("unknown_path"); |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_DEBUG_DEATH(usb_driver_tracker_.ClearDetachedInterfaceRecord( |
| client_0_id, unknown_file_path, kIface0), |
| ""); |
| } |
| |
| TEST_F(UsbDriverTrackerDeathTest, ClearDetachedInterfaceRecordDupIface) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0, kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_DEBUG_DEATH(usb_driver_tracker_.ClearDetachedInterfaceRecord( |
| client_0_id, path, kIface0), |
| ""); |
| // Explicitly clear the tracking structure to avoid DCHECK failure in |
| // destructor. |
| usb_driver_tracker_.dev_fds_.clear(); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, DetachInterfaceSuccess) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| EXPECT_CALL(usb_driver_tracker_, |
| DisconnectInterface( |
| usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), kIface0)) |
| .WillOnce(Return(true)); |
| ASSERT_TRUE(usb_driver_tracker_.DetachInterface(client_0_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_fds_[client_0_id].interfaces[0], kIface0); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_[path][kIface0], client_0_id); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, DetachInterfaceUnTrackedClientFail) { |
| std::string untracked_client_id = "abc"; |
| ASSERT_FALSE( |
| usb_driver_tracker_.DetachInterface(untracked_client_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_fds_.size(), 0); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_.size(), 0); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, DetachInterfaceIfaceAlreadyDetachedByOtherClient) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| std::vector<uint8_t> client_1_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| SetupClient(kClient1, path, client_1_ifaces); |
| ASSERT_FALSE(usb_driver_tracker_.DetachInterface(client_0_id, kIface0)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, |
| DetachInterfaceIfaceAlreadyDetachedByTheClientNoOp) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_TRUE(usb_driver_tracker_.DetachInterface(client_0_id, kIface0)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, DetachInterfaceIfaceDisconnectFail) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| EXPECT_CALL(usb_driver_tracker_, |
| DisconnectInterface( |
| usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), kIface0)) |
| .WillOnce(Return(false)); |
| ASSERT_FALSE(usb_driver_tracker_.DetachInterface(client_0_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_.size(), 0); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ReattachInterfaceSuccess) { |
| std::vector<uint8_t> client_0_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| EXPECT_CALL(usb_driver_tracker_, |
| ConnectInterface( |
| usb_driver_tracker_.dev_fds_[client_0_id].fd.get(), kIface0)) |
| .WillOnce(Return(true)); |
| ASSERT_TRUE(usb_driver_tracker_.ReattachInterface(client_0_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_.size(), 0); |
| // The client id should still be tracked even it doesn't have any ifaces |
| // detached. |
| ASSERT_TRUE(usb_driver_tracker_.IsClientIdTracked(client_0_id)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ReattachInterfaceUntrackedClientFail) { |
| std::string untracked_client_id = "abc"; |
| ASSERT_FALSE( |
| usb_driver_tracker_.ReattachInterface(untracked_client_id, kIface0)); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ReattachInterfacePathNoIfaceDetachedNoOp) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_TRUE(usb_driver_tracker_.ReattachInterface(client_0_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_.size(), 0); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ReattachInterfaceIfaceNotDetachedNoOp) { |
| std::vector<uint8_t> client_0_ifaces = {kIface1}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| ASSERT_TRUE(usb_driver_tracker_.ReattachInterface(client_0_id, kIface0)); |
| ASSERT_EQ(usb_driver_tracker_.dev_ifaces_[path][kIface1], client_0_id); |
| } |
| |
| TEST_F(UsbDriverTrackerTest, ReattachInterfaceIfaceDetachedByOtherClient) { |
| std::vector<uint8_t> client_0_ifaces = {}; |
| std::vector<uint8_t> client_1_ifaces = {kIface0}; |
| const auto& path = temp_file_path_; |
| auto client_0_id = SetupClient(kClient0, path, client_0_ifaces); |
| SetupClient(kClient1, path, client_1_ifaces); |
| ASSERT_FALSE(usb_driver_tracker_.ReattachInterface(client_0_id, kIface0)); |
| } |
| |
| } // namespace permission_broker |
