// Copyright (c) 2012 The Chromium 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 "dbus/property.h" #include #include #include #include #include #include "base/bind.h" #include "base/memory/raw_ptr.h" #include "base/message_loop/message_pump_type.h" #include "base/run_loop.h" #include "base/strings/string_number_conversions.h" #include "base/test/task_environment.h" #include "base/threading/thread.h" #include "base/threading/thread_restrictions.h" #include "dbus/bus.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 { // The property test exerises the asynchronous APIs in PropertySet and // Property<>. class PropertyTest : public testing::Test { public: PropertyTest() = default; struct Properties : public PropertySet { Property name; Property version; Property> methods; Property> objects; Property> bytes; Properties(ObjectProxy* object_proxy, PropertyChangedCallback property_changed_callback) : PropertySet(object_proxy, "org.chromium.TestInterface", property_changed_callback) { RegisterProperty("Name", &name); RegisterProperty("Version", &version); RegisterProperty("Methods", &methods); RegisterProperty("Objects", &objects); RegisterProperty("Bytes", &bytes); } }; void SetUp() override { // Make the main thread not to allow IO. disallow_blocking_.emplace(); // Start the D-Bus thread. dbus_thread_ = std::make_unique("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(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_ = new Bus(bus_options); object_proxy_ = bus_->GetObjectProxy( test_service_->service_name(), ObjectPath("/org/chromium/TestObject")); ASSERT_TRUE(bus_->HasDBusThread()); // Create the properties structure properties_ = std::make_unique( object_proxy_, base::BindRepeating(&PropertyTest::OnPropertyChanged, base::Unretained(this))); properties_->ConnectSignals(); properties_->GetAll(); } void TearDown() 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(); } // Generic callback, bind with a string |id| for passing to // WaitForCallback() to ensure the callback for the right method is // waited for. void PropertyCallback(const std::string& id, bool success) { last_callback_ = id; run_loop_->Quit(); } // Generic method callback, that might be used together with // WaitForMethodCallback to test wether method was succesfully called. void MethodCallback(Response* response) { run_loop_->Quit(); } protected: // Called when a property value is updated. void OnPropertyChanged(const std::string& name) { updated_properties_.push_back(name); run_loop_->Quit(); } // Waits for the given number of updates. void WaitForUpdates(size_t num_updates) { while (updated_properties_.size() < num_updates) { run_loop_ = std::make_unique(); run_loop_->Run(); } for (size_t i = 0; i < num_updates; ++i) updated_properties_.erase(updated_properties_.begin()); } // Name, Version, Methods, Objects static const int kExpectedSignalUpdates = 5; // Waits for initial values to be set. void WaitForGetAll() { WaitForUpdates(kExpectedSignalUpdates); } // Waits until MethodCallback is called. void WaitForMethodCallback() { run_loop_ = std::make_unique(); run_loop_->Run(); } // Waits for the callback. |id| is the string bound to the callback when // the method call is made that identifies it and distinguishes from any // other; you can set this to whatever you wish. void WaitForCallback(const std::string& id) { while (last_callback_ != id) { run_loop_ = std::make_unique(); run_loop_->Run(); } } base::test::SingleThreadTaskEnvironment task_environment_; absl::optional disallow_blocking_; std::unique_ptr run_loop_; std::unique_ptr dbus_thread_; scoped_refptr bus_; raw_ptr object_proxy_; std::unique_ptr properties_; std::unique_ptr test_service_; // Properties updated. std::vector updated_properties_; // Last callback received. std::string last_callback_; }; TEST_F(PropertyTest, InitialValues) { EXPECT_FALSE(properties_->name.is_valid()); EXPECT_FALSE(properties_->version.is_valid()); WaitForGetAll(); EXPECT_TRUE(properties_->name.is_valid()); EXPECT_EQ("TestService", properties_->name.value()); EXPECT_TRUE(properties_->version.is_valid()); EXPECT_EQ(10, properties_->version.value()); std::vector methods = properties_->methods.value(); ASSERT_EQ(4U, methods.size()); EXPECT_EQ("Echo", methods[0]); EXPECT_EQ("SlowEcho", methods[1]); EXPECT_EQ("AsyncEcho", methods[2]); EXPECT_EQ("BrokenMethod", methods[3]); std::vector objects = properties_->objects.value(); ASSERT_EQ(1U, objects.size()); EXPECT_EQ(ObjectPath("/TestObjectPath"), objects[0]); std::vector bytes = properties_->bytes.value(); ASSERT_EQ(4U, bytes.size()); EXPECT_EQ('T', bytes[0]); EXPECT_EQ('e', bytes[1]); EXPECT_EQ('s', bytes[2]); EXPECT_EQ('t', bytes[3]); } TEST_F(PropertyTest, UpdatedValues) { WaitForGetAll(); // Update the value of the "Name" property, this value should not change. properties_->name.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Name")); WaitForCallback("Name"); WaitForUpdates(1); EXPECT_EQ("TestService", properties_->name.value()); // Update the value of the "Version" property, this value should be changed. properties_->version.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Version")); WaitForCallback("Version"); WaitForUpdates(1); EXPECT_EQ(20, properties_->version.value()); // Update the value of the "Methods" property, this value should not change // and should not grow to contain duplicate entries. properties_->methods.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Methods")); WaitForCallback("Methods"); WaitForUpdates(1); std::vector methods = properties_->methods.value(); ASSERT_EQ(4U, methods.size()); EXPECT_EQ("Echo", methods[0]); EXPECT_EQ("SlowEcho", methods[1]); EXPECT_EQ("AsyncEcho", methods[2]); EXPECT_EQ("BrokenMethod", methods[3]); // Update the value of the "Objects" property, this value should not change // and should not grow to contain duplicate entries. properties_->objects.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Objects")); WaitForCallback("Objects"); WaitForUpdates(1); std::vector objects = properties_->objects.value(); ASSERT_EQ(1U, objects.size()); EXPECT_EQ(ObjectPath("/TestObjectPath"), objects[0]); // Update the value of the "Bytes" property, this value should not change // and should not grow to contain duplicate entries. properties_->bytes.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Bytes")); WaitForCallback("Bytes"); WaitForUpdates(1); std::vector bytes = properties_->bytes.value(); ASSERT_EQ(4U, bytes.size()); EXPECT_EQ('T', bytes[0]); EXPECT_EQ('e', bytes[1]); EXPECT_EQ('s', bytes[2]); EXPECT_EQ('t', bytes[3]); } TEST_F(PropertyTest, Get) { WaitForGetAll(); // Ask for the new Version property. properties_->version.Get(base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Get")); WaitForCallback("Get"); // Make sure we got a property update too. WaitForUpdates(1); EXPECT_EQ(20, properties_->version.value()); } TEST_F(PropertyTest, Set) { WaitForGetAll(); // Set a new name. properties_->name.Set("NewService", base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Set")); WaitForCallback("Set"); // TestService sends a property update. WaitForUpdates(1); EXPECT_EQ("NewService", properties_->name.value()); } TEST_F(PropertyTest, Invalidate) { WaitForGetAll(); EXPECT_TRUE(properties_->name.is_valid()); // Invalidate name. MethodCall method_call("org.chromium.TestInterface", "PerformAction"); MessageWriter writer(&method_call); writer.AppendString("InvalidateProperty"); writer.AppendObjectPath(ObjectPath("/org/chromium/TestService")); object_proxy_->CallMethod( &method_call, ObjectProxy::TIMEOUT_USE_DEFAULT, base::BindOnce(&PropertyTest::MethodCallback, base::Unretained(this))); WaitForMethodCallback(); // TestService sends a property update. WaitForUpdates(1); EXPECT_FALSE(properties_->name.is_valid()); // Set name to something valid. properties_->name.Set("NewService", base::BindOnce(&PropertyTest::PropertyCallback, base::Unretained(this), "Set")); WaitForCallback("Set"); // TestService sends a property update. WaitForUpdates(1); EXPECT_TRUE(properties_->name.is_valid()); } TEST(PropertyTestStatic, ReadWriteStringMap) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter variant_array_writer(nullptr); MessageWriter struct_entry_writer(nullptr); writer.OpenVariant("a{ss}", &variant_writer); variant_writer.OpenArray("{ss}", &variant_array_writer); const char* items[] = {"One", "Two", "Three", "Four"}; for (unsigned i = 0; i < std::size(items); ++i) { variant_array_writer.OpenDictEntry(&struct_entry_writer); struct_entry_writer.AppendString(items[i]); struct_entry_writer.AppendString(base::NumberToString(i + 1)); variant_array_writer.CloseContainer(&struct_entry_writer); } variant_writer.CloseContainer(&variant_array_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property> string_map; EXPECT_TRUE(string_map.PopValueFromReader(&reader)); ASSERT_EQ(4U, string_map.value().size()); EXPECT_EQ("1", string_map.value().at("One")); EXPECT_EQ("2", string_map.value().at("Two")); EXPECT_EQ("3", string_map.value().at("Three")); EXPECT_EQ("4", string_map.value().at("Four")); } TEST(PropertyTestStatic, SerializeStringMap) { std::map test_map; test_map["Hi"] = "There"; test_map["Map"] = "Test"; test_map["Random"] = "Text"; std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); Property> string_map; string_map.ReplaceSetValueForTesting(test_map); string_map.AppendSetValueToWriter(&writer); MessageReader reader(message.get()); EXPECT_TRUE(string_map.PopValueFromReader(&reader)); EXPECT_EQ(test_map, string_map.value()); } TEST(PropertyTestStatic, ReadWriteNetAddressArray) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter variant_array_writer(nullptr); MessageWriter struct_entry_writer(nullptr); writer.OpenVariant("a(ayq)", &variant_writer); variant_writer.OpenArray("(ayq)", &variant_array_writer); uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30}; for (uint16_t i = 0; i < 5; ++i) { variant_array_writer.OpenStruct(&struct_entry_writer); ip_bytes[4] = 0x30 + i; struct_entry_writer.AppendArrayOfBytes(ip_bytes, std::size(ip_bytes)); struct_entry_writer.AppendUint16(i); variant_array_writer.CloseContainer(&struct_entry_writer); } variant_writer.CloseContainer(&variant_array_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property, uint16_t>>> ip_list; EXPECT_TRUE(ip_list.PopValueFromReader(&reader)); ASSERT_EQ(5U, ip_list.value().size()); size_t item_index = 0; for (auto& item : ip_list.value()) { ASSERT_EQ(5U, item.first.size()); ip_bytes[4] = 0x30 + item_index; EXPECT_EQ(0, memcmp(ip_bytes, item.first.data(), 5U)); EXPECT_EQ(item_index, item.second); ++item_index; } } TEST(PropertyTestStatic, SerializeNetAddressArray) { std::vector, uint16_t>> test_list; uint8_t ip_bytes[] = {0x54, 0x65, 0x73, 0x74, 0x30}; for (uint16_t i = 0; i < 5; ++i) { ip_bytes[4] = 0x30 + i; std::vector bytes(ip_bytes, ip_bytes + std::size(ip_bytes)); test_list.push_back(make_pair(bytes, 16)); } std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); Property, uint16_t>>> ip_list; ip_list.ReplaceSetValueForTesting(test_list); ip_list.AppendSetValueToWriter(&writer); MessageReader reader(message.get()); EXPECT_TRUE(ip_list.PopValueFromReader(&reader)); EXPECT_EQ(test_list, ip_list.value()); } TEST(PropertyTestStatic, ReadWriteStringToByteVectorMapVariantWrapped) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter dict_writer(nullptr); writer.OpenVariant("a{sv}", &variant_writer); variant_writer.OpenArray("{sv}", &dict_writer); const char* keys[] = {"One", "Two", "Three", "Four"}; const std::vector values[] = {{1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}}; for (unsigned i = 0; i < std::size(keys); ++i) { MessageWriter entry_writer(nullptr); dict_writer.OpenDictEntry(&entry_writer); entry_writer.AppendString(keys[i]); MessageWriter value_varient_writer(nullptr); entry_writer.OpenVariant("ay", &value_varient_writer); value_varient_writer.AppendArrayOfBytes(values[i].data(), values[i].size()); entry_writer.CloseContainer(&value_varient_writer); dict_writer.CloseContainer(&entry_writer); } variant_writer.CloseContainer(&dict_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property>> test_property; EXPECT_TRUE(test_property.PopValueFromReader(&reader)); ASSERT_EQ(std::size(keys), test_property.value().size()); for (unsigned i = 0; i < std::size(keys); ++i) EXPECT_EQ(values[i], test_property.value().at(keys[i])); } TEST(PropertyTestStatic, ReadWriteStringToByteVectorMap) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter dict_writer(nullptr); writer.OpenVariant("a{say}", &variant_writer); variant_writer.OpenArray("{say}", &dict_writer); const char* keys[] = {"One", "Two", "Three", "Four"}; const std::vector values[] = {{1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}}; for (unsigned i = 0; i < std::size(keys); ++i) { MessageWriter entry_writer(nullptr); dict_writer.OpenDictEntry(&entry_writer); entry_writer.AppendString(keys[i]); entry_writer.AppendArrayOfBytes(values[i].data(), values[i].size()); dict_writer.CloseContainer(&entry_writer); } variant_writer.CloseContainer(&dict_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property>> test_property; EXPECT_TRUE(test_property.PopValueFromReader(&reader)); ASSERT_EQ(std::size(keys), test_property.value().size()); for (unsigned i = 0; i < std::size(keys); ++i) EXPECT_EQ(values[i], test_property.value().at(keys[i])); } TEST(PropertyTestStatic, SerializeStringToByteVectorMap) { std::map> test_map; test_map["Hi"] = {1, 2, 3}; test_map["Map"] = {0xab, 0xcd}; test_map["Random"] = {0x0}; std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); Property>> test_property; test_property.ReplaceSetValueForTesting(test_map); test_property.AppendSetValueToWriter(&writer); MessageReader reader(message.get()); EXPECT_TRUE(test_property.PopValueFromReader(&reader)); EXPECT_EQ(test_map, test_property.value()); } TEST(PropertyTestStatic, ReadWriteUInt16ToByteVectorMapVariantWrapped) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter dict_writer(nullptr); writer.OpenVariant("a{qv}", &variant_writer); variant_writer.OpenArray("{qv}", &dict_writer); const uint16_t keys[] = {11, 12, 13, 14}; const std::vector values[] = {{1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}}; for (unsigned i = 0; i < std::size(keys); ++i) { MessageWriter entry_writer(nullptr); dict_writer.OpenDictEntry(&entry_writer); entry_writer.AppendUint16(keys[i]); MessageWriter value_varient_writer(nullptr); entry_writer.OpenVariant("ay", &value_varient_writer); value_varient_writer.AppendArrayOfBytes(values[i].data(), values[i].size()); entry_writer.CloseContainer(&value_varient_writer); dict_writer.CloseContainer(&entry_writer); } variant_writer.CloseContainer(&dict_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property>> test_property; EXPECT_TRUE(test_property.PopValueFromReader(&reader)); ASSERT_EQ(std::size(keys), test_property.value().size()); for (unsigned i = 0; i < std::size(keys); ++i) EXPECT_EQ(values[i], test_property.value().at(keys[i])); } TEST(PropertyTestStatic, ReadWriteUInt16ToByteVectorMap) { std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); MessageWriter variant_writer(nullptr); MessageWriter dict_writer(nullptr); writer.OpenVariant("a{qay}", &variant_writer); variant_writer.OpenArray("{qay}", &dict_writer); const uint16_t keys[] = {11, 12, 13, 14}; const std::vector values[] = {{1}, {1, 2}, {1, 2, 3}, {1, 2, 3, 4}}; for (unsigned i = 0; i < std::size(keys); ++i) { MessageWriter entry_writer(nullptr); dict_writer.OpenDictEntry(&entry_writer); entry_writer.AppendUint16(keys[i]); entry_writer.AppendArrayOfBytes(values[i].data(), values[i].size()); dict_writer.CloseContainer(&entry_writer); } variant_writer.CloseContainer(&dict_writer); writer.CloseContainer(&variant_writer); MessageReader reader(message.get()); Property>> test_property; EXPECT_TRUE(test_property.PopValueFromReader(&reader)); ASSERT_EQ(std::size(keys), test_property.value().size()); for (unsigned i = 0; i < std::size(keys); ++i) EXPECT_EQ(values[i], test_property.value().at(keys[i])); } TEST(PropertyTestStatic, SerializeUInt16ToByteVectorMap) { std::map> test_map; test_map[11] = {1, 2, 3}; test_map[12] = {0xab, 0xcd}; test_map[13] = {0x0}; std::unique_ptr message(Response::CreateEmpty()); MessageWriter writer(message.get()); Property>> test_property; test_property.ReplaceSetValueForTesting(test_map); test_property.AppendSetValueToWriter(&writer); MessageReader reader(message.get()); EXPECT_TRUE(test_property.PopValueFromReader(&reader)); EXPECT_EQ(test_map, test_property.value()); } } // namespace dbus