refactor: add strong types to public API (#414)

This introduces strong types for `std::string`-based D-Bus types. This facilitates safer, less error-prone and more expressive API.

What previously was `auto proxy = createProxy("org.sdbuscpp.concatenator", "/org/sdbuscpp/concatenator");` is now written like `auto proxy = createProxy(ServiceName{"org.sdbuscpp.concatenator"}, ObjectPath{"/org/sdbuscpp/concatenator"});`.

These types are:
  * `ObjectPath` type for the object path (the type has been around already but now is also used consistently in sdbus-c++ API for object path strings),
  * `InterfaceName` type for D-Bus interface names,
  * `BusName` (and its aliases `ServiceName` and `ConnectionName`) type for bus/service/connection names,
  * `MemberName` (and its aliases `MethodName`, `SignalName` and `PropertyName`) type for D-Bus method, signal and property names,
  * `Signature` type for the D-Bus signature (the type has been around already but now is also used consistently in sdbus-c++ API for signature strings),
  * `Error::Name` type for D-Bus error names.

tests/integrationtests/DBusAsyncMethodsTests.cpp

@@ -96,7 +96,7 @@ TYPED_TEST(AsyncSdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously
     std::atomic<int> startedCount{};
     auto call = [&](uint32_t param)
     {
-        TestProxy proxy{BUS_NAME, OBJECT_PATH};
+        TestProxy proxy{SERVICE_NAME, OBJECT_PATH};
         ++startedCount;
         while (!invoke) ;
         auto result = proxy.doOperationAsync(param);
@@ -119,7 +119,7 @@ TYPED_TEST(AsyncSdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncM
     std::atomic<int> startedCount{};
     auto call = [&]()
     {
-        TestProxy proxy{BUS_NAME, OBJECT_PATH};
+        TestProxy proxy{SERVICE_NAME, OBJECT_PATH};
         ++startedCount;
         while (!invoke) ;
 

tests/integrationtests/DBusConnectionTests.cpp

@@ -51,38 +51,43 @@ TEST(Connection, CanBeDefaultConstructed)
     ASSERT_NO_THROW(auto con = sdbus::createBusConnection());
 }
 
-TEST(SystemBusConnection, CanRequestRegisteredDbusName)
+TEST(Connection, CanRequestName)
 {
-    auto connection = sdbus::createSystemBusConnection();
+    auto connection = sdbus::createBusConnection();
 
-    ASSERT_NO_THROW(connection->requestName(BUS_NAME))
+    // In case of system bus connection, requesting may throw as we need to allow that first through a config file in /etc/dbus-1/system.d
+    ASSERT_NO_THROW(connection->requestName(SERVICE_NAME))
         << "Perhaps you've forgotten to copy `org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory before running the tests?";
 }
 
 TEST(SystemBusConnection, CannotRequestNonregisteredDbusName)
 {
     auto connection = sdbus::createSystemBusConnection();
-    ASSERT_THROW(connection->requestName("some.random.not.supported.dbus.name"), sdbus::Error);
+    sdbus::ServiceName notSupportedBusName{"some.random.not.supported.dbus.name"};
+
+    ASSERT_THROW(connection->requestName(notSupportedBusName), sdbus::Error);
 }
 
-TEST(Connection, CanReleasedRequestedName)
+TEST(Connection, CanReleaseRequestedName)
 {
     auto connection = sdbus::createBusConnection();
+    connection->requestName(SERVICE_NAME);
 
-    connection->requestName(BUS_NAME);
-    ASSERT_NO_THROW(connection->releaseName(BUS_NAME));
+    ASSERT_NO_THROW(connection->releaseName(SERVICE_NAME));
 }
 
 TEST(Connection, CannotReleaseNonrequestedName)
 {
     auto connection = sdbus::createBusConnection();
-    ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
+    sdbus::ServiceName notAcquiredBusName{"some.random.unacquired.name"};
+
+    ASSERT_THROW(connection->releaseName(notAcquiredBusName), sdbus::Error);
 }
 
 TEST(Connection, CanEnterAndLeaveInternalEventLoop)
 {
     auto connection = sdbus::createBusConnection();
-    connection->requestName(BUS_NAME);
+    connection->requestName(SERVICE_NAME);
 
     std::thread t([&](){ connection->enterEventLoop(); });
     connection->leaveEventLoop();

tests/integrationtests/DBusGeneralTests.cpp

@@ -54,12 +54,12 @@ using ADirectConnection = TestFixtureWithDirectConnection;
 TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
 {
     auto connection = sdbus::createBusConnection();
-    connection->requestName(BUS_NAME);
+    connection->requestName(SERVICE_NAME);
 
     ASSERT_NO_THROW(TestAdaptor adaptor(*connection, OBJECT_PATH));
-    ASSERT_NO_THROW(TestProxy proxy(BUS_NAME, OBJECT_PATH));
+    ASSERT_NO_THROW(TestProxy proxy(SERVICE_NAME, OBJECT_PATH));
 
-    connection->releaseName(BUS_NAME);
+    connection->releaseName(SERVICE_NAME);
 }
 
 TEST(AProxy, SupportsMoveSemantics)
@@ -76,7 +76,7 @@ TEST(AnAdaptor, SupportsMoveSemantics)
 
 TYPED_TEST(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
 {
-    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
     auto slot = this->s_proxyConnection->addMatch(matchRule, [&](sdbus::Message msg)
     {
@@ -91,7 +91,7 @@ TYPED_TEST(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRu
 
 TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 {
-    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
     std::atomic<bool> matchRuleInstalled{false};
     auto slot = this->s_proxyConnection->addMatchAsync( matchRule
@@ -114,7 +114,7 @@ TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 
 TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
 {
-    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
     auto slot = this->s_proxyConnection->addMatch(matchRule, [&](sdbus::Message msg)
     {
@@ -130,7 +130,7 @@ TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedS
 
 TYPED_TEST(AConnection, CanAddFloatingMatchRule)
 {
-    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    auto matchRule = "sender='" + SERVICE_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
     auto con = sdbus::createBusConnection();
     con->enterEventLoopAsync();

tests/integrationtests/DBusMethodsTests.cpp

@@ -231,13 +231,13 @@ TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
 
 TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
 {
-    TestProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
+    TestProxy proxy(sdbus::ServiceName{"sdbuscpp.destination.that.does.not.exist"}, OBJECT_PATH);
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
 TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
 {
-    TestProxy proxy(BUS_NAME, "/sdbuscpp/path/that/does/not/exist");
+    TestProxy proxy(SERVICE_NAME, sdbus::ObjectPath{"/sdbuscpp/path/that/does/not/exist"});
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
@@ -254,7 +254,7 @@ TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHand
     this->m_proxy->doOperation(10); // This will save pointer to method call message on server side
 
     ASSERT_THAT(this->m_adaptor->m_methodCallMsg, NotNull());
-    ASSERT_THAT(this->m_adaptor->m_methodCallMemberName, Eq("doOperation"));
+    ASSERT_THAT(this->m_adaptor->m_methodName, Eq("doOperation"));
 }
 
 TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCallHandler)
@@ -262,7 +262,7 @@ TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCal
     this->m_proxy->doOperationAsync(10); // This will save pointer to method call message on server side
 
     ASSERT_THAT(this->m_adaptor->m_methodCallMsg, NotNull());
-    ASSERT_THAT(this->m_adaptor->m_methodCallMemberName, Eq("doOperationAsync"));
+    ASSERT_THAT(this->m_adaptor->m_methodName, Eq("doOperationAsync"));
 }
 
 #if LIBSYSTEMD_VERSION>=240
@@ -281,7 +281,7 @@ TYPED_TEST(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLe
 
 TYPED_TEST(SdbusTestObject, CanCallMethodSynchronouslyWithoutAnEventLoopThread)
 {
-    auto proxy = std::make_unique<TestProxy>(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+    auto proxy = std::make_unique<TestProxy>(SERVICE_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
 
     auto multiplyRes = proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
 
@@ -291,15 +291,16 @@ TYPED_TEST(SdbusTestObject, CanCallMethodSynchronouslyWithoutAnEventLoopThread)
 TYPED_TEST(SdbusTestObject, CanRegisterAdditionalVTableDynamicallyAtAnyTime)
 {
     auto& object = this->m_adaptor->getObject();
-    auto vtableSlot = object.addVTable( "org.sdbuscpp.integrationtests2"
+    sdbus::InterfaceName interfaceName{"org.sdbuscpp.integrationtests2"};
+    auto vtableSlot = object.addVTable( interfaceName
                                       , { sdbus::registerMethod("add").implementedAs([](const int64_t& a, const double& b){ return a + b; })
                                         , sdbus::registerMethod("subtract").implementedAs([](const int& a, const int& b){ return a - b; }) }
                                       , sdbus::return_slot );
 
     // The new remote vtable is registered as long as we keep vtableSlot, so remote method calls now should pass
-    auto proxy = sdbus::createProxy(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+    auto proxy = sdbus::createProxy(SERVICE_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
     int result{};
-    proxy->callMethod("subtract").onInterface("org.sdbuscpp.integrationtests2").withArguments(10, 2).storeResultsTo(result);
+    proxy->callMethod("subtract").onInterface(interfaceName).withArguments(10, 2).storeResultsTo(result);
 
     ASSERT_THAT(result, Eq(8));
 }
@@ -307,14 +308,15 @@ TYPED_TEST(SdbusTestObject, CanRegisterAdditionalVTableDynamicallyAtAnyTime)
 TYPED_TEST(SdbusTestObject, CanUnregisterAdditionallyRegisteredVTableAtAnyTime)
 {
     auto& object = this->m_adaptor->getObject();
+    sdbus::InterfaceName interfaceName{"org.sdbuscpp.integrationtests2"};
 
-    auto vtableSlot = object.addVTable( "org.sdbuscpp.integrationtests2"
+    auto vtableSlot = object.addVTable( interfaceName
                                       , { sdbus::registerMethod("add").implementedAs([](const int64_t& a, const double& b){ return a + b; })
                                         , sdbus::registerMethod("subtract").implementedAs([](const int& a, const int& b){ return a - b; }) }
                                       , sdbus::return_slot );
     vtableSlot.reset(); // Letting the slot go means letting go the associated vtable registration
 
     // No such remote D-Bus method under given interface exists anymore...
-    auto proxy = sdbus::createProxy(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
-    ASSERT_THROW(proxy->callMethod("subtract").onInterface("org.sdbuscpp.integrationtests2").withArguments(10, 2), sdbus::Error);
+    auto proxy = sdbus::createProxy(SERVICE_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+    ASSERT_THROW(proxy->callMethod("subtract").onInterface(interfaceName).withArguments(10, 2), sdbus::Error);
 }

tests/integrationtests/DBusSignalsTests.cpp

@@ -57,8 +57,8 @@ TYPED_TEST(SdbusTestObject, EmitsSimpleSignalSuccesfully)
 
 TYPED_TEST(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
 {
-    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
-    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, SERVICE_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, SERVICE_NAME, OBJECT_PATH);
 
     this->m_adaptor->emitSimpleSignal();
 
@@ -69,7 +69,7 @@ TYPED_TEST(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
 
 TYPED_TEST(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
 {
-    auto otherBusName = BUS_NAME + "2";
+    sdbus::ServiceName otherBusName{SERVICE_NAME + "2"};
     auto connection2 = sdbus::createBusConnection(otherBusName);
     auto adaptor2 = std::make_unique<TestAdaptor>(*connection2, OBJECT_PATH);
 
@@ -110,10 +110,10 @@ TYPED_TEST(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
 
 TYPED_TEST(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
 {
-    this->m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
+    this->m_adaptor->emitSignalWithoutRegistration({"platform", sdbus::Signature{"av"}});
 
     ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithSignature));
-    ASSERT_THAT(this->m_proxy->m_signatureFromSignal["platform"], Eq("av"));
+    ASSERT_THAT(this->m_proxy->m_signatureFromSignal["platform"], Eq(sdbus::Signature{"av"}));
 }
 
 TYPED_TEST(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
@@ -123,7 +123,7 @@ TYPED_TEST(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
     waitUntil(this->m_proxy->m_gotSimpleSignal);
 
     ASSERT_THAT(this->m_proxy->m_signalMsg, NotNull());
-    ASSERT_THAT(this->m_proxy->m_signalMemberName, Eq("simpleSignal"));
+    ASSERT_THAT(this->m_proxy->m_signalName, Eq(std::string("simpleSignal")));
 }
 
 TYPED_TEST(SdbusTestObject, UnregistersSignalHandler)
@@ -137,8 +137,8 @@ TYPED_TEST(SdbusTestObject, UnregistersSignalHandler)
 
 TYPED_TEST(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
 {
-    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
-    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, SERVICE_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, SERVICE_NAME, OBJECT_PATH);
 
     ASSERT_NO_THROW(this->m_proxy->unregisterSimpleSignalHandler());
 

tests/integrationtests/DBusStandardInterfacesTests.cpp

@@ -142,17 +142,17 @@ TYPED_TEST(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
     const auto properties = this->m_proxy->GetAll(INTERFACE_NAME);
 
     ASSERT_THAT(properties, SizeIs(3));
-    EXPECT_THAT(properties.at("state").template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-    EXPECT_THAT(properties.at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
-    EXPECT_THAT(properties.at("blocking").template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+    EXPECT_THAT(properties.at(STATE_PROPERTY).template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at(ACTION_PROPERTY).template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at(BLOCKING_PROPERTY).template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
 }
 
 TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterface)
 {
-    std::promise<std::map<std::string, sdbus::Variant>> promise;
+    std::promise<std::map<sdbus::PropertyName, sdbus::Variant>> promise;
     auto future = promise.get_future();
 
-    this->m_proxy->GetAllAsync(INTERFACE_NAME, [&](std::optional<sdbus::Error> err, std::map<std::string, sdbus::Variant> value)
+    this->m_proxy->GetAllAsync(INTERFACE_NAME, [&](std::optional<sdbus::Error> err, std::map<sdbus::PropertyName, sdbus::Variant> value)
     {
         if (!err)
             promise.set_value(std::move(value));
@@ -162,9 +162,9 @@ TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfac
     const auto properties = future.get();
 
     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));
+    EXPECT_THAT(properties.at(STATE_PROPERTY).get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at(ACTION_PROPERTY).get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at(BLOCKING_PROPERTY).get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
 }
 
 TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfaceWithFuture)
@@ -174,27 +174,27 @@ TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfac
     auto properties = future.get();
 
     ASSERT_THAT(properties, SizeIs(3));
-    EXPECT_THAT(properties.at("state").template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-    EXPECT_THAT(properties.at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
-    EXPECT_THAT(properties.at("blocking").template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+    EXPECT_THAT(properties.at(STATE_PROPERTY).template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at(ACTION_PROPERTY).template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at(BLOCKING_PROPERTY).template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
 }
 
 TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
 {
     std::atomic<bool> signalReceived{false};
-    this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
-                                                                   , const std::map<std::string, sdbus::Variant>& changedProperties
-                                                                   , const std::vector<std::string>& /*invalidatedProperties*/ )
+    this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const sdbus::InterfaceName& interfaceName
+                                                                   , const std::map<sdbus::PropertyName, sdbus::Variant>& changedProperties
+                                                                   , const std::vector<sdbus::PropertyName>& /*invalidatedProperties*/ )
     {
         EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
         EXPECT_THAT(changedProperties, SizeIs(1));
-        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(!DEFAULT_BLOCKING_VALUE));
+        EXPECT_THAT(changedProperties.at(BLOCKING_PROPERTY).get<bool>(), Eq(!DEFAULT_BLOCKING_VALUE));
         signalReceived = true;
     };
 
     this->m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
     this->m_proxy->action(DEFAULT_ACTION_VALUE*2);
-    this->m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
+    this->m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {BLOCKING_PROPERTY});
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
@@ -202,13 +202,13 @@ TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
 TYPED_TEST(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
 {
     std::atomic<bool> signalReceived{false};
-    this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
-                                                                   , const std::map<std::string, sdbus::Variant>& changedProperties
-                                                                   , const std::vector<std::string>& invalidatedProperties )
+    this->m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const sdbus::InterfaceName& interfaceName
+                                                                   , const std::map<sdbus::PropertyName, sdbus::Variant>& changedProperties
+                                                                   , const std::vector<sdbus::PropertyName>& invalidatedProperties )
     {
         EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
         EXPECT_THAT(changedProperties, SizeIs(1));
-        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+        EXPECT_THAT(changedProperties.at(BLOCKING_PROPERTY).get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
         ASSERT_THAT(invalidatedProperties, SizeIs(1));
         EXPECT_THAT(invalidatedProperties[0], Eq("action"));
         signalReceived = true;
@@ -235,17 +235,17 @@ TYPED_TEST(SdbusTestObject, GetsManagedObjectsSuccessfully)
     ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
     EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH)
         .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
-        .at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+        .at(ACTION_PROPERTY).template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
     EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH_2)
         .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
-        .at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+        .at(ACTION_PROPERTY).template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
 }
 
 TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                              , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+                                                                              , const std::map<sdbus::InterfaceName, std::map<sdbus::PropertyName, sdbus::Variant>>& interfacesAndProperties )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
         EXPECT_THAT(interfacesAndProperties, SizeIs(1));
@@ -253,16 +253,16 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterface
 #if LIBSYSTEMD_VERSION<=244
         // Up to sd-bus v244, all properties are added to the list, i.e. `state', `action', and `blocking' in this case.
         EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("action"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(STATE_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(ACTION_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(BLOCKING_PROPERTY));
 #else
         // Since v245 sd-bus does not add to the InterfacesAdded signal message the values of properties marked only
         // for invalidation on change, which makes the behavior consistent with the PropertiesChangedSignal.
         // So in this specific instance, `action' property is no more added to the list.
         EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(2));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(STATE_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(BLOCKING_PROPERTY));
 #endif
         signalReceived = true;
     };
@@ -276,7 +276,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                              , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+                                                                              , const std::map<sdbus::InterfaceName, std::map<sdbus::PropertyName, sdbus::Variant>>& interfacesAndProperties )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
 #if LIBSYSTEMD_VERSION<=250
@@ -289,16 +289,16 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
 #if LIBSYSTEMD_VERSION<=244
         // Up to sd-bus v244, all properties are added to the list, i.e. `state', `action', and `blocking' in this case.
         EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("action"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(STATE_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(ACTION_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(BLOCKING_PROPERTY));
 #else
         // Since v245 sd-bus does not add to the InterfacesAdded signal message the values of properties marked only
         // for invalidation on change, which makes the behavior consistent with the PropertiesChangedSignal.
         // So in this specific instance, `action' property is no more added to the list.
         EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(2));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
-        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(STATE_PROPERTY));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count(BLOCKING_PROPERTY));
 #endif
         signalReceived = true;
     };
@@ -312,7 +312,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfa
 {
     std::atomic<bool> signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                                , const std::vector<std::string>& interfaces )
+                                                                                , const std::vector<sdbus::InterfaceName>& interfaces )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
         ASSERT_THAT(interfaces, SizeIs(1));
@@ -329,7 +329,7 @@ TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
     this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                                , const std::vector<std::string>& interfaces )
+                                                                                , const std::vector<sdbus::InterfaceName>& interfaces )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
 #if LIBSYSTEMD_VERSION<=250

tests/integrationtests/Defs.h

@@ -34,12 +34,15 @@
 
 namespace sdbus { namespace test {
 
-const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
-const std::string BUS_NAME = INTERFACE_NAME;
-const std::string EMPTY_DESTINATION;
-const std::string MANAGER_PATH {"/org/sdbuscpp/integrationtests"};
-const std::string OBJECT_PATH  {"/org/sdbuscpp/integrationtests/ObjectA1"};
-const std::string OBJECT_PATH_2{"/org/sdbuscpp/integrationtests/ObjectB1"};
+const InterfaceName INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
+const ServiceName SERVICE_NAME{"org.sdbuscpp.integrationtests"};
+const ServiceName EMPTY_DESTINATION;
+const ObjectPath MANAGER_PATH {"/org/sdbuscpp/integrationtests"};
+const ObjectPath OBJECT_PATH  {"/org/sdbuscpp/integrationtests/ObjectA1"};
+const ObjectPath OBJECT_PATH_2{"/org/sdbuscpp/integrationtests/ObjectB1"};
+const PropertyName STATE_PROPERTY{"state"};
+const PropertyName ACTION_PROPERTY{"action"};
+const PropertyName BLOCKING_PROPERTY{"blocking"};
 const std::string DIRECT_CONNECTION_SOCKET_PATH{std::filesystem::temp_directory_path() / "sdbus-cpp-direct-connection-test"};
 
 constexpr const uint8_t UINT8_VALUE{1};
@@ -49,8 +52,8 @@ constexpr const int32_t INT32_VALUE{-42};
 constexpr const int32_t INT64_VALUE{-1024};
 
 const std::string STRING_VALUE{"sdbus-c++-testing"};
-const sdbus::Signature SIGNATURE_VALUE{"a{is}"};
-const sdbus::ObjectPath OBJECT_PATH_VALUE{"/"};
+const Signature SIGNATURE_VALUE{"a{is}"};
+const ObjectPath OBJECT_PATH_VALUE{"/"};
 const int UNIX_FD_VALUE = 0;
 
 const std::string DEFAULT_STATE_VALUE{"default-state-value"};

tests/integrationtests/TestAdaptor.cpp

@@ -31,8 +31,8 @@
 
 namespace sdbus { namespace test {
 
-TestAdaptor::TestAdaptor(sdbus::IConnection& connection, const std::string& path) :
-    AdaptorInterfaces(connection, path)
+TestAdaptor::TestAdaptor(sdbus::IConnection& connection, sdbus::ObjectPath path) :
+    AdaptorInterfaces(connection, std::move(path))
 {
     registerAdaptor();
 }
@@ -123,7 +123,7 @@ uint32_t TestAdaptor::doOperation(const uint32_t& param)
     std::this_thread::sleep_for(std::chrono::milliseconds(param));
 
     m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
-    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+    m_methodName = m_methodCallMsg->getMemberName();
 
     return param;
 }
@@ -131,7 +131,7 @@ uint32_t TestAdaptor::doOperation(const uint32_t& param)
 void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t param)
 {
     m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
-    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+    m_methodName = m_methodCallMsg->getMemberName();
 
     if (param == 0)
     {
@@ -173,7 +173,7 @@ std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::
                         23,  // uint8_t
                         {   // vector
                             {   // struct
-                                    "/object/path", // object path
+                                    sdbus::ObjectPath{"/object/path"}, // object path
                                     false,
                                     Variant{3.14},
                                     {   // map
@@ -183,7 +183,7 @@ std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::
                         }
                     }
                 },
-                "a{t(a{ya(obva{is})}gs)}", // signature
+                sdbus::Signature{"a{t(a{ya(obva{is})}gs)}"}, // signature
                 std::string{}
             }
         }

tests/integrationtests/TestAdaptor.h

@@ -40,7 +40,7 @@ namespace sdbus { namespace test {
 class ObjectManagerTestAdaptor final : public sdbus::AdaptorInterfaces< sdbus::ObjectManager_adaptor >
 {
 public:
-    ObjectManagerTestAdaptor(sdbus::IConnection& connection, std::string path) :
+    ObjectManagerTestAdaptor(sdbus::IConnection& connection, sdbus::ObjectPath path) :
         AdaptorInterfaces(connection, std::move(path))
     {
         registerAdaptor();
@@ -57,7 +57,7 @@ class TestAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::integr
                                                          , sdbus::ManagedObject_adaptor >
 {
 public:
-    TestAdaptor(sdbus::IConnection& connection, const std::string& path);
+    TestAdaptor(sdbus::IConnection& connection, sdbus::ObjectPath path);
     ~TestAdaptor();
 
 protected:
@@ -105,7 +105,7 @@ public: // for tests
     mutable std::atomic<bool> m_wasThrowErrorCalled{false};
 
     std::unique_ptr<const Message> m_methodCallMsg;
-    std::string m_methodCallMemberName;
+    MethodName m_methodName;
     std::unique_ptr<const Message> m_propertySetMsg;
     std::string m_propertySetSender;
 };
@@ -115,7 +115,9 @@ class DummyTestAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::i
                                                               , sdbus::ManagedObject_adaptor >
 {
 public:
-    DummyTestAdaptor(sdbus::IConnection& connection, const std::string& path) : AdaptorInterfaces(connection, path) {}
+    DummyTestAdaptor(sdbus::IConnection& connection, sdbus::ObjectPath path)
+        : AdaptorInterfaces(connection, std::move(path))
+    {}
 
 protected:
     void noArgNoReturn() override {}

tests/integrationtests/TestFixture.h

@@ -55,19 +55,19 @@ class BaseTestFixture : public ::testing::Test
 public:
     static void SetUpTestCase()
     {
-        s_adaptorConnection->requestName(BUS_NAME);
+        s_adaptorConnection->requestName(SERVICE_NAME);
     }
 
     static void TearDownTestCase()
     {
-        s_adaptorConnection->releaseName(BUS_NAME);
+        s_adaptorConnection->releaseName(SERVICE_NAME);
     }
 
 private:
     void SetUp() override
     {
-        m_objectManagerProxy = std::make_unique<ObjectManagerTestProxy>(*s_proxyConnection, BUS_NAME, MANAGER_PATH);
-        m_proxy = std::make_unique<TestProxy>(*s_proxyConnection, BUS_NAME, OBJECT_PATH);
+        m_objectManagerProxy = std::make_unique<ObjectManagerTestProxy>(*s_proxyConnection, SERVICE_NAME, MANAGER_PATH);
+        m_proxy = std::make_unique<TestProxy>(*s_proxyConnection, SERVICE_NAME, OBJECT_PATH);
 
         m_objectManagerAdaptor = std::make_unique<ObjectManagerTestAdaptor>(*s_adaptorConnection, MANAGER_PATH);
         m_adaptor = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH);

tests/integrationtests/TestProxy.cpp

@@ -31,7 +31,7 @@
 
 namespace sdbus { namespace test {
 
-TestProxy::TestProxy(std::string destination, std::string objectPath)
+TestProxy::TestProxy(ServiceName destination, ObjectPath objectPath)
     : ProxyInterfaces(std::move(destination), std::move(objectPath))
 {
     getProxy().uponSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s){ this->onSignalWithoutRegistration(s); });
@@ -39,14 +39,14 @@ TestProxy::TestProxy(std::string destination, std::string objectPath)
     registerProxy();
 }
 
-TestProxy::TestProxy(std::string destination, std::string objectPath, dont_run_event_loop_thread_t)
+TestProxy::TestProxy(ServiceName destination, ObjectPath objectPath, dont_run_event_loop_thread_t)
     : ProxyInterfaces(std::move(destination), std::move(objectPath), dont_run_event_loop_thread)
 {
     // It doesn't make sense to register any signals here since proxy upon a D-Bus connection with no event loop thread
     // will not receive any incoming messages except replies to synchronous D-Bus calls.
 }
 
-TestProxy::TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+TestProxy::TestProxy(sdbus::IConnection& connection, ServiceName destination, ObjectPath objectPath)
     : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
 {
     getProxy().uponSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s){ this->onSignalWithoutRegistration(s); });
@@ -62,7 +62,7 @@ TestProxy::~TestProxy()
 void TestProxy::onSimpleSignal()
 {
     m_signalMsg = std::make_unique<sdbus::Message>(getProxy().getCurrentlyProcessedMessage());
-    m_signalMemberName = m_signalMsg->getMemberName();
+    m_signalName = m_signalMsg->getMemberName();
 
     m_gotSimpleSignal = true;
 }
@@ -81,6 +81,7 @@ void TestProxy::onSignalWithVariant(const sdbus::Variant& aVariant)
 
 void TestProxy::onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
 {
+    // Static cast to std::string is a workaround for gcc 11.4 false positive warning (which later gcc versions nor Clang emit)
     m_signatureFromSignal[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
     m_gotSignalWithSignature = true;
 }
@@ -91,9 +92,9 @@ void TestProxy::onDoOperationReply(uint32_t returnValue, std::optional<sdbus::Er
         m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
 }
 
-void TestProxy::onPropertiesChanged( const std::string& interfaceName
-                                   , const std::map<std::string, sdbus::Variant>& changedProperties
-                                   , const std::vector<std::string>& invalidatedProperties )
+void TestProxy::onPropertiesChanged( const sdbus::InterfaceName& interfaceName
+                                   , const std::map<PropertyName, sdbus::Variant>& changedProperties
+                                   , const std::vector<PropertyName>& invalidatedProperties )
 {
     if (m_onPropertiesChangedHandler)
         m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
@@ -133,7 +134,7 @@ std::future<uint32_t> TestProxy::doOperationClientSideAsync(uint32_t param, with
 
 std::future<MethodReply> TestProxy::doOperationClientSideAsyncOnBasicAPILevel(uint32_t param)
 {
-    auto methodCall = getProxy().createMethodCall(sdbus::test::INTERFACE_NAME, "doOperation");
+    auto methodCall = getProxy().createMethodCall(sdbus::test::INTERFACE_NAME, sdbus::MethodName{"doOperation"});
     methodCall << param;
 
     return getProxy().callMethodAsync(methodCall, sdbus::with_future);
@@ -178,8 +179,9 @@ int32_t TestProxy::callNonexistentMethod()
 
 int32_t TestProxy::callMethodOnNonexistentInterface()
 {
+    sdbus::InterfaceName nonexistentInterfaceName{"sdbuscpp.interface.that.does.not.exist"};
     int32_t result;
-    getProxy().callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
+    getProxy().callMethod("someMethod").onInterface(nonexistentInterfaceName).storeResultsTo(result);
     return result;
 }
 

tests/integrationtests/TestProxy.h

@@ -40,7 +40,7 @@ namespace sdbus { namespace test {
 class ObjectManagerTestProxy final : public sdbus::ProxyInterfaces< sdbus::ObjectManager_proxy >
 {
 public:
-    ObjectManagerTestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+    ObjectManagerTestProxy(sdbus::IConnection& connection, ServiceName destination, ObjectPath objectPath)
         : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
     {
         registerProxy();
@@ -51,21 +51,21 @@ public:
         unregisterProxy();
     }
 protected:
-    void onInterfacesAdded(const sdbus::ObjectPath& objectPath, const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override
+    void onInterfacesAdded(const sdbus::ObjectPath& objectPath, const std::map<sdbus::InterfaceName, std::map<PropertyName, sdbus::Variant>>& interfacesAndProperties) override
     {
         if (m_onInterfacesAddedHandler)
             m_onInterfacesAddedHandler(objectPath, interfacesAndProperties);
     }
 
-    void onInterfacesRemoved(const sdbus::ObjectPath& objectPath, const std::vector<std::string>& interfaces) override
+    void onInterfacesRemoved(const sdbus::ObjectPath& objectPath, const std::vector<sdbus::InterfaceName>& interfaces) override
     {
         if (m_onInterfacesRemovedHandler)
             m_onInterfacesRemovedHandler(objectPath, interfaces);
     }
 
 public: // for tests
-    std::function<void(const sdbus::ObjectPath&, const std::map<std::string, std::map<std::string, sdbus::Variant>>&)> m_onInterfacesAddedHandler;
-    std::function<void(const sdbus::ObjectPath&, const std::vector<std::string>&)> m_onInterfacesRemovedHandler;
+    std::function<void(const sdbus::ObjectPath&, const std::map<sdbus::InterfaceName, std::map<PropertyName, sdbus::Variant>>&)> m_onInterfacesAddedHandler;
+    std::function<void(const sdbus::ObjectPath&, const std::vector<sdbus::InterfaceName>&)> m_onInterfacesRemovedHandler;
 };
 
 class TestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integrationtests_proxy
@@ -74,9 +74,9 @@ class TestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integratio
                                                      , sdbus::Properties_proxy >
 {
 public:
-    TestProxy(std::string destination, std::string objectPath);
-    TestProxy(std::string destination, std::string objectPath, dont_run_event_loop_thread_t);
-    TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath);
+    TestProxy(ServiceName destination, ObjectPath objectPath);
+    TestProxy(ServiceName destination, ObjectPath objectPath, dont_run_event_loop_thread_t);
+    TestProxy(sdbus::IConnection& connection, ServiceName destination, ObjectPath objectPath);
     ~TestProxy();
 
 protected:
@@ -88,9 +88,9 @@ protected:
     void onDoOperationReply(uint32_t returnValue, std::optional<sdbus::Error> error);
 
     // 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;
+    void onPropertiesChanged( const sdbus::InterfaceName& interfaceName
+                            , const std::map<PropertyName, sdbus::Variant>& changedProperties
+                            , const std::vector<PropertyName>& invalidatedProperties ) override;
 
 public:
     void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, std::optional<sdbus::Error> err)> handler);
@@ -114,13 +114,13 @@ public: // for tests
     std::atomic<bool> m_gotSignalWithVariant{false};
     double m_variantFromSignal;
     std::atomic<bool> m_gotSignalWithSignature{false};
-    std::map<std::string, std::string> m_signatureFromSignal;
+    std::map<std::string, Signature> m_signatureFromSignal;
 
     std::function<void(uint32_t res, std::optional<sdbus::Error> err)> m_DoOperationClientSideAsyncReplyHandler;
-    std::function<void(const std::string&, const std::map<std::string, sdbus::Variant>&, const std::vector<std::string>&)> m_onPropertiesChangedHandler;
+    std::function<void(const sdbus::InterfaceName&, const std::map<PropertyName, sdbus::Variant>&, const std::vector<PropertyName>&)> m_onPropertiesChangedHandler;
 
     std::unique_ptr<const Message> m_signalMsg;
-    std::string m_signalMemberName;
+    SignalName m_signalName;
 };
 
 class DummyTestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integrationtests_proxy
@@ -129,7 +129,7 @@ class DummyTestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integ
                                                           , sdbus::Properties_proxy >
 {
 public:
-    DummyTestProxy(std::string destination, std::string objectPath)
+    DummyTestProxy(ServiceName destination, ObjectPath objectPath)
         : ProxyInterfaces(destination, objectPath)
     {
     }
@@ -143,7 +143,7 @@ protected:
     void onDoOperationReply(uint32_t, std::optional<sdbus::Error>) {}
 
     // Signals of standard D-Bus interfaces
-    void onPropertiesChanged( const std::string&, const std::map<std::string, sdbus::Variant>&, const std::vector<std::string>& ) override {}
+    void onPropertiesChanged(const InterfaceName&, const std::map<PropertyName, sdbus::Variant>&, const std::vector<PropertyName>&) override {}
 };
 
 }}

tests/integrationtests/integrationtests-adaptor.h

@@ -16,7 +16,7 @@ namespace sdbuscpp {
 class integrationtests_adaptor
 {
 public:
-    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+    static inline const sdbus::InterfaceName INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 
 protected:
     integrationtests_adaptor(sdbus::IObject& object)

tests/integrationtests/integrationtests-proxy.h

@@ -16,7 +16,7 @@ namespace sdbuscpp {
 class integrationtests_proxy
 {
 public:
-    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+    static inline const sdbus::InterfaceName INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 
 protected:
     integrationtests_proxy(sdbus::IProxy& proxy)