Add support for ObjectManager and other standard D-Bus interfaces (#55)

Fixes #50

tests/integrationtests/AdaptorAndProxy_test.cpp

@@ -45,6 +45,7 @@
 using ::testing::Eq;
 using ::testing::Gt;
 using ::testing::ElementsAre;
+using ::testing::SizeIs;
 using namespace std::chrono_literals;
 
 namespace
@@ -65,6 +66,18 @@ public:
         s_connection->releaseName(INTERFACE_NAME);
     }
 
+    static void waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = 1s)
+    {
+        std::chrono::milliseconds elapsed{};
+        std::chrono::milliseconds step{5ms};
+        do {
+            std::this_thread::sleep_for(step);
+            elapsed += step;
+            if (elapsed > timeout)
+                throw std::runtime_error("Waiting timed out");
+        } while (!flag);
+    }
+
 private:
     void SetUp() override
     {
@@ -396,30 +409,117 @@ TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
 
 // Properties
 
-TEST_F(SdbusTestObject, ReadsReadPropertySuccesfully)
+TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
 {
-    ASSERT_THAT(m_proxy->state(), Eq(STRING_VALUE));
+    ASSERT_THAT(m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
+{
+    ASSERT_THROW(m_proxy->state("new_value"), sdbus::Error);
 }
 
 TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
 {
-    uint32_t x = 42;
-    ASSERT_NO_THROW(m_proxy->action(x));
-    ASSERT_THAT(m_proxy->action(), Eq(x));
+    uint32_t newActionValue = 5678;
+
+    m_proxy->action(newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
 }
 
-TEST_F(SdbusTestObject, WritesToWritePropertySuccesfully)
+// Standard D-Bus interfaces
+
+TEST_F(SdbusTestObject, PingsViaPeerInterface)
 {
-    auto x = true;
-    ASSERT_NO_THROW(m_proxy->blocking(x));
+    ASSERT_NO_THROW(m_proxy->Ping());
 }
 
-TEST_F(SdbusTestObject, CannotReadFromWriteProperty)
+TEST_F(SdbusTestObject, AnswersMachineUuidViaPeerInterface)
 {
-    ASSERT_THROW(m_proxy->blocking(), sdbus::Error);
+    ASSERT_NO_THROW(m_proxy->GetMachineId());
 }
 
-TEST_F(SdbusTestObject, AnswersXmlApiDescriptionOnIntrospection)
+TEST_F(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
 {
     ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
 }
+
+TEST_F(SdbusTestObject, GetsPropertyViaPropertiesInterface)
+{
+    ASSERT_THAT(m_proxy->Get(INTERFACE_NAME, "state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
+{
+    uint32_t newActionValue = 2345;
+
+    m_proxy->Set(INTERFACE_NAME, "action", newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+}
+
+TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+{
+    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
+
+    ASSERT_THAT(properties, SizeIs(3));
+    EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+}
+
+// TODO: Uncomment once we have support for PropertiesChanged signals
+//TEST_F(SdbusTestObject, GetsSignalOnChangedPropertiesViaPropertiesInterface)
+//{
+//    std::atomic<bool> signalReceived{false};
+//    m_proxy->m_onPropertiesChangedHandler = [&signalReceived](const std::string& interfaceName, const std::map<std::string, sdbus::Variant>& changedProperties, const std::vector<std::string>& invalidatedProperties)
+//    {
+//        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
+//        EXPECT_THAT(changedProperties, SizeIs(2));
+//        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(false));
+//        EXPECT_THAT(invalidatedProperties, SizeIs(0));
+//        signalReceived = true;
+//    };
+//
+//    m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
+//    waitUntil(signalReceived);
+//}
+
+TEST_F(SdbusTestObject, DoesNotProvideObjectManagerInterfaceByDefault)
+{
+    ASSERT_THROW(m_proxy->GetManagedObjects(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, ProvidesObjectManagerInterfaceWhenExplicitlyAdded)
+{
+    m_adaptor->addObjectManager();
+
+    ASSERT_NO_THROW(m_proxy->GetManagedObjects());
+}
+
+TEST_F(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
+{
+    m_adaptor->addObjectManager();
+
+    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(0));
+}
+
+TEST_F(SdbusTestObject, GetsManagedObjectsSuccessfully)
+{
+    m_adaptor->addObjectManager();
+    auto subObject1 = sdbus::createObject(*s_connection, "/sub/path1");
+    subObject1->registerProperty("aProperty1").onInterface("org.sdbuscpp.integrationtests.iface1").withGetter([]{return uint8_t{123};});
+    subObject1->finishRegistration();
+    auto subObject2 = sdbus::createObject(*s_connection, "/sub/path2");
+    subObject2->registerProperty("aProperty2").onInterface("org.sdbuscpp.integrationtests.iface2").withGetter([]{return "hi";});
+    subObject2->finishRegistration();
+
+    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
+    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path1").at("org.sdbuscpp.integrationtests.iface1").at("aProperty1").get<uint8_t>(), Eq(123));
+    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path2").at("org.sdbuscpp.integrationtests.iface2").at("aProperty2").get<std::string>(), Eq("hi"));
+}

tests/integrationtests/TestingAdaptor.h

@@ -177,15 +177,16 @@ protected:
         throw sdbus::createError(1, "A test error occurred");
     }
 
-    std::string state() { return STRING_VALUE; }
+    std::string state() { return m_state; }
     uint32_t action() { return m_action; }
     void action(const uint32_t& value) { m_action = value; }
     bool blocking() { return m_blocking; }
     void blocking(const bool& value) { m_blocking = value; }
 
 private:
-    uint32_t m_action;
-    bool m_blocking;
+    const std::string m_state{DEFAULT_STATE_VALUE};
+    uint32_t m_action{DEFAULT_ACTION_VALUE};
+    bool m_blocking{DEFAULT_BLOCKING_VALUE};
 
     // For dont-expect-reply method call verifications
     mutable std::atomic<bool> m_multiplyCalled{};

tests/integrationtests/TestingProxy.h

@@ -28,7 +28,11 @@
 
 #include "proxy-glue.h"
 
-class TestingProxy : public sdbus::ProxyInterfaces<::testing_proxy, sdbus::introspectable_proxy>
+class TestingProxy : public sdbus::ProxyInterfaces< ::testing_proxy
+                                                  , sdbus::Peer_proxy
+                                                  , sdbus::Introspectable_proxy
+                                                  , sdbus::Properties_proxy
+                                                  , sdbus::ObjectManager_proxy >
 {
 public:
     TestingProxy(std::string destination, std::string objectPath)
@@ -73,13 +77,36 @@ protected:
             m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
     }
 
-private:
+    // Signals of standard D-Bus interfaces
+
+    void onPropertiesChanged( const std::string& interfaceName
+                            , const std::map<std::string, sdbus::Variant>& changedProperties
+                            , const std::vector<std::string>& invalidatedProperties ) override
+    {
+        if (m_onPropertiesChangedHandler)
+            m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
+    }
+
+    void onInterfacesAdded( const sdbus::ObjectPath& /*objectPath*/
+                          , const std::map<std::string, std::map<std::string, sdbus::Variant>>& /*interfacesAndProperties*/) override
+    {
+        // Intentionally left empty
+    }
+    void onInterfacesRemoved( const sdbus::ObjectPath& /*objectPath*/
+                            , const std::vector<std::string>& /*interfaces*/) override
+    {
+        // Intentionally left empty
+    }
+
+//private:
+public:
     int m_simpleCallCounter{};
     std::map<int32_t, std::string> m_map;
     double m_variantValue;
     std::map<std::string, std::string> m_signature;
 
     std::function<void(uint32_t res, const sdbus::Error* err)> m_DoOperationClientSideAsyncReplyHandler;
+    std::function<void(const std::string& interfaceName, const std::map<std::string, sdbus::Variant>& changedProperties, const std::vector<std::string>& invalidatedProperties)> m_onPropertiesChangedHandler;
 };
 
 

tests/integrationtests/adaptor-glue.h

@@ -111,8 +111,9 @@ protected:
         object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>();
 
         object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
-        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-        object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
+        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
+        //object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
+        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
 
     }
 
@@ -294,7 +295,7 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
   </signal>
   <property name="action" type="u" access="readwrite">
-   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false"/>
+   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
   </property>
   <property name="blocking" type="b" access="readwrite">
   </property>

tests/integrationtests/defs.h

@@ -41,6 +41,10 @@ const std::string STRING_VALUE{"sdbus-c++-testing"};
 const sdbus::Signature SIGNATURE_VALUE{"a{is}"};
 const sdbus::ObjectPath OBJECT_PATH_VALUE{"/"};
 
+const std::string DEFAULT_STATE_VALUE{"default-state-value"};
+const uint32_t DEFAULT_ACTION_VALUE{999};
+const bool DEFAULT_BLOCKING_VALUE{true};
+
 constexpr const double DOUBLE_VALUE{3.24L};
 
 #endif /* SDBUS_CPP_INTEGRATIONTESTS_DEFS_H_ */

tests/integrationtests/proxy-glue.h

@@ -211,6 +211,11 @@ public:
         return object_.getProperty("state").onInterface(INTERFACE_NAME);
     }
 
+    void state(const std::string& value)
+    {
+        object_.setProperty("state").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
     uint32_t action()
     {
         return object_.getProperty("action").onInterface(INTERFACE_NAME);

tests/perftests/perftests-adaptor.h

@@ -3,8 +3,8 @@
  * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
-#ifndef __sdbuscpp__perftest_adaptor_h__adaptor__H__
-#define __sdbuscpp__perftest_adaptor_h__adaptor__H__
+#ifndef __sdbuscpp__perftests_adaptor_h__adaptor__H__
+#define __sdbuscpp__perftests_adaptor_h__adaptor__H__
 
 #include <sdbus-c++/sdbus-c++.h>
 #include <string>
@@ -16,21 +16,21 @@ namespace sdbuscpp {
 class perftests_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.perftests";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.perftests";
 
 protected:
     perftests_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("sendDataSignals").onInterface(interfaceName).implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); });
-        object_.registerMethod("concatenateTwoStrings").onInterface(interfaceName).implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); });
-        object_.registerSignal("dataSignal").onInterface(interfaceName).withParameters<std::string>();
+        object_.registerMethod("sendDataSignals").onInterface(INTERFACE_NAME).implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); });
+        object_.registerMethod("concatenateTwoStrings").onInterface(INTERFACE_NAME).implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); });
+        object_.registerSignal("dataSignal").onInterface(INTERFACE_NAME).withParameters<std::string>();
     }
 
 public:
     void dataSignal(const std::string& data)
     {
-        object_.emitSignal("dataSignal").onInterface(interfaceName).withArguments(data);
+        object_.emitSignal("dataSignal").onInterface(INTERFACE_NAME).withArguments(data);
     }
 
 private:

tests/perftests/perftests-proxy.h

@@ -3,8 +3,8 @@
  * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
-#ifndef __sdbuscpp__perftest_proxy_h__proxy__H__
-#define __sdbuscpp__perftest_proxy_h__proxy__H__
+#ifndef __sdbuscpp__perftests_proxy_h__proxy__H__
+#define __sdbuscpp__perftests_proxy_h__proxy__H__
 
 #include <sdbus-c++/sdbus-c++.h>
 #include <string>
@@ -16,13 +16,13 @@ namespace sdbuscpp {
 class perftests_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.perftests";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.perftests";
 
 protected:
     perftests_proxy(sdbus::IProxy& proxy)
         : proxy_(proxy)
     {
-        proxy_.uponSignal("dataSignal").onInterface(interfaceName).call([this](const std::string& data){ this->onDataSignal(data); });
+        proxy_.uponSignal("dataSignal").onInterface(INTERFACE_NAME).call([this](const std::string& data){ this->onDataSignal(data); });
     }
 
     virtual void onDataSignal(const std::string& data) = 0;
@@ -30,13 +30,13 @@ protected:
 public:
     void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize)
     {
-        proxy_.callMethod("sendDataSignals").onInterface(interfaceName).withArguments(numberOfSignals, signalMsgSize);
+        proxy_.callMethod("sendDataSignals").onInterface(INTERFACE_NAME).withArguments(numberOfSignals, signalMsgSize);
     }
 
     std::string concatenateTwoStrings(const std::string& string1, const std::string& string2)
     {
         std::string result;
-        proxy_.callMethod("concatenateTwoStrings").onInterface(interfaceName).withArguments(string1, string2).storeResultsTo(result);
+        proxy_.callMethod("concatenateTwoStrings").onInterface(INTERFACE_NAME).withArguments(string1, string2).storeResultsTo(result);
         return result;
     }
 

tests/stresstests/celsius-thermometer-adaptor.h

@@ -18,13 +18,13 @@ namespace celsius {
 class thermometer_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.celsius.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("getCurrentTemperature").onInterface(interfaceName).implementedAs([this](){ return this->getCurrentTemperature(); });
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getCurrentTemperature(); });
     }
 
 private:

tests/stresstests/celsius-thermometer-proxy.h

@@ -18,7 +18,7 @@ namespace celsius {
 class thermometer_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.celsius.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
     thermometer_proxy(sdbus::IProxy& proxy)
@@ -30,7 +30,7 @@ public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        proxy_.callMethod("getCurrentTemperature").onInterface(interfaceName).storeResultsTo(result);
+        proxy_.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 

tests/stresstests/concatenator-adaptor.h

@@ -17,20 +17,20 @@ namespace stresstests {
 class concatenator_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.concatenator";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.concatenator";
 
 protected:
     concatenator_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("concatenate").onInterface(interfaceName).implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); });
-        object_.registerSignal("concatenatedSignal").onInterface(interfaceName).withParameters<std::string>();
+        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); });
+        object_.registerSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withParameters<std::string>();
     }
 
 public:
     void concatenatedSignal(const std::string& concatenatedString)
     {
-        object_.emitSignal("concatenatedSignal").onInterface(interfaceName).withArguments(concatenatedString);
+        object_.emitSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withArguments(concatenatedString);
     }
 
 private:

tests/stresstests/concatenator-proxy.h

@@ -17,13 +17,13 @@ namespace stresstests {
 class concatenator_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.concatenator";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.concatenator";
 
 protected:
     concatenator_proxy(sdbus::IProxy& proxy)
         : proxy_(proxy)
     {
-        proxy_.uponSignal("concatenatedSignal").onInterface(interfaceName).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
+        proxy_.uponSignal("concatenatedSignal").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
     }
 
     virtual void onConcatenatedSignal(const std::string& concatenatedString) = 0;
@@ -33,7 +33,7 @@ protected:
 public:
     void concatenate(const std::map<std::string, sdbus::Variant>& params)
     {
-        proxy_.callMethodAsync("concatenate").onInterface(interfaceName).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
+        proxy_.callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
     }
 
 private:

tests/stresstests/fahrenheit-thermometer-adaptor.h

@@ -18,13 +18,13 @@ namespace fahrenheit {
 class thermometer_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("getCurrentTemperature").onInterface(interfaceName).implementedAs([this](){ return this->getCurrentTemperature(); });
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getCurrentTemperature(); });
     }
 
 private:
@@ -45,14 +45,14 @@ namespace thermometer {
 class factory_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
 
 protected:
     factory_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("createDelegateObject").onInterface(interfaceName).implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); });
-        object_.registerMethod("destroyDelegateObject").onInterface(interfaceName).implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply();
+        object_.registerMethod("createDelegateObject").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); });
+        object_.registerMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply();
     }
 
 private:

tests/stresstests/fahrenheit-thermometer-proxy.h

@@ -18,7 +18,7 @@ namespace fahrenheit {
 class thermometer_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
 
 protected:
     thermometer_proxy(sdbus::IProxy& proxy)
@@ -30,7 +30,7 @@ public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        proxy_.callMethod("getCurrentTemperature").onInterface(interfaceName).storeResultsTo(result);
+        proxy_.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
@@ -49,7 +49,7 @@ namespace thermometer {
 class factory_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
 
 protected:
     factory_proxy(sdbus::IProxy& proxy)
@@ -61,13 +61,13 @@ public:
     sdbus::ObjectPath createDelegateObject()
     {
         sdbus::ObjectPath result;
-        proxy_.callMethod("createDelegateObject").onInterface(interfaceName).storeResultsTo(result);
+        proxy_.callMethod("createDelegateObject").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     void destroyDelegateObject(const sdbus::ObjectPath& delegate)
     {
-        proxy_.callMethod("destroyDelegateObject").onInterface(interfaceName).withArguments(delegate).dontExpectReply();
+        proxy_.callMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withArguments(delegate).dontExpectReply();
     }
 
 private:

tests/unittests/mocks/SdBusMock.h

@@ -51,6 +51,7 @@ public:
     MOCK_METHOD3(sd_bus_request_name, int(sd_bus *bus, const char *name, uint64_t flags));
     MOCK_METHOD2(sd_bus_release_name, int(sd_bus *bus, const char *name));
     MOCK_METHOD6(sd_bus_add_object_vtable, int(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata));
+    MOCK_METHOD3(sd_bus_add_object_manager, int(sd_bus *bus, sd_bus_slot **slot, const char *path));
     MOCK_METHOD5(sd_bus_add_match, int(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata));
     MOCK_METHOD1(sd_bus_slot_unref, sd_bus_slot*(sd_bus_slot *slot));