| // |
| // Copyright (C) 2015 Google, Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at: |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #include <memory> |
| |
| #include <sys/socket.h> |
| #include <sys/un.h> |
| |
| #include <base/at_exit.h> |
| #include <base/command_line.h> |
| #include <base/files/scoped_file.h> |
| #include <base/macros.h> |
| #include <base/strings/stringprintf.h> |
| #include <gtest/gtest.h> |
| |
| #include "service/adapter.h" |
| #include "service/hal/fake_bluetooth_gatt_interface.h" |
| #include "service/hal/fake_bluetooth_interface.h" |
| #include "service/ipc/ipc_manager.h" |
| #include "service/settings.h" |
| #include "service/test/mock_daemon.h" |
| |
| namespace { |
| |
| using testing::Return; |
| |
| const char kTestSocketPath[] = "test_socket_path"; |
| |
| class IPCLinuxTest : public ::testing::Test { |
| public: |
| IPCLinuxTest() = default; |
| ~IPCLinuxTest() override = default; |
| |
| void SetUp() override { |
| SetUpCommandLine(); |
| ASSERT_TRUE(settings_.Init()); |
| |
| auto mock_daemon = new bluetooth::testing::MockDaemon(); |
| |
| ON_CALL(*mock_daemon, GetSettings()).WillByDefault(Return(&settings_)); |
| ON_CALL(*mock_daemon, GetMessageLoop()) |
| .WillByDefault(Return(&message_loop_)); |
| |
| bluetooth::Daemon::InitializeForTesting(mock_daemon); |
| bluetooth::hal::BluetoothInterface::InitializeForTesting( |
| new bluetooth::hal::FakeBluetoothInterface()); |
| bluetooth::hal::BluetoothGattInterface::InitializeForTesting( |
| new bluetooth::hal::FakeBluetoothGattInterface(nullptr, nullptr, |
| nullptr, nullptr)); |
| |
| adapter_ = bluetooth::Adapter::Create(); |
| ipc_manager_.reset(new ipc::IPCManager(adapter_.get())); |
| } |
| |
| void TearDown() override { |
| client_fd_.reset(); |
| ipc_manager_.reset(); |
| adapter_.reset(); |
| bluetooth::hal::BluetoothGattInterface::CleanUp(); |
| bluetooth::hal::BluetoothInterface::CleanUp(); |
| bluetooth::Daemon::ShutDown(); |
| base::CommandLine::Reset(); |
| } |
| |
| virtual void SetUpCommandLine() { |
| std::string ipc_socket_arg = |
| base::StringPrintf("--create-ipc-socket=%s", kTestSocketPath); |
| const base::CommandLine::CharType* argv[] = { |
| "program", ipc_socket_arg.c_str(), |
| }; |
| base::CommandLine::Init(arraysize(argv), argv); |
| } |
| |
| void ConnectToTestSocket() { |
| client_fd_.reset(socket(PF_UNIX, SOCK_SEQPACKET, 0)); |
| ASSERT_TRUE(client_fd_.is_valid()); |
| |
| struct sockaddr_un address; |
| memset(&address, 0, sizeof(address)); |
| address.sun_family = AF_UNIX; |
| strncpy(address.sun_path, kTestSocketPath, sizeof(address.sun_path) - 1); |
| |
| int status = |
| connect(client_fd_.get(), (struct sockaddr*)&address, sizeof(address)); |
| EXPECT_EQ(0, status); |
| } |
| |
| protected: |
| base::AtExitManager exit_manager_; |
| base::MessageLoop message_loop_; |
| bluetooth::Settings settings_; |
| |
| std::unique_ptr<bluetooth::Adapter> adapter_; |
| std::unique_ptr<ipc::IPCManager> ipc_manager_; |
| base::ScopedFD client_fd_; |
| |
| DISALLOW_COPY_AND_ASSIGN(IPCLinuxTest); |
| }; |
| |
| class IPCLinuxTestDisabled : public IPCLinuxTest { |
| public: |
| IPCLinuxTestDisabled() = default; |
| ~IPCLinuxTestDisabled() override = default; |
| |
| void SetUpCommandLine() override { |
| // Set up with no --ipc-socket-path |
| const base::CommandLine::CharType* argv[] = {"program"}; |
| base::CommandLine::Init(arraysize(argv), argv); |
| } |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(IPCLinuxTestDisabled); |
| }; |
| |
| class TestDelegate : public ipc::IPCManager::Delegate, |
| public base::SupportsWeakPtr<TestDelegate> { |
| public: |
| TestDelegate() : started_count_(0), stopped_count_(0) {} |
| |
| void OnIPCHandlerStarted(ipc::IPCManager::Type type) override { |
| ASSERT_EQ(ipc::IPCManager::TYPE_LINUX, type); |
| started_count_++; |
| base::MessageLoop::current()->QuitWhenIdle(); |
| } |
| |
| void OnIPCHandlerStopped(ipc::IPCManager::Type type) override { |
| ASSERT_EQ(ipc::IPCManager::TYPE_LINUX, type); |
| stopped_count_++; |
| base::MessageLoop::current()->QuitWhenIdle(); |
| } |
| |
| int started_count() const { return started_count_; } |
| int stopped_count() const { return stopped_count_; } |
| |
| private: |
| int started_count_; |
| int stopped_count_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestDelegate); |
| }; |
| |
| TEST_F(IPCLinuxTestDisabled, StartWithNoSocketPath) { |
| TestDelegate delegate; |
| EXPECT_FALSE(ipc_manager_->Start(ipc::IPCManager::TYPE_LINUX, &delegate)); |
| EXPECT_FALSE(ipc_manager_->LinuxStarted()); |
| EXPECT_EQ(0, delegate.started_count()); |
| EXPECT_EQ(0, delegate.stopped_count()); |
| } |
| |
| TEST_F(IPCLinuxTest, BasicStartAndExit) { |
| TestDelegate delegate; |
| EXPECT_TRUE(ipc_manager_->Start(ipc::IPCManager::TYPE_LINUX, &delegate)); |
| EXPECT_TRUE(ipc_manager_->LinuxStarted()); |
| |
| // Run the message loop. We will stop the loop when we receive a delegate |
| // event. |
| message_loop_.Run(); |
| |
| // We should have received the started event. |
| EXPECT_EQ(1, delegate.started_count()); |
| EXPECT_EQ(0, delegate.stopped_count()); |
| |
| // At this point the thread is blocking on accept and listening for incoming |
| // connections. TearDown should gracefully clean up the thread and the test |
| // should succeed without hanging. |
| ipc_manager_.reset(); |
| message_loop_.Run(); |
| EXPECT_EQ(1, delegate.stopped_count()); |
| } |
| |
| TEST_F(IPCLinuxTest, BasicStartAndConnect) { |
| TestDelegate delegate; |
| EXPECT_TRUE(ipc_manager_->Start(ipc::IPCManager::TYPE_LINUX, &delegate)); |
| EXPECT_TRUE(ipc_manager_->LinuxStarted()); |
| |
| // Run the message loop. We will stop the loop when we receive a delegate |
| // event. |
| message_loop_.Run(); |
| |
| // We should have received the started event. |
| EXPECT_EQ(1, delegate.started_count()); |
| EXPECT_EQ(0, delegate.stopped_count()); |
| |
| // IPC successfully started. Now attempt to connect to the socket. |
| ConnectToTestSocket(); |
| |
| // TODO(armansito): Test that the IPC event loop shuts down cleanly while a |
| // client is connected. Currently this will fail and the fix is to use |
| // MessageLoopForIO rather than a custom event loop. |
| } |
| |
| } // namespace |