| // Copyright 2021 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "device/bluetooth/floss/floss_manager_client.h" |
| |
| #include <utility> |
| #include <vector> |
| |
| #include "base/memory/raw_ptr.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/run_loop.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/test/task_environment.h" |
| #include "dbus/bus.h" |
| #include "dbus/message.h" |
| #include "dbus/mock_bus.h" |
| #include "dbus/mock_exported_object.h" |
| #include "dbus/mock_object_proxy.h" |
| #include "dbus/object_manager.h" |
| #include "dbus/object_path.h" |
| #include "device/bluetooth/floss/floss_dbus_client.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace floss { |
| namespace { |
| |
| using testing::DoAll; |
| |
| const std::vector<std::pair<int, bool>> kMockAdaptersAvailable = {{0, false}, |
| {5, true}}; |
| |
| void FakeExportMethod( |
| const std::string& interface_name, |
| const std::string& method_name, |
| const dbus::ExportedObject::MethodCallCallback& method_call_callback, |
| dbus::ExportedObject::OnExportedCallback on_exported_callback) { |
| std::move(on_exported_callback) |
| .Run(interface_name, method_name, /*success=*/true); |
| } |
| |
| class TestManagerObserver : public FlossManagerClient::Observer { |
| public: |
| explicit TestManagerObserver(FlossManagerClient* client) : client_(client) { |
| client_->AddObserver(this); |
| } |
| |
| ~TestManagerObserver() override { client_->RemoveObserver(this); } |
| |
| void ManagerPresent(bool present) override { |
| manager_present_count_++; |
| manager_present_ = present; |
| } |
| |
| void AdapterPresent(int adapter, bool present) override { |
| adapter_present_count_++; |
| adapter_present_[adapter] = present; |
| } |
| |
| void AdapterEnabledChanged(int adapter, bool enabled) override { |
| adapter_enabled_changed_count_++; |
| adapter_enabled_[adapter] = enabled; |
| } |
| |
| int manager_present_count_ = 0; |
| int adapter_present_count_ = 0; |
| int adapter_enabled_changed_count_ = 0; |
| |
| bool manager_present_ = false; |
| std::map<int, bool> adapter_present_; |
| std::map<int, bool> adapter_enabled_; |
| |
| private: |
| raw_ptr<FlossManagerClient> client_ = nullptr; |
| }; |
| |
| } // namespace |
| |
| class FlossManagerClientTest : public testing::Test { |
| public: |
| FlossManagerClientTest() = default; |
| |
| base::Version GetCurrVersion() { |
| return floss::version::GetMaximalSupportedVersion(); |
| } |
| |
| void SetUpMocks() { |
| auto obj_mgr_path = |
| ::dbus::ObjectPath(FlossManagerClient::kObjectManagerPath); |
| |
| manager_object_proxy_ = base::MakeRefCounted<::dbus::MockObjectProxy>( |
| bus_.get(), kManagerInterface, ::dbus::ObjectPath(kManagerObject)); |
| |
| exported_callbacks_ = base::MakeRefCounted<::dbus::MockExportedObject>( |
| bus_.get(), |
| ::dbus::ObjectPath(FlossManagerClient::kExportedCallbacksPath)); |
| |
| // Make sure a valid object manager is returned |
| EXPECT_CALL(*bus_.get(), GetObjectProxy(kManagerInterface, obj_mgr_path)) |
| .WillOnce(::testing::Return(manager_object_proxy_.get())); |
| EXPECT_CALL(*bus_.get(), GetDBusTaskRunner()) |
| .WillOnce(::testing::Return( |
| ::base::SequencedTaskRunner::GetCurrentDefault().get())); |
| object_manager_ = ::dbus::ObjectManager::Create( |
| bus_.get(), kManagerInterface, obj_mgr_path); |
| EXPECT_CALL(*bus_.get(), |
| GetObjectManager(kManagerInterface, dbus::ObjectPath("/"))) |
| .WillOnce(::testing::Return(object_manager_.get())); |
| |
| // Set up expects for remaining interfaces |
| EXPECT_CALL(*bus_.get(), GetObjectProxy(kManagerInterface, |
| ::dbus::ObjectPath(kManagerObject))) |
| .WillRepeatedly(::testing::Return(manager_object_proxy_.get())); |
| EXPECT_CALL(*bus_.get(), GetExportedObject) |
| .WillRepeatedly(::testing::Return(exported_callbacks_.get())); |
| |
| // Exported callback methods that we don't need to invoke. |
| EXPECT_CALL(*exported_callbacks_.get(), ExportMethod) |
| .Times(1) |
| .WillRepeatedly(&FakeExportMethod); |
| // Save method handlers of exported callbacks that we need to invoke here. |
| EXPECT_CALL( |
| *exported_callbacks_.get(), |
| ExportMethod(manager::kCallbackInterface, manager::kOnHciDeviceChanged, |
| testing::_, testing::_)) |
| .WillOnce(DoAll(testing::SaveArg<2>(&on_hci_device_changed_), |
| &FakeExportMethod)); |
| EXPECT_CALL( |
| *exported_callbacks_.get(), |
| ExportMethod(manager::kCallbackInterface, manager::kOnHciEnabledChanged, |
| testing::_, testing::_)) |
| .WillOnce(DoAll(testing::SaveArg<2>(&on_hci_enabled_changed_), |
| &FakeExportMethod)); |
| |
| // Handle method calls on the object proxy |
| ON_CALL(*manager_object_proxy_.get(), CallMethodWithErrorResponse) |
| .WillByDefault([this](::dbus::MethodCall* method_call, int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| if (method_call->GetMember() == manager::kGetAvailableAdapters) { |
| HandleGetAvailableAdapters(method_call, timeout_ms, std::move(cb)); |
| } else if (method_call->GetMember() == manager::kGetAdapterEnabled) { |
| HandleGetAdapterEnabled(method_call, timeout_ms, std::move(cb)); |
| } else if (method_call->GetMember() == manager::kSetFlossEnabled) { |
| HandleSetFlossEnabled(method_call, timeout_ms, std::move(cb)); |
| } else if (method_call->GetMember() == manager::kGetFlossEnabled) { |
| HandleGetFlossEnabled(method_call, timeout_ms, std::move(cb)); |
| } else if (method_call->GetMember() == manager::kGetFlossApiVersion) { |
| HandleGetFlossApiVersion(method_call, timeout_ms, std::move(cb)); |
| } |
| |
| method_called_[method_call->GetMember()]++; |
| }); |
| } |
| |
| void SendHciDeviceCallback(int adapter, |
| bool present, |
| dbus::ExportedObject::ResponseSender response) { |
| dbus::MethodCall method_call(manager::kCallbackInterface, |
| manager::kOnHciDeviceChanged); |
| method_call.SetSerial(serial_++); |
| dbus::MessageWriter writer(&method_call); |
| writer.AppendInt32(adapter); |
| writer.AppendBool(present); |
| |
| on_hci_device_changed_.Run(&method_call, std::move(response)); |
| } |
| |
| void SendInvalidHciDeviceCallback(dbus::ExportedObject::ResponseSender rsp) { |
| dbus::MethodCall method_call(manager::kCallbackInterface, |
| manager::kOnHciDeviceChanged); |
| method_call.SetSerial(serial_++); |
| on_hci_device_changed_.Run(&method_call, std::move(rsp)); |
| } |
| |
| void SendHciEnabledCallback(int adapter, |
| bool enabled, |
| dbus::ExportedObject::ResponseSender response) { |
| dbus::MethodCall method_call(manager::kCallbackInterface, |
| manager::kOnHciEnabledChanged); |
| method_call.SetSerial(serial_++); |
| dbus::MessageWriter writer(&method_call); |
| writer.AppendInt32(adapter); |
| writer.AppendBool(enabled); |
| |
| on_hci_enabled_changed_.Run(&method_call, std::move(response)); |
| } |
| |
| void SendInvalidHciEnabledCallback(dbus::ExportedObject::ResponseSender rsp) { |
| dbus::MethodCall method_call(manager::kCallbackInterface, |
| manager::kOnHciEnabledChanged); |
| method_call.SetSerial(serial_++); |
| on_hci_enabled_changed_.Run(&method_call, std::move(rsp)); |
| } |
| |
| void SetUp() override { |
| ::dbus::Bus::Options options; |
| options.bus_type = ::dbus::Bus::BusType::SYSTEM; |
| bus_ = base::MakeRefCounted<::dbus::MockBus>(std::move(options)); |
| client_ = FlossManagerClient::Create(); |
| |
| SetUpMocks(); |
| } |
| |
| void TearDown() override { |
| // Clean up the client first so it gets rid of all its references to the |
| // various buses, object proxies, etc. |
| client_.reset(); |
| method_called_.clear(); |
| } |
| |
| void HandleGetAvailableAdapters( |
| ::dbus::MethodCall* method_call, |
| int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| // Return that there are 2 adapter objects |
| auto response = ::dbus::Response::CreateEmpty(); |
| |
| ::dbus::MessageWriter msg(response.get()); |
| ::dbus::MessageWriter outer(nullptr); |
| msg.OpenArray("a{sv}", &outer); |
| for (auto kv : kMockAdaptersAvailable) { |
| ::dbus::MessageWriter inner(nullptr); |
| ::dbus::MessageWriter dict(nullptr); |
| outer.OpenArray("{sv}", &inner); |
| |
| inner.OpenDictEntry(&dict); |
| dict.AppendString("hci_interface"); |
| dict.AppendVariantOfInt32(kv.first); |
| inner.CloseContainer(&dict); |
| |
| inner.OpenDictEntry(&dict); |
| dict.AppendString("enabled"); |
| dict.AppendVariantOfBool(kv.second); |
| inner.CloseContainer(&dict); |
| |
| outer.CloseContainer(&inner); |
| } |
| msg.CloseContainer(&outer); |
| |
| std::move(cb).Run(response.get(), nullptr); |
| } |
| |
| void HandleGetAdapterEnabled( |
| ::dbus::MethodCall* method_call, |
| int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| auto response = ::dbus::Response::CreateEmpty(); |
| ::dbus::MessageWriter writer(response.get()); |
| writer.AppendBool(get_adapter_enabled_return_); |
| std::move(cb).Run(response.get(), nullptr); |
| } |
| |
| void HandleSetFlossEnabled(::dbus::MethodCall* method_call, |
| int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| method_call->SetSerial(serial_++); |
| if (fail_setfloss_count_ > 0) { |
| fail_setfloss_count_--; |
| |
| std::string error_name("org.foo.bar"); |
| std::string error_message("SetFlossEnabled failed"); |
| auto error = ::dbus::ErrorResponse::FromMethodCall( |
| method_call, error_name, error_message); |
| std::move(cb).Run(nullptr, error.get()); |
| } else { |
| auto response = ::dbus::Response::CreateEmpty(); |
| std::move(cb).Run(response.get(), nullptr); |
| } |
| } |
| |
| void HandleGetFlossEnabled(::dbus::MethodCall* method_call, |
| int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| method_call->SetSerial(serial_++); |
| if (fail_getfloss_count_ > 0) { |
| fail_getfloss_count_--; |
| |
| std::string error_name("org.foo.bar"); |
| std::string error_message("GetFlossEnabled failed"); |
| auto error = ::dbus::ErrorResponse::FromMethodCall( |
| method_call, error_name, error_message); |
| std::move(cb).Run(nullptr, error.get()); |
| } else { |
| auto response = ::dbus::Response::CreateEmpty(); |
| ::dbus::MessageWriter writer(response.get()); |
| writer.AppendBool(floss_enabled_target_); |
| std::move(cb).Run(response.get(), nullptr); |
| } |
| } |
| |
| void HandleGetFlossApiVersion( |
| ::dbus::MethodCall* method_call, |
| int timeout_ms, |
| ::dbus::ObjectProxy::ResponseOrErrorCallback cb) { |
| auto response = ::dbus::Response::CreateEmpty(); |
| ::dbus::MessageWriter writer(response.get()); |
| writer.AppendUint32(floss_api_version_); |
| std::move(cb).Run(response.get(), nullptr); |
| } |
| |
| void ExpectErrorResponse(std::unique_ptr<dbus::Response> response) { |
| EXPECT_EQ(response->GetMessageType(), |
| dbus::Message::MessageType::MESSAGE_ERROR); |
| } |
| |
| void ExpectNormalResponse(std::unique_ptr<dbus::Response> response) { |
| EXPECT_NE(response->GetMessageType(), |
| dbus::Message::MessageType::MESSAGE_ERROR); |
| } |
| |
| void TriggerObjectAdded(dbus::ObjectPath& path, |
| const std::string& interface) { |
| client_->ObjectAdded(path, interface); |
| } |
| |
| void TriggerObjectRemoved(dbus::ObjectPath& path, |
| const std::string& interface) { |
| client_->ObjectRemoved(path, interface); |
| } |
| |
| bool IsInterfaceRegisteredOnObjectManager(const std::string& interface) { |
| return client_->object_manager_ != nullptr && |
| client_->object_manager_->IsInterfaceRegisteredForTesting(interface); |
| } |
| |
| protected: |
| void SetFlossEnabled(bool enable, |
| int retry_count, |
| int retry_ms, |
| base::RepeatingClosure quitloop) { |
| client_->SetFlossEnabled(enable, retry_count, retry_ms, |
| GetQuitLoopCallback(quitloop)); |
| } |
| |
| void DoGetFlossApiVersion() { client_->DoGetFlossApiVersion(); } |
| |
| bool IsCompatibleFlossApi() { return client_->IsCompatibleFlossApi(); } |
| |
| void EndRunLoopCallback(base::RepeatingClosure quit, DBusResult<bool> ret) { |
| std::move(quit).Run(); |
| } |
| |
| ResponseCallback<bool> GetQuitLoopCallback(base::RepeatingClosure quit) { |
| return base::BindOnce(&FlossManagerClientTest::EndRunLoopCallback, |
| weak_ptr_factory_.GetWeakPtr(), std::move(quit)); |
| } |
| |
| // DBus messages require an increasing serial number or the dbus libraries |
| // assert. |
| int serial_ = 1; |
| std::unique_ptr<FlossManagerClient> client_; |
| scoped_refptr<::dbus::MockBus> bus_; |
| scoped_refptr<::dbus::MockExportedObject> exported_callbacks_; |
| scoped_refptr<::dbus::MockObjectProxy> manager_object_proxy_; |
| scoped_refptr<::dbus::ObjectManager> object_manager_; |
| std::map<std::string, int> method_called_; |
| |
| // Testing the |SetFlossEnabled| retry with a target of enabling Floss. |
| int fail_setfloss_count_ = 0; |
| int fail_getfloss_count_ = 0; |
| bool floss_enabled_target_ = true; |
| uint32_t floss_api_version_ = 0x1234abcd; |
| |
| bool get_adapter_enabled_return_ = false; |
| |
| dbus::ExportedObject::MethodCallCallback on_hci_device_changed_; |
| dbus::ExportedObject::MethodCallCallback on_hci_enabled_changed_; |
| |
| base::test::SingleThreadTaskEnvironment task_environment_; |
| base::WeakPtrFactory<FlossManagerClientTest> weak_ptr_factory_{this}; |
| }; |
| |
| // Make sure adapter presence is updated on init |
| TEST_F(FlossManagerClientTest, QueriesAdapterPresenceOnInit) { |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| EXPECT_EQ(observer.manager_present_count_, 1); |
| EXPECT_TRUE(observer.manager_present_); |
| |
| EXPECT_THAT(client_->GetAdapters(), ::testing::ElementsAre(0, 5)); |
| EXPECT_TRUE(client_->GetAdapterPresent(0)); |
| EXPECT_TRUE(client_->GetAdapterPresent(5)); |
| EXPECT_FALSE(client_->GetAdapterPresent(1)); |
| |
| EXPECT_EQ(observer.adapter_present_count_, 2); |
| EXPECT_TRUE(observer.adapter_present_[0]); |
| EXPECT_TRUE(observer.adapter_present_[5]); |
| } |
| |
| // Make sure adapter presence is plumbed through callbacks |
| TEST_F(FlossManagerClientTest, VerifyAdapterPresent) { |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| EXPECT_EQ(observer.adapter_present_count_, 2); |
| EXPECT_EQ(observer.adapter_enabled_changed_count_, 2); |
| EXPECT_TRUE(observer.adapter_present_[0]); |
| |
| SendInvalidHciDeviceCallback( |
| base::BindOnce(&FlossManagerClientTest::ExpectErrorResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| SendHciDeviceCallback( |
| 0, false, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| EXPECT_THAT(client_->GetAdapters(), ::testing::ElementsAre(5)); |
| EXPECT_TRUE(client_->GetAdapterPresent(5)); |
| EXPECT_FALSE(client_->GetAdapterPresent(0)); |
| EXPECT_FALSE(client_->GetAdapterEnabled(0)); |
| |
| // 2 to start and 1 to remove "0" |
| EXPECT_EQ(observer.adapter_present_count_, 3); |
| EXPECT_FALSE(observer.adapter_present_[0]); |
| |
| // On present = false, the client may not be sent an additional enabled |
| // = false. It is implied and the client must act accordingly. |
| EXPECT_EQ(observer.adapter_enabled_changed_count_, 2); |
| } |
| |
| // Make sure we query the enabled state when adapter presents |
| TEST_F(FlossManagerClientTest, VerifyAdapterPresentEnabled) { |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| |
| EXPECT_EQ(method_called_[manager::kGetAdapterEnabled], 0); |
| EXPECT_EQ(observer.adapter_present_count_, 2); |
| |
| // A disabled adapter presents |
| SendHciDeviceCallback( |
| 1, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| EXPECT_EQ(method_called_[manager::kGetAdapterEnabled], 1); |
| EXPECT_EQ(observer.adapter_present_count_, 3); |
| EXPECT_FALSE(client_->GetAdapterEnabled(1)); |
| |
| // An enabled adapter presents |
| get_adapter_enabled_return_ = true; |
| SendHciDeviceCallback( |
| 2, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| EXPECT_EQ(method_called_[manager::kGetAdapterEnabled], 2); |
| EXPECT_EQ(observer.adapter_present_count_, 4); |
| EXPECT_TRUE(client_->GetAdapterEnabled(2)); |
| |
| // Presenting twice should be no-op |
| SendHciDeviceCallback( |
| 2, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| EXPECT_EQ(method_called_[manager::kGetAdapterEnabled], 2); |
| EXPECT_EQ(observer.adapter_present_count_, 4); |
| EXPECT_TRUE(client_->GetAdapterEnabled(2)); |
| } |
| |
| // Make sure adapter powered is plumbed through callbacks |
| TEST_F(FlossManagerClientTest, VerifyAdapterEnabled) { |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| // Pre-conditions |
| EXPECT_FALSE(client_->GetAdapterEnabled(0)); |
| EXPECT_TRUE(client_->GetAdapterEnabled(5)); |
| EXPECT_EQ(observer.adapter_enabled_changed_count_, 2); |
| |
| // Adapter 1 is not present at the beginning |
| EXPECT_FALSE(client_->GetAdapterEnabled(1)); |
| EXPECT_FALSE(client_->GetAdapterPresent(1)); |
| |
| SendInvalidHciEnabledCallback( |
| base::BindOnce(&FlossManagerClientTest::ExpectErrorResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| SendHciEnabledCallback( |
| 0, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| |
| EXPECT_TRUE(client_->GetAdapterEnabled(0)); |
| EXPECT_EQ(observer.adapter_enabled_changed_count_, 3); |
| EXPECT_TRUE(observer.adapter_enabled_[0]); |
| |
| // Enabled implies presence too |
| SendHciEnabledCallback( |
| 1, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| EXPECT_TRUE(client_->GetAdapterPresent(1)); |
| EXPECT_TRUE(client_->GetAdapterEnabled(1)); |
| |
| EXPECT_EQ(observer.adapter_enabled_changed_count_, 4); |
| EXPECT_TRUE(observer.adapter_enabled_[1]); |
| // On enabled = true, present = true is implied. The platform should emit both |
| // but the client shouldn't depend on it. |
| EXPECT_FALSE(observer.adapter_present_[1]); |
| |
| // 5 was unchanged |
| EXPECT_TRUE(client_->GetAdapterEnabled(5)); |
| EXPECT_TRUE(observer.adapter_enabled_[5]); |
| } |
| |
| // Make sure manager presence is correctly detected |
| TEST_F(FlossManagerClientTest, HandleManagerPresence) { |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| dbus::ObjectPath opath = dbus::ObjectPath(kManagerObject); |
| EXPECT_EQ(observer.manager_present_count_, 1); |
| |
| // Make sure we registered against ObjectManager |
| EXPECT_TRUE(IsInterfaceRegisteredOnObjectManager(kManagerInterface)); |
| |
| // By default, the manager should be available |
| EXPECT_TRUE(observer.manager_present_); |
| |
| // Triggering an ObjectRemoved should clear all present adapters |
| TriggerObjectRemoved(opath, kManagerInterface); |
| EXPECT_THAT(client_->GetAdapters(), ::testing::ElementsAre()); |
| EXPECT_FALSE(observer.manager_present_); |
| |
| // Triggering ObjectRemoved while already unavailable should do nothing |
| TriggerObjectRemoved(opath, kManagerInterface); |
| EXPECT_THAT(client_->GetAdapters(), ::testing::ElementsAre()); |
| EXPECT_FALSE(observer.manager_present_); |
| |
| method_called_.clear(); |
| // Triggering ObjectAdded should refill available hci devices and register |
| // callbacks |
| TriggerObjectAdded(opath, kManagerInterface); |
| EXPECT_TRUE(method_called_[manager::kGetAvailableAdapters] > 0); |
| EXPECT_TRUE(method_called_[manager::kRegisterCallback] > 0); |
| EXPECT_TRUE(observer.manager_present_); |
| |
| // Triggering ObjectAdded on an already added object should do nothing |
| observer.manager_present_count_ = 0; |
| method_called_.clear(); |
| SendHciDeviceCallback( |
| 1, true, |
| base::BindOnce(&FlossManagerClientTest::ExpectNormalResponse, |
| weak_ptr_factory_.GetWeakPtr())); |
| EXPECT_TRUE(method_called_[manager::kGetAdapterEnabled] > 0); |
| EXPECT_TRUE(client_->GetAdapterPresent(1)); |
| TriggerObjectAdded(opath, kManagerInterface); |
| EXPECT_EQ(observer.manager_present_count_, 0); |
| EXPECT_TRUE(client_->GetAdapterPresent(1)); |
| EXPECT_TRUE(method_called_[manager::kGetAvailableAdapters] == 0); |
| EXPECT_TRUE(method_called_[manager::kRegisterCallback] == 0); |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| TEST_F(FlossManagerClientTest, SetFlossEnabledRetries) { |
| base::RunLoop loop; |
| |
| TestManagerObserver observer(client_.get()); |
| floss_enabled_target_ = false; |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| |
| // First confirm we had it set to False |
| EXPECT_EQ(method_called_[manager::kSetFlossEnabled], 1); |
| EXPECT_EQ(method_called_[manager::kGetFlossEnabled], 1); |
| |
| method_called_.clear(); |
| |
| // Retries up to 3 times across both Get and Set. |
| fail_setfloss_count_ = 1; |
| fail_getfloss_count_ = 1; |
| floss_enabled_target_ = true; |
| SetFlossEnabled(true, 3, 0, loop.QuitClosure()); |
| loop.Run(); |
| |
| EXPECT_EQ(method_called_[manager::kSetFlossEnabled], 2); |
| EXPECT_EQ(method_called_[manager::kGetFlossEnabled], 2); |
| } |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| TEST_F(FlossManagerClientTest, GetFlossApiVersion) { |
| base::Version version = floss::version::IntoVersion(floss_api_version_); |
| |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| |
| method_called_.clear(); |
| DoGetFlossApiVersion(); |
| |
| EXPECT_EQ(method_called_[manager::kGetFlossApiVersion], 1); |
| EXPECT_EQ(client_->GetFlossApiVersion(), version); |
| } |
| |
| TEST_F(FlossManagerClientTest, NewFlossDaemonIsNotCompatible) { |
| // Given Floss daemon's Floss API version is a newer one. |
| floss_api_version_ = 0xffffffff; |
| |
| // When FlossManagerClient gets the Floss API version at initialized. |
| TestManagerObserver observer(client_.get()); |
| client_->Init(bus_.get(), kManagerInterface, /*adapter_index=*/-1, |
| GetCurrVersion(), base::DoNothing()); |
| |
| // Then, the Floss API exported by Floss daemon is not compatible. |
| EXPECT_FALSE(IsCompatibleFlossApi()); |
| } |
| } // namespace floss |
