| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include<stddef.h> |
| |
| #include<algorithm> |
| #include<array> |
| #include<memory> |
| #include<optional> |
| #include<string> |
| #include<vector> |
| |
| #include"base/functional/bind.h" |
| #include"base/functional/callback_helpers.h" |
| #include"base/memory/raw_ptr.h" |
| #include"base/message_loop/message_pump_type.h" |
| #include"base/run_loop.h" |
| #include"base/task/single_thread_task_runner.h" |
| #include"base/test/task_environment.h" |
| #include"base/test/test_timeouts.h" |
| #include"base/threading/thread.h" |
| #include"base/threading/thread_restrictions.h" |
| #include"base/time/time.h" |
| #include"dbus/bus.h" |
| #include"dbus/message.h" |
| #include"dbus/object_path.h" |
| #include"dbus/object_proxy.h" |
| #include"dbus/test_service.h" |
| #include"testing/gtest/include/gtest/gtest.h" |
| |
| namespace dbus{ |
| |
| namespace{ |
| |
| // See comments in ObjectProxy::RunResponseCallback() for why the number was |
| // chosen. |
| constint kHugePayloadSize=64<<20;// 64 MB |
| |
| }// namespace |
| |
| // The end-to-end test exercises the asynchronous APIs in ObjectProxy and |
| // ExportedObject. |
| classEndToEndAsyncTest:public testing::Test{ |
| public: |
| voidSetUp() override{ |
| // Make the main thread not to allow IO. |
| disallow_blocking_.emplace(); |
| |
| // Start the D-Bus thread. |
| dbus_thread_= std::make_unique<base::Thread>("D-Bus Thread"); |
| base::Thread::Options thread_options; |
| thread_options.message_pump_type= base::MessagePumpType::IO; |
| ASSERT_TRUE(dbus_thread_->StartWithOptions(std::move(thread_options))); |
| |
| // Start the test service, using the D-Bus thread. |
| TestService::Options options; |
| options.dbus_task_runner= dbus_thread_->task_runner(); |
| test_service_= std::make_unique<TestService>(options); |
| ASSERT_TRUE(test_service_->StartService()); |
| test_service_->WaitUntilServiceIsStarted(); |
| ASSERT_TRUE(test_service_->HasDBusThread()); |
| |
| // Create the client, using the D-Bus thread. |
| Bus::Options bus_options; |
| bus_options.bus_type=Bus::SESSION; |
| bus_options.connection_type=Bus::PRIVATE; |
| bus_options.dbus_task_runner= dbus_thread_->task_runner(); |
| bus_=newBus(bus_options); |
| object_proxy_= bus_->GetObjectProxy( |
| test_service_->service_name(), |
| ObjectPath("/org/chromium/TestObject")); |
| ASSERT_TRUE(bus_->HasDBusThread()); |
| |
| // Connect to the "Test" signal of "org.chromium.TestInterface" from |
| // the remote object. |
| object_proxy_->ConnectToSignal( |
| "org.chromium.TestInterface","Test", |
| base::BindRepeating(&EndToEndAsyncTest::OnTestSignal, |
| base::Unretained(this)), |
| base::BindOnce(&EndToEndAsyncTest::OnConnected, |
| base::Unretained(this))); |
| // Wait until the object proxy is connected to the signal. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| |
| // Connect to the "Test2" signal of "org.chromium.TestInterface" from |
| // the remote object. There was a bug where we were emitting error |
| // messages like "Requested to remove an unknown match rule: ..." at |
| // the shutdown of Bus when an object proxy is connected to more than |
| // one signal of the same interface. See crosbug.com/23382 for details. |
| object_proxy_->ConnectToSignal( |
| "org.chromium.TestInterface","Test2", |
| base::BindRepeating(&EndToEndAsyncTest::OnTest2Signal, |
| base::Unretained(this)), |
| base::BindOnce(&EndToEndAsyncTest::OnConnected, |
| base::Unretained(this))); |
| // Wait until the object proxy is connected to the signal. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| |
| // Create a second object proxy for the root object. |
| root_object_proxy_= bus_->GetObjectProxy(test_service_->service_name(), |
| ObjectPath("/")); |
| ASSERT_TRUE(bus_->HasDBusThread()); |
| |
| // Connect to the "Test" signal of "org.chromium.TestInterface" from |
| // the root remote object too. |
| root_object_proxy_->ConnectToSignal( |
| "org.chromium.TestInterface","Test", |
| base::BindRepeating(&EndToEndAsyncTest::OnRootTestSignal, |
| base::Unretained(this)), |
| base::BindOnce(&EndToEndAsyncTest::OnConnected, |
| base::Unretained(this))); |
| // Wait until the root object proxy is connected to the signal. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| } |
| |
| voidTearDown() override{ |
| bus_->ShutdownOnDBusThreadAndBlock(); |
| |
| // Shut down the service. |
| test_service_->ShutdownAndBlock(); |
| |
| // Stopping a thread is considered an IO operation, so do this after |
| // allowing IO. |
| disallow_blocking_.reset(); |
| test_service_->Stop(); |
| } |
| |
| protected: |
| // Replaces the bus with a broken one. |
| voidSetUpBrokenBus(){ |
| // Shut down the existing bus. |
| bus_->ShutdownOnDBusThreadAndBlock(); |
| |
| // Create new bus with invalid address. |
| constchar kInvalidAddress[]=""; |
| Bus::Options bus_options; |
| bus_options.bus_type=Bus::CUSTOM_ADDRESS; |
| bus_options.address= kInvalidAddress; |
| bus_options.connection_type=Bus::PRIVATE; |
| bus_options.dbus_task_runner= dbus_thread_->task_runner(); |
| bus_=newBus(bus_options); |
| ASSERT_TRUE(bus_->HasDBusThread()); |
| |
| // Create new object proxy. |
| object_proxy_= bus_->GetObjectProxy( |
| test_service_->service_name(), |
| ObjectPath("/org/chromium/TestObject")); |
| } |
| |
| // Calls the method asynchronously. OnResponse() will be called once the |
| // response is received. |
| voidCallMethod(MethodCall* method_call, |
| int timeout_ms){ |
| object_proxy_->CallMethod( |
| method_call, timeout_ms, |
| base::BindOnce(&EndToEndAsyncTest::OnResponse, base::Unretained(this))); |
| } |
| |
| // Calls the method asynchronously. OnResponse() will be called once the |
| // response is received without error, otherwise OnError() will be called. |
| voidCallMethodWithErrorCallback(MethodCall* method_call, |
| int timeout_ms){ |
| object_proxy_->CallMethodWithErrorCallback( |
| method_call, timeout_ms, |
| base::BindOnce(&EndToEndAsyncTest::OnResponse, base::Unretained(this)), |
| base::BindOnce(&EndToEndAsyncTest::OnError, base::Unretained(this))); |
| } |
| |
| // Wait for the give number of responses. |
| voidWaitForResponses(size_t num_responses){ |
| while(response_strings_.size()< num_responses){ |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| } |
| } |
| |
| // Called when the response is received. |
| voidOnResponse(Response* response){ |
| // |response| will be deleted on exit of the function. Copy the |
| // payload to |response_strings_|. |
| if(response){ |
| MessageReader reader(response); |
| std::string response_string; |
| ASSERT_TRUE(reader.PopString(&response_string)); |
| response_strings_.push_back(response_string); |
| }else{ |
| response_strings_.push_back(std::string()); |
| } |
| run_loop_->Quit(); |
| } |
| |
| // Wait for the given number of errors. |
| voidWaitForErrors(size_t num_errors){ |
| while(error_names_.size()< num_errors){ |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| } |
| } |
| |
| // Called when an error is received. |
| voidOnError(ErrorResponse* error){ |
| // |error| will be deleted on exit of the function. Copy the payload to |
| // |error_names_|. |
| if(error){ |
| ASSERT_NE("", error->GetErrorName()); |
| error_names_.push_back(error->GetErrorName()); |
| }else{ |
| error_names_.push_back(std::string()); |
| } |
| run_loop_->Quit(); |
| } |
| |
| // Called when the "Test" signal is received, in the main thread. |
| // Copy the string payload to |test_signal_string_|. |
| voidOnTestSignal(Signal* signal){ |
| MessageReader reader(signal); |
| ASSERT_TRUE(reader.PopString(&test_signal_string_)); |
| run_loop_->Quit(); |
| } |
| |
| // Called when the "Test" signal is received, in the main thread, by |
| // the root object proxy. Copy the string payload to |
| // |root_test_signal_string_|. |
| voidOnRootTestSignal(Signal* signal){ |
| MessageReader reader(signal); |
| ASSERT_TRUE(reader.PopString(&root_test_signal_string_)); |
| run_loop_->Quit(); |
| } |
| |
| // Called when the "Test2" signal is received, in the main thread. |
| voidOnTest2Signal(Signal* signal){ |
| MessageReader reader(signal); |
| run_loop_->Quit(); |
| } |
| |
| // Called when connected to the signal. |
| voidOnConnected(const std::string& interface_name, |
| const std::string& signal_name, |
| bool success){ |
| ASSERT_TRUE(success); |
| run_loop_->Quit(); |
| } |
| |
| // Wait for the hey signal to be received. |
| voidWaitForTestSignal(){ |
| // OnTestSignal() will quit the message loop. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| } |
| |
| base::test::SingleThreadTaskEnvironment task_environment_; |
| std::optional<base::ScopedDisallowBlocking> disallow_blocking_; |
| std::unique_ptr<base::RunLoop> run_loop_; |
| std::vector<std::string> response_strings_; |
| std::vector<std::string> error_names_; |
| std::unique_ptr<base::Thread> dbus_thread_; |
| scoped_refptr<Bus> bus_; |
| raw_ptr<ObjectProxy,AcrossTasksDanglingUntriaged> object_proxy_; |
| raw_ptr<ObjectProxy,AcrossTasksDanglingUntriaged> root_object_proxy_; |
| std::unique_ptr<TestService> test_service_; |
| // Text message from "Test" signal. |
| std::string test_signal_string_; |
| // Text message from "Test" signal delivered to root. |
| std::string root_test_signal_string_; |
| }; |
| |
| TEST_F(EndToEndAsyncTest,Echo){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| |
| // Check the response. |
| WaitForResponses(1); |
| EXPECT_EQ(kHello, response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,EchoWithErrorCallback){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| |
| // Check the response. |
| WaitForResponses(1); |
| EXPECT_EQ(kHello, response_strings_[0]); |
| EXPECT_TRUE(error_names_.empty()); |
| } |
| |
| // Call Echo method three times. |
| TEST_F(EndToEndAsyncTest,EchoThreeTimes){ |
| auto kMessages= std::to_array<constchar*>({"foo","bar","baz"}); |
| |
| for(size_t i=0; i< std::size(kMessages);++i){ |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kMessages[i]); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| } |
| |
| // Check the responses. |
| WaitForResponses(3); |
| // Sort as the order of the returned messages is not deterministic. |
| std::sort(response_strings_.begin(), response_strings_.end()); |
| EXPECT_EQ("bar", response_strings_[0]); |
| EXPECT_EQ("baz", response_strings_[1]); |
| EXPECT_EQ("foo", response_strings_[2]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,Echo_HugePayload){ |
| const std::string kHugePayload(kHugePayloadSize,'o'); |
| |
| // Create the method call with a huge payload. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHugePayload); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| |
| // This caused a DCHECK failure before. Ensure that the issue is fixed. |
| WaitForResponses(1); |
| EXPECT_EQ(kHugePayload, response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,BrokenBus){ |
| constchar* kHello="hello"; |
| |
| // Set up a broken bus. |
| SetUpBrokenBus(); |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| WaitForResponses(1); |
| |
| // Should fail because of the broken bus. |
| ASSERT_EQ("", response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,BrokenBusWithErrorCallback){ |
| constchar* kHello="hello"; |
| |
| // Set up a broken bus. |
| SetUpBrokenBus(); |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| WaitForErrors(1); |
| |
| // Should fail because of the broken bus. |
| ASSERT_TRUE(response_strings_.empty()); |
| ASSERT_EQ("", error_names_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,Timeout){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","SlowEcho"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method with timeout of 0ms. |
| constint timeout_ms=0; |
| CallMethod(&method_call, timeout_ms); |
| WaitForResponses(1); |
| |
| // Should fail because of timeout. |
| ASSERT_EQ("", response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,TimeoutWithErrorCallback){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","SlowEcho"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method with timeout of 0ms. |
| constint timeout_ms=0; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| WaitForErrors(1); |
| |
| // Should fail because of timeout. |
| ASSERT_TRUE(response_strings_.empty()); |
| ASSERT_EQ(DBUS_ERROR_NO_REPLY, error_names_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,CancelPendingCalls){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| |
| // Remove the object proxy before receiving the result. |
| // This results in cancelling the pending method call. |
| bus_->RemoveObjectProxy(test_service_->service_name(), |
| ObjectPath("/org/chromium/TestObject"), |
| base::DoNothing()); |
| |
| // We shouldn't receive any responses. Wait for a while just to make sure. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| task_environment_.GetMainThreadTaskRunner()->PostDelayedTask( |
| FROM_HERE, run_loop_->QuitClosure(),TestTimeouts::tiny_timeout()); |
| run_loop_->Run(); |
| EXPECT_TRUE(response_strings_.empty()); |
| } |
| |
| // Tests calling a method that sends its reply asynchronously. |
| TEST_F(EndToEndAsyncTest,AsyncEcho){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","AsyncEcho"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| |
| // Check the response. |
| WaitForResponses(1); |
| EXPECT_EQ(kHello, response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,NonexistentMethod){ |
| MethodCall method_call("org.chromium.TestInterface","Nonexistent"); |
| |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| WaitForResponses(1); |
| |
| // Should fail because the method is nonexistent. |
| ASSERT_EQ("", response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,NonexistentMethodWithErrorCallback){ |
| MethodCall method_call("org.chromium.TestInterface","Nonexistent"); |
| |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| WaitForErrors(1); |
| |
| // Should fail because the method is nonexistent. |
| ASSERT_TRUE(response_strings_.empty()); |
| ASSERT_EQ(DBUS_ERROR_UNKNOWN_METHOD, error_names_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,BrokenMethod){ |
| MethodCall method_call("org.chromium.TestInterface","BrokenMethod"); |
| |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethod(&method_call, timeout_ms); |
| WaitForResponses(1); |
| |
| // Should fail because the method is broken. |
| ASSERT_EQ("", response_strings_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,BrokenMethodWithErrorCallback){ |
| MethodCall method_call("org.chromium.TestInterface","BrokenMethod"); |
| |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| WaitForErrors(1); |
| |
| // Should fail because the method is broken. |
| ASSERT_TRUE(response_strings_.empty()); |
| ASSERT_EQ(DBUS_ERROR_FAILED, error_names_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,InvalidServiceName){ |
| // Bus name cannot contain '/'. |
| const std::string invalid_service_name=":1/2"; |
| |
| // Replace object proxy with new one. |
| object_proxy_= bus_->GetObjectProxy(invalid_service_name, |
| ObjectPath("/org/chromium/TestObject")); |
| |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| CallMethodWithErrorCallback(&method_call, timeout_ms); |
| WaitForErrors(1); |
| |
| // Should fail because of the invalid bus name. |
| ASSERT_TRUE(response_strings_.empty()); |
| ASSERT_EQ("", error_names_[0]); |
| } |
| |
| TEST_F(EndToEndAsyncTest,EmptyResponseCallback){ |
| constchar* kHello="hello"; |
| |
| // Create the method call. |
| MethodCall method_call("org.chromium.TestInterface","Echo"); |
| MessageWriter writer(&method_call); |
| writer.AppendString(kHello); |
| |
| // Call the method with an empty callback. |
| constint timeout_ms=ObjectProxy::TIMEOUT_USE_DEFAULT; |
| object_proxy_->CallMethod(&method_call, timeout_ms, base::DoNothing()); |
| // Post a delayed task to quit the RunLoop. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| task_environment_.GetMainThreadTaskRunner()->PostDelayedTask( |
| FROM_HERE, run_loop_->QuitClosure(),TestTimeouts::tiny_timeout()); |
| run_loop_->Run(); |
| // We cannot tell if the empty callback is called, but at least we can |
| // check if the test does not crash. |
| } |
| |
| TEST_F(EndToEndAsyncTest,TestSignal){ |
| constchar kMessage[]="hello, world"; |
| // Send the test signal from the exported object. |
| test_service_->SendTestSignal(kMessage); |
| // Receive the signal with the object proxy. The signal is handled in |
| // EndToEndAsyncTest::OnTestSignal() in the main thread. |
| WaitForTestSignal(); |
| ASSERT_EQ(kMessage, test_signal_string_); |
| } |
| |
| TEST_F(EndToEndAsyncTest,TestSignalFromRoot){ |
| constchar kMessage[]="hello, world"; |
| // Object proxies are tied to a particular object path, if a signal |
| // arrives from a different object path like "/" the first object proxy |
| // |object_proxy_| should not handle it, and should leave it for the root |
| // object proxy |root_object_proxy_|. |
| test_service_->SendTestSignalFromRoot(kMessage); |
| WaitForTestSignal(); |
| // Verify the signal was not received by the specific proxy. |
| ASSERT_TRUE(test_signal_string_.empty()); |
| // Verify the string WAS received by the root proxy. |
| ASSERT_EQ(kMessage, root_test_signal_string_); |
| } |
| |
| TEST_F(EndToEndAsyncTest,TestHugeSignal){ |
| const std::string kHugeMessage(kHugePayloadSize,'o'); |
| |
| // Send the huge signal from the exported object. |
| test_service_->SendTestSignal(kHugeMessage); |
| // This caused a DCHECK failure before. Ensure that the issue is fixed. |
| WaitForTestSignal(); |
| ASSERT_EQ(kHugeMessage, test_signal_string_); |
| } |
| |
| classSignalMultipleHandlerTest:publicEndToEndAsyncTest{ |
| public: |
| SignalMultipleHandlerTest()=default; |
| |
| voidSetUp() override{ |
| // Set up base class. |
| EndToEndAsyncTest::SetUp(); |
| |
| // Connect the root object proxy's signal handler to a new handler |
| // so that we can verify that a second call to ConnectSignal() delivers |
| // to both our new handler and the old. |
| object_proxy_->ConnectToSignal( |
| "org.chromium.TestInterface","Test", |
| base::BindRepeating(&SignalMultipleHandlerTest::OnAdditionalTestSignal, |
| base::Unretained(this)), |
| base::BindOnce(&SignalMultipleHandlerTest::OnAdditionalConnected, |
| base::Unretained(this))); |
| // Wait until the object proxy is connected to the signal. |
| run_loop_= std::make_unique<base::RunLoop>(); |
| run_loop_->Run(); |
| } |
| |
| protected: |
| // Called when the "Test" signal is received, in the main thread. |
| // Copy the string payload to |additional_test_signal_string_|. |
| voidOnAdditionalTestSignal(Signal* signal){ |
| MessageReader reader(signal); |
| ASSERT_TRUE(reader.PopString(&additional_test_signal_string_)); |
| run_loop_->Quit(); |
| } |
| |
| // Called when connected to the signal. |
| voidOnAdditionalConnected(const std::string& interface_name, |
| const std::string& signal_name, |
| bool success){ |
| ASSERT_TRUE(success); |
| run_loop_->Quit(); |
| } |
| |
| // Text message from "Test" signal delivered to additional handler. |
| std::string additional_test_signal_string_; |
| }; |
| |
| TEST_F(SignalMultipleHandlerTest,TestMultipleHandlers){ |
| constchar kMessage[]="hello, world"; |
| // Send the test signal from the exported object. |
| test_service_->SendTestSignal(kMessage); |
| // Receive the signal with the object proxy. |
| WaitForTestSignal(); |
| // Verify the string WAS received by the original handler. |
| ASSERT_EQ(kMessage, test_signal_string_); |
| // Verify the signal WAS ALSO received by the additional handler. |
| ASSERT_EQ(kMessage, additional_test_signal_string_); |
| } |
| |
| }// namespace dbus |
