simpleble 0.0.1

data/vendor/simpleble/simpledbus/test/src/test_message.cpp

@@ -0,0 +1,397 @@
+#include <gtest/gtest.h>
+
+#include <simpledbus/base/Connection.h>
+#include <simpledbus/base/Message.h>
+
+#include <chrono>
+
+using namespace SimpleDBus;
+
+class MessageTest : public ::testing::Test {
+  protected:
+    void SetUp() override {
+        conn = new Connection(DBUS_BUS_SESSION);
+        conn->init();
+    }
+
+    void TearDown() override {
+        conn->uninit();
+        delete conn;
+        conn = nullptr;
+    }
+
+    Connection* conn;
+};
+
+TEST_F(MessageTest, SendReceiveBooleanTrue) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveBoolean");
+
+    msg.append_argument(Holder::create_boolean(true), DBUS_TYPE_BOOLEAN_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::BOOLEAN);
+    EXPECT_EQ(h_reply.get_boolean(), true);
+}
+
+TEST_F(MessageTest, SendReceiveBooleanFalse) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveBoolean");
+
+    msg.append_argument(Holder::create_boolean(false), DBUS_TYPE_BOOLEAN_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::BOOLEAN);
+    EXPECT_EQ(h_reply.get_boolean(), false);
+}
+
+TEST_F(MessageTest, SendReceiveByte) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveByte");
+
+    uint8_t value = 0x42;
+    msg.append_argument(Holder::create_byte(value), DBUS_TYPE_BYTE_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::BYTE);
+    EXPECT_EQ(h_reply.get_byte(), value);
+}
+
+TEST_F(MessageTest, SendReceiveInt16) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveInt16");
+
+    int16_t value = 0x1234;
+    msg.append_argument(Holder::create_int16(value), DBUS_TYPE_INT16_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::INT16);
+    EXPECT_EQ(h_reply.get_int16(), value);
+}
+
+TEST_F(MessageTest, SendReceiveUint16) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveUint16");
+
+    uint16_t value = 0x1234;
+    msg.append_argument(Holder::create_uint16(value), DBUS_TYPE_UINT16_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::UINT16);
+    EXPECT_EQ(h_reply.get_uint16(), value);
+}
+
+TEST_F(MessageTest, SendReceiveInt32) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveInt32");
+
+    int32_t value = 0x12345678;
+    msg.append_argument(Holder::create_int32(value), DBUS_TYPE_INT32_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::INT32);
+    EXPECT_EQ(h_reply.get_int32(), value);
+}
+
+TEST_F(MessageTest, SendReceiveUint32) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveUint32");
+
+    uint32_t value = 0x12345678;
+    msg.append_argument(Holder::create_uint32(value), DBUS_TYPE_UINT32_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::UINT32);
+    EXPECT_EQ(h_reply.get_uint32(), value);
+}
+
+TEST_F(MessageTest, SendReceiveInt64) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveInt64");
+
+    int64_t value = 0x1234567812345678;
+    msg.append_argument(Holder::create_int64(value), DBUS_TYPE_INT64_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::INT64);
+    EXPECT_EQ(h_reply.get_int64(), value);
+}
+
+TEST_F(MessageTest, SendReceiveUint64) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveUint64");
+
+    uint64_t value = 0x1234567812345678;
+    msg.append_argument(Holder::create_uint64(value), DBUS_TYPE_UINT64_AS_STRING);
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::UINT64);
+    EXPECT_EQ(h_reply.get_uint64(), value);
+}
+
+TEST_F(MessageTest, SendReceiveArrayInt32) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveArrayInt32");
+
+    Holder h_msg = Holder::create_array();
+    h_msg.array_append(Holder::create_int32(0x12345678));
+    h_msg.array_append(Holder::create_int32(0x87654321));
+    msg.append_argument(h_msg, "ai");
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::ARRAY);
+
+    std::vector<Holder> array = h_reply.get_array();
+
+    ASSERT_EQ(array.size(), 2);
+
+    EXPECT_EQ(array[0].type(), Holder::Type::INT32);
+    EXPECT_EQ(array[0].get_int32(), 0x12345678);
+
+    EXPECT_EQ(array[1].type(), Holder::Type::INT32);
+    EXPECT_EQ(array[1].get_int32(), 0x87654321);
+}
+
+TEST_F(MessageTest, SendReceiveArrayString) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveArrayString");
+
+    Holder h_msg = Holder::create_array();
+    h_msg.array_append(Holder::create_string("Hello"));
+    h_msg.array_append(Holder::create_string("World"));
+    msg.append_argument(h_msg, "as");
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::ARRAY);
+
+    std::vector<Holder> array = h_reply.get_array();
+
+    ASSERT_EQ(array.size(), 2);
+
+    EXPECT_EQ(array[0].type(), Holder::Type::STRING);
+    EXPECT_EQ(array[0].get_string(), "Hello");
+
+    EXPECT_EQ(array[1].type(), Holder::Type::STRING);
+    EXPECT_EQ(array[1].get_string(), "World");
+}
+
+TEST_F(MessageTest, SendReceiveDictInt32) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveDictInt32");
+
+    Holder h_msg = Holder::create_dict();
+    h_msg.dict_append(Holder::INT32, static_cast<int32_t>(0x12345678), Holder::create_int32(0x87654321));
+    h_msg.dict_append(Holder::INT32, static_cast<int32_t>(0x87654321), Holder::create_string("Hello"));
+    msg.append_argument(h_msg, "a{iv}");
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::DICT);
+
+    std::map<int32_t, Holder> dict = h_reply.get_dict_int32();
+
+    ASSERT_EQ(dict.size(), 2);
+    ASSERT_EQ(dict.count(0x12345678), 1);
+    ASSERT_EQ(dict.count(0x87654321), 1);
+
+    EXPECT_EQ(dict[0x12345678].type(), Holder::Type::INT32);
+    EXPECT_EQ(dict[0x12345678].get_int32(), 0x87654321);
+
+    EXPECT_EQ(dict[0x87654321].type(), Holder::Type::STRING);
+    EXPECT_EQ(dict[0x87654321].get_string(), "Hello");
+}
+
+TEST_F(MessageTest, SendReceiveDictString) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "SendReceiveDictString");
+
+    Holder h_msg = Holder::create_dict();
+    h_msg.dict_append(Holder::STRING, "key1", Holder::create_int32(0x87654321));
+    h_msg.dict_append(Holder::STRING, "key2", Holder::create_string("Hello"));
+    msg.append_argument(h_msg, "a{sv}");
+
+    Message reply = conn->send_with_reply_and_block(msg);
+    Holder h_reply = reply.extract();
+
+    EXPECT_EQ(h_reply.type(), Holder::Type::DICT);
+
+    std::map<std::string, Holder> dict = h_reply.get_dict_string();
+
+    ASSERT_EQ(dict.size(), 2);
+    ASSERT_EQ(dict.count("key1"), 1);
+    ASSERT_EQ(dict.count("key2"), 1);
+
+    EXPECT_EQ(dict["key1"].type(), Holder::Type::INT32);
+    EXPECT_EQ(dict["key1"].get_int32(), 0x87654321);
+
+    EXPECT_EQ(dict["key2"].type(), Holder::Type::STRING);
+    EXPECT_EQ(dict["key2"].get_string(), "Hello");
+}
+
+TEST_F(MessageTest, ReceiveMethodCallSuccess) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "TriggerMethodCall");
+
+    msg.append_argument(Holder::create_string(conn->unique_name()), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("/my/custom/path"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("my.interface"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("MyMethod"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("Hello World"), DBUS_TYPE_STRING_AS_STRING);
+    conn->send_with_reply_and_block(msg);
+
+    // Wait for the method call to be received
+    bool method_called = false;
+    std::chrono::time_point<std::chrono::steady_clock> end = std::chrono::steady_clock::now() + std::chrono::seconds(1);
+    while (std::chrono::steady_clock::now() < end) {
+        conn->read_write();
+        auto method_call = conn->pop_message();
+        if (method_call.is_valid()) {
+            EXPECT_EQ(method_call.get_path(), "/my/custom/path");
+            EXPECT_EQ(method_call.get_interface(), "my.interface");
+            EXPECT_EQ(method_call.get_member(), "MyMethod");
+
+            Holder arguments = method_call.extract();
+            EXPECT_EQ(arguments.type(), Holder::Type::STRING);
+            EXPECT_EQ(arguments.get_string(), "Hello World");
+
+            Message reply = Message::create_method_return(method_call);
+            reply.append_argument(Holder::create_string("Nice to meet you"), DBUS_TYPE_STRING_AS_STRING);
+            conn->send(reply);
+            method_called = true;
+            break;
+        }
+    }
+    EXPECT_TRUE(method_called);
+}
+
+TEST_F(MessageTest, ReceiveMethodCallFailure) {
+    Message msg = Message::create_method_call("simpledbus.tester.python", "/", "simpledbus.tester.message",
+                                              "TriggerMethodCall");
+
+    msg.append_argument(Holder::create_string(conn->unique_name()), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("/my/custom/path"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("my.interface"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("MyMethod"), DBUS_TYPE_STRING_AS_STRING);
+    msg.append_argument(Holder::create_string("Hello World"), DBUS_TYPE_STRING_AS_STRING);
+    conn->send_with_reply_and_block(msg);
+
+    // Wait for the method call to be received
+    bool method_called = false;
+    std::chrono::time_point<std::chrono::steady_clock> end = std::chrono::steady_clock::now() + std::chrono::seconds(1);
+    while (std::chrono::steady_clock::now() < end) {
+        conn->read_write();
+        auto method_call = conn->pop_message();
+        if (method_call.is_valid()) {
+            EXPECT_EQ(method_call.get_path(), "/my/custom/path");
+            EXPECT_EQ(method_call.get_interface(), "my.interface");
+            EXPECT_EQ(method_call.get_member(), "MyMethod");
+
+            Holder arguments = method_call.extract();
+            EXPECT_EQ(arguments.type(), Holder::Type::STRING);
+            EXPECT_EQ(arguments.get_string(), "Hello World");
+
+            Message reply = Message::create_error(method_call, "simpledbus.error.unknown", "Unknown error");
+            conn->send(reply);
+            method_called = true;
+            break;
+        }
+    }
+    EXPECT_TRUE(method_called);
+}
+
+TEST_F(MessageTest, CopyConstructor) {
+    // Create an original message
+    Message original = Message::create_method_call("org.example.Bus", "/org/example/Path", "org.example.Interface",
+                                                   "ExampleMethod");
+    original.append_argument(Holder::create_string("Test argument"), "s");
+
+    // Test copy constructor
+    Message copy_constructed(original);
+    EXPECT_TRUE(copy_constructed.is_valid());
+    EXPECT_NE(copy_constructed.get_unique_id(), original.get_unique_id());
+    EXPECT_EQ(copy_constructed.get_path(), original.get_path());
+    EXPECT_EQ(copy_constructed.get_interface(), original.get_interface());
+    EXPECT_EQ(copy_constructed.get_member(), original.get_member());
+
+    // Verify that the original message is still valid and unchanged
+    EXPECT_TRUE(original.is_valid());
+    EXPECT_EQ(original.get_path(), "/org/example/Path");
+    EXPECT_EQ(original.get_interface(), "org.example.Interface");
+    EXPECT_EQ(original.get_member(), "ExampleMethod");
+}
+
+TEST_F(MessageTest, CopyAssignment) {
+    // Create an original message
+    Message original = Message::create_method_call("org.example.Bus", "/org/example/Path", "org.example.Interface",
+                                                   "ExampleMethod");
+    original.append_argument(Holder::create_string("Test argument"), "s");
+
+    // Test copy assignment
+    Message copy_assigned;
+    copy_assigned = original;
+    EXPECT_TRUE(copy_assigned.is_valid());
+    EXPECT_NE(copy_assigned.get_unique_id(), original.get_unique_id());
+    EXPECT_EQ(copy_assigned.get_path(), original.get_path());
+    EXPECT_EQ(copy_assigned.get_interface(), original.get_interface());
+    EXPECT_EQ(copy_assigned.get_member(), original.get_member());
+
+    // Verify that the original message is still valid and unchanged
+    EXPECT_TRUE(original.is_valid());
+    EXPECT_EQ(original.get_path(), "/org/example/Path");
+    EXPECT_EQ(original.get_interface(), "org.example.Interface");
+    EXPECT_EQ(original.get_member(), "ExampleMethod");
+}
+
+TEST_F(MessageTest, MoveConstructor) {
+    // Create an original message
+    Message original = Message::create_method_call("org.example.Bus", "/org/example/Path", "org.example.Interface",
+                                                   "ExampleMethod");
+    original.append_argument(Holder::create_string("Test argument"), "s");
+
+    // Test move constructor
+    Message move_constructed(std::move(original));
+    EXPECT_TRUE(move_constructed.is_valid());
+    EXPECT_FALSE(original.is_valid());  // Original should be invalidated
+    EXPECT_EQ(move_constructed.get_path(), "/org/example/Path");
+    EXPECT_EQ(move_constructed.get_interface(), "org.example.Interface");
+    EXPECT_EQ(move_constructed.get_member(), "ExampleMethod");
+}
+
+TEST_F(MessageTest, MoveAssignment) {
+    // Create an original message
+    Message original = Message::create_method_call("org.example.Bus", "/org/example/Path", "org.example.Interface",
+                                                   "ExampleMethod");
+    original.append_argument(Holder::create_string("Test argument"), "s");
+
+    // Test move assignment
+    Message move_assigned;
+    move_assigned = std::move(original);
+    EXPECT_TRUE(move_assigned.is_valid());
+    EXPECT_FALSE(original.is_valid());  // Original should be invalidated
+    EXPECT_EQ(move_assigned.get_path(), "/org/example/Path");
+    EXPECT_EQ(move_assigned.get_interface(), "org.example.Interface");
+    EXPECT_EQ(move_assigned.get_member(), "ExampleMethod");
+}

data/vendor/simpleble/simpledbus/test/src/test_path.cpp

@@ -0,0 +1,76 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <simpledbus/base/Path.h>
+
+using namespace SimpleDBus;
+
+TEST(Path, CountElements) {
+    EXPECT_EQ(0, Path::count_elements("/"));
+    EXPECT_EQ(1, Path::count_elements("/a"));
+    EXPECT_EQ(2, Path::count_elements("/a/b"));
+    EXPECT_EQ(3, Path::count_elements("/a/b/c"));
+}
+
+TEST(Path, FetchElements) {
+    EXPECT_EQ("/", Path::fetch_elements("/a/b/c/d", 0));
+    EXPECT_EQ("/a", Path::fetch_elements("/a/b/c/d", 1));
+    EXPECT_EQ("/a/b", Path::fetch_elements("/a/b/c/d", 2));
+    EXPECT_EQ("/a/b/c", Path::fetch_elements("/a/b/c/d", 3));
+    EXPECT_EQ("/a/b/c/d", Path::fetch_elements("/a/b/c/d", 4));
+}
+
+TEST(Path, SplitElements) {
+    EXPECT_THAT(Path::split_elements("/"), ::testing::SizeIs(0));
+    EXPECT_THAT(Path::split_elements("/a"), ::testing::ElementsAre("a"));
+    EXPECT_THAT(Path::split_elements("/a/b"), ::testing::ElementsAre("a", "b"));
+    EXPECT_THAT(Path::split_elements("/a/b/c"), ::testing::ElementsAre("a", "b", "c"));
+    EXPECT_THAT(Path::split_elements("/a/b/c/d"), ::testing::ElementsAre("a", "b", "c", "d"));
+}
+
+TEST(Path, RecognizeDescendant) {
+    EXPECT_FALSE(Path::is_descendant("/a/b", "/a/b"));
+    EXPECT_FALSE(Path::is_descendant("/a/b", "/a"));
+    EXPECT_FALSE(Path::is_descendant("/a/b", "/"));
+
+    EXPECT_TRUE(Path::is_descendant("/a/b", "/a/b/c"));
+    EXPECT_TRUE(Path::is_descendant("/a/b", "/a/b/c/d"));
+    EXPECT_TRUE(Path::is_descendant("/a/b", "/a/b/c/d/e"));
+}
+
+TEST(Path, RecognizeAscendant) {
+    EXPECT_FALSE(Path::is_ascendant("/a/b", "/a/b"));
+    EXPECT_TRUE(Path::is_ascendant("/a/b", "/a"));
+    EXPECT_TRUE(Path::is_ascendant("/a/b", "/"));
+
+    EXPECT_FALSE(Path::is_ascendant("/a/b", "/a/b/c"));
+    EXPECT_FALSE(Path::is_ascendant("/a/b", "/a/b/c/d"));
+    EXPECT_FALSE(Path::is_ascendant("/a/b", "/a/b/c/d/e"));
+}
+
+TEST(Path, RecognizeChild) {
+    EXPECT_FALSE(Path::is_child("/a/b", "/a/b"));
+    EXPECT_FALSE(Path::is_child("/a/b", "/a"));
+    EXPECT_FALSE(Path::is_child("/a/b", "/"));
+
+    EXPECT_TRUE(Path::is_child("/a/b", "/a/b/c"));
+    EXPECT_FALSE(Path::is_child("/a/b", "/a/b/c/d"));
+    EXPECT_FALSE(Path::is_child("/a/b", "/a/b/c/d/e"));
+}
+
+TEST(Path, RecognizeParent) {
+    EXPECT_FALSE(Path::is_parent("/a/b", "/a/b"));
+    EXPECT_TRUE(Path::is_parent("/a/b", "/a"));
+    EXPECT_FALSE(Path::is_parent("/a/b", "/"));
+
+    EXPECT_FALSE(Path::is_parent("/a/b", "/a/b/c"));
+    EXPECT_FALSE(Path::is_parent("/a/b", "/a/b/c/d"));
+    EXPECT_FALSE(Path::is_parent("/a/b", "/a/b/c/d/e"));
+}
+
+TEST(Path, GenerateNextChild) {
+    EXPECT_EQ("/a", Path::next_child("/", "/a/b/c/d/e"));
+    EXPECT_EQ("/a/b", Path::next_child("/a", "/a/b/c/d/e"));
+    EXPECT_EQ("/a/b/c", Path::next_child("/a/b", "/a/b/c/d/e"));
+    EXPECT_EQ("/a/b/c/d", Path::next_child("/a/b/c", "/a/b/c/d/e"));
+}

data/vendor/simpleble/simpledbus/test/src/test_proxy_children.cpp

@@ -0,0 +1,109 @@
+#include <gtest/gtest.h>
+
+#include <simpledbus/advanced/Proxy.h>
+
+using namespace SimpleDBus;
+
+TEST(ProxyChildren, AppendChild) {
+    Proxy p = Proxy(nullptr, "", "/a/b");
+
+    p.path_add("/a/b/c", Holder());
+    EXPECT_EQ(1, p.children().size());
+    EXPECT_EQ(1, p.children().count("/a/b/c"));
+    EXPECT_EQ("/a/b/c", p.children().at("/a/b/c")->path());
+}
+
+TEST(ProxyChildren, AppendRepeatedChild) {
+    Proxy p = Proxy(nullptr, "", "/a/b");
+    p.path_add("/a/b/c", Holder());
+
+    // Attempting to add a child with the same name should be a no-op
+    p.path_add("/a/b/c", Holder());
+    EXPECT_EQ(1, p.children().size());
+}
+
+TEST(ProxyChildren, AppendExtendedChild) {
+    Proxy p = Proxy(nullptr, "", "/");
+    p.path_add("/a/b/c/d", Holder());
+
+    ASSERT_EQ(1, p.children().size());
+    ASSERT_EQ(1, p.children().count("/a"));
+
+    std::shared_ptr<Proxy> p_a = std::dynamic_pointer_cast<Proxy>(p.children().at("/a"));
+    ASSERT_EQ(1, p_a->children().size());
+    ASSERT_EQ(1, p_a->children().count("/a/b"));
+
+    std::shared_ptr<Proxy> p_a_b = std::dynamic_pointer_cast<Proxy>(p_a->children().at("/a/b"));
+    ASSERT_EQ(1, p_a_b->children().size());
+    ASSERT_EQ(1, p_a_b->children().count("/a/b/c"));
+
+    std::shared_ptr<Proxy> p_a_b_c = std::dynamic_pointer_cast<Proxy>(p_a_b->children().at("/a/b/c"));
+    ASSERT_EQ(1, p_a_b_c->children().size());
+    ASSERT_EQ(1, p_a_b_c->children().count("/a/b/c/d"));
+}
+
+TEST(ProxyChildren, RemoveSelf) {
+    Proxy p = Proxy(nullptr, "", "/");
+
+    // Should notify that the proxy can be safely deleted, as nothing worth keeping is left
+    ASSERT_TRUE(p.path_remove("/", Holder::create_array()));
+
+    // Add a child path without any interfaces
+    p.path_add("/a", Holder());
+
+    // Attempt to remove the path while holding a local copy of the child, should be a no-op
+    {
+        std::shared_ptr<Proxy> p_a = std::dynamic_pointer_cast<Proxy>(p.children().at("/a"));
+        // As there is another copy of the child, the proxy should not be deleted
+        ASSERT_FALSE(p.path_remove("/", Holder::create_array()));
+        ASSERT_EQ(1, p.children().size());
+    }
+
+    // Should notify that the proxy can be safely deleted, as nothing worth keeping is left
+    ASSERT_TRUE(p.path_remove("/", Holder::create_array()));
+    ASSERT_EQ(0, p.children().size());
+}
+
+TEST(ProxyChildren, RemoveChildNoInterfaces) {
+    Proxy p = Proxy(nullptr, "", "/");
+    p.path_add("/a", Holder());
+
+    // Attempt to remove the path while holding a local copy of the child, should be a no-op
+    {
+        std::shared_ptr<Proxy> p_a = std::dynamic_pointer_cast<Proxy>(p.children().at("/a"));
+        // As there is another copy of the child, the proxy should not be deleted
+        ASSERT_FALSE(p.path_remove("/a", Holder::create_array()));
+        ASSERT_EQ(1, p.children().size());
+    }
+
+    // As only the child was removed, the main proxy should not be deleted.
+    ASSERT_FALSE(p.path_remove("/a", Holder::create_array()));
+    ASSERT_EQ(0, p.children().size());
+}
+
+TEST(ProxyChildren, RemoveChildWithInterfaces) {
+    Proxy p = Proxy(nullptr, "", "/");
+
+    Holder managed_interfaces = Holder::create_dict();
+    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.2", Holder());
+    p.path_add("/a", managed_interfaces);
+
+    Holder removed_interfaces = Holder::create_array();
+    removed_interfaces.array_append(Holder::create_string("i.2"));
+    p.path_remove("/a", removed_interfaces);
+
+    // Because /a has one interface still, it should still be in the children map.
+    ASSERT_EQ(1, p.children().size());
+    {
+        std::shared_ptr<Proxy> p_a = std::dynamic_pointer_cast<Proxy>(p.children().at("/a"));
+        ASSERT_EQ(1, p_a->interfaces_count());
+        ASSERT_EQ(1, p_a->interfaces().count("i.1"));
+    }
+
+    // Remove the second interface
+    removed_interfaces = Holder::create_array();
+    removed_interfaces.array_append(Holder::create_string("i.1"));
+    p.path_remove("/a", removed_interfaces);
+    ASSERT_EQ(0, p.children().size());
+}

data/vendor/simpleble/simpledbus/test/src/test_proxy_interfaces.cpp

@@ -0,0 +1,102 @@
+#include <gtest/gtest.h>
+
+#include <simpledbus/advanced/Proxy.h>
+#include <simpledbus/advanced/InterfaceRegistry.h>
+
+using namespace SimpleDBus;
+
+const AutoRegisterInterface<Interface> registry_i1{
+    "i.1",
+    // clang-format off
+    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::make_shared<Interface>(conn, bus_name, path, "i.1");
+    }
+    // clang-format on
+};
+
+const AutoRegisterInterface<Interface> registry_i2{
+    "i.2",
+    // clang-format off
+    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::make_shared<Interface>(conn, bus_name, path, "i.2");
+    }
+    // clang-format on
+};
+
+const AutoRegisterInterface<Interface> registry_i3{
+    "i.3",
+    // clang-format off
+    [](std::shared_ptr<Connection> conn, const std::string& bus_name, const std::string& path, const Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::make_shared<Interface>(conn, bus_name, path, "i.3");
+    }
+    // clang-format on
+};
+
+TEST(ProxyInterfaces, LoadInterfaces) {
+    Holder managed_interfaces = Holder::create_dict();
+    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
+
+    Proxy h = Proxy(nullptr, "", "/");
+    EXPECT_FALSE(h.interfaces_loaded());
+
+    // TODO: Check that all properties of the interface are correctly loaded.
+
+    h.interfaces_load(managed_interfaces);
+
+    EXPECT_TRUE(h.interfaces_loaded());
+    EXPECT_EQ(1, h.interfaces().size());
+    EXPECT_EQ(1, h.interfaces().count("i.1"));
+}
+
+TEST(ProxyInterfaces, UnloadInterfaces) {
+    Holder managed_interfaces = Holder::create_dict();
+    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.2", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());
+
+    Proxy h = Proxy(nullptr, "", "/");
+    h.interfaces_load(managed_interfaces);
+    EXPECT_EQ(3, h.interfaces_count());
+
+    Holder removed_interfaces = Holder::create_array();
+    removed_interfaces.array_append(Holder::create_string("i.3"));
+    h.interfaces_unload(removed_interfaces);
+
+    EXPECT_EQ(2, h.interfaces_count());
+    EXPECT_TRUE(h.interfaces_loaded());
+    EXPECT_FALSE(h.interfaces().at("i.3")->is_loaded());
+
+    removed_interfaces = Holder::create_array();
+    removed_interfaces.array_append(Holder::create_string("i.2"));
+    h.interfaces_unload(removed_interfaces);
+
+    EXPECT_EQ(1, h.interfaces_count());
+    EXPECT_TRUE(h.interfaces_loaded());
+    EXPECT_FALSE(h.interfaces().at("i.2")->is_loaded());
+
+    removed_interfaces = Holder::create_array();
+    removed_interfaces.array_append(Holder::create_string("i.1"));
+    h.interfaces_unload(removed_interfaces);
+
+    EXPECT_EQ(0, h.interfaces_count());
+    EXPECT_FALSE(h.interfaces_loaded());
+    EXPECT_FALSE(h.interfaces().at("i.1")->is_loaded());
+}
+
+TEST(ProxyInterfaces, ReloadInterfaces) {
+    Holder managed_interfaces = Holder::create_dict();
+    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.2", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());
+
+    Proxy h = Proxy(nullptr, "", "/");
+    h.interfaces_load(managed_interfaces);
+    EXPECT_EQ(3, h.interfaces_count());
+
+    managed_interfaces = Holder::create_dict();
+    managed_interfaces.dict_append(Holder::STRING, "i.1", Holder());
+    managed_interfaces.dict_append(Holder::STRING, "i.3", Holder());
+    h.interfaces_reload(managed_interfaces);
+
+    EXPECT_EQ(2, h.interfaces_count());
+}