Bump up revision to 0.5.2

CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.8)
 
-project(sdbus-c++ VERSION 0.5.0 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.5.2 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
@@ -57,7 +57,6 @@ set(SDBUSCPP_PUBLIC_HDRS
     ${SDBUSCPP_INCLUDE_DIR}/IObjectProxy.h
     ${SDBUSCPP_INCLUDE_DIR}/Message.h
     ${SDBUSCPP_INCLUDE_DIR}/MethodResult.h
-    ${SDBUSCPP_INCLUDE_DIR}/MethodResult.inl
     ${SDBUSCPP_INCLUDE_DIR}/Types.h
     ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h
     ${SDBUSCPP_INCLUDE_DIR}/Flags.h
@@ -80,21 +79,22 @@ include_directories("${CMAKE_SOURCE_DIR}/src")
 set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(SDBUSCPP_VERSION "${PROJECT_VERSION}")
 
-# We are building in two steps: first objects, then link them into a library,
-# and that's because we need object files since unit tests link against them.
-add_library(sdbuscppobjects OBJECT ${SDBUSCPP_SRCS})
-target_include_directories(sdbuscppobjects PUBLIC ${SYSTEMD_INCLUDE_DIRS})
-target_compile_definitions(sdbuscppobjects PRIVATE BUILDLIB=1)
-set_target_properties(sdbuscppobjects PROPERTIES POSITION_INDEPENDENT_CODE ON)
+option(BUILD_SHARED_LIBS "Build shared libraries (.so) instead of static ones (.a)" ON)
 
-add_library(sdbus-c++ SHARED $<TARGET_OBJECTS:sdbuscppobjects>)
+add_library(sdbus-cpp OBJECT ${SDBUSCPP_SRCS})
+target_include_directories(sdbus-cpp PUBLIC ${SYSTEMD_INCLUDE_DIRS})
+target_compile_definitions(sdbus-cpp PRIVATE BUILDLIB=1)
+if(BUILD_SHARED_LIBS)
+    set_target_properties(sdbus-cpp PROPERTIES POSITION_INDEPENDENT_CODE ON)
+endif()
+
+add_library(sdbus-c++ $<TARGET_OBJECTS:sdbus-cpp>)
 set_target_properties(sdbus-c++
     PROPERTIES
     PUBLIC_HEADER "${SDBUSCPP_PUBLIC_HDRS}"
     VERSION "${SDBUSCPP_VERSION}"
     SOVERSION "${SDBUSCPP_VERSION_MAJOR}"
     OUTPUT_NAME "sdbus-c++")
-
 target_link_libraries(sdbus-c++ ${SYSTEMD_LIBRARIES})
 
 #----------------------------------
@@ -111,9 +111,9 @@ install(TARGETS sdbus-c++
 # TESTS
 #----------------------------------
 
-option(ENABLE_TESTS "Build and install tests (default ON)" ON)
+option(BUILD_TESTS "Build and install tests (default OFF)" OFF)
 
-if(ENABLE_TESTS)
+if(BUILD_TESTS)
     enable_testing()
     add_subdirectory("${CMAKE_SOURCE_DIR}/test")
 endif()
@@ -132,7 +132,11 @@ endif()
 # DOCUMENTATION
 #----------------------------------
 
-# TODO Build doxygen
+option(BUILD_DOC "Build doxygen documentation for sdbus-c++ API" ON)
+
+if(BUILD_DOC)
+    add_subdirectory("${CMAKE_SOURCE_DIR}/doc")
+endif()
 
 #----------------------------------
 # CMAKE CONFIG & PACKAGE CONFIG

ChangeLog

@@ -54,7 +54,17 @@ v0.4.3
 
 v0.5.0
 - Redesign of the Connection model for scalability, thread-safety, simplicity and clarity
-- Introduce support asynchronous invocation of D-Bus methods on client-side
+- [[Breaking ABI change]] Introduce support asynchronous invocation of D-Bus methods on client-side
 - Revise and extend sdbus-c++ tutorial
 - Introduce stress tests that involve a D-Bus server and client interacting in dense communication in both sync and async ways
 - Compilation error fixes for older gcc versions
+
+v0.5.1
+- Cleanups of CMakeLists.txt
+- Rename sdbus-c++ test executables for consistency
+- Rename sdbus-c++ stub code generator executable
+- Introduce generation of doxygen documentation
+- Improve documentation
+
+v0.5.2
+- Simplify and unify basic API level callbacks for both sync and async methods

README.md

@@ -16,9 +16,31 @@ $ make
 $ sudo make install
 ```
 
-By default, the library builds its unit and integration tests. That incorporates downloading and building static libraries of Google Test. Use `-DENABLE_TESTS=OFF` configure flag if you want to disable building the tests.
+### CMake configuration flags
 
-By default, the library doesn't build the code generator for adaptor and proxy interfaces. Use `-DBUILD_CODE_GEN=ON` flag to also build the code generator.
+* `BUILD_CODE_GEN` [boolean]
+
+  Option for building the stub code generator `sdbus-c++-xml2cpp` for generating the adaptor and proxy interfaces out of the D-Bus IDL XML description. Default value: `OFF`. Use `-DBUILD_CODE_GEN=ON` flag to turn on building the code gen.
+
+* `BUILD_DOC` [boolean]
+
+  Option for building Doxygen documentation of sdbus-c++ API. If `BUILD_DOC` is enabled, the documentation must still be built explicitly through `make doc`. Default value: `ON`. Use `-DBUILD_DOC=OFF` to disable searching for Doxygen and building Doxygen documentation of sdbus-c++ API.
+
+* `BUILD_TESTS` [boolean]
+
+  Option for building sdbus-c++ unit and integration tests, invokable by `make test`. That incorporates downloading and building static libraries of Google Test. Default value: `OFF`. Use `-DBUILD_TESTS=ON` to enable building the tests. With this option turned on, you may also enable/disable the following options:
+
+    * `BUILD_PERF_TESTS` [boolean]
+
+      Option for building sdbus-c++ performance tests. Default value: `OFF`.
+
+    * `BUILD_STRESS_TESTS` [boolean]
+
+      Option for building sdbus-c++ stress tests. Default value: `OFF`.
+
+    * `TESTS_INSTALL_PATH` [string]
+
+      Path where the test binaries shall get installed. Default value: `/opt/test/bin`.
 
 Dependencies
 ------------

doc/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Building doxygen documentation
+
+find_package(Doxygen)
+
+if(DOXYGEN_FOUND)
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+
+    add_custom_target(doc
+        COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        COMMENT "Generating API documentation with Doxygen"
+        VERBATIM)
+
+    install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR})
+else()
+    message(WARNING "Documentation enabled, but Doxygen cannot be found")
+endif()

doc/using-sdbus-c++.md

@@ -150,7 +150,7 @@ This is how a simple Concatenator service implemented upon the basic sdbus-c++ A
 // to emit signals.
 sdbus::IObject* g_concatenator{};
 
-void concatenate(sdbus::MethodCall& call, sdbus::MethodReply& reply)
+void concatenate(sdbus::MethodCall call)
 {
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
@@ -170,8 +170,10 @@ void concatenate(sdbus::MethodCall& call, sdbus::MethodReply& reply)
         result += (result.empty() ? std::string() : separator) + std::to_string(number);
     }
     
-    // Serialize resulting string to the reply
+    // Serialize resulting string to the reply and send the reply to the caller
+    auto reply = call.createReply();
     reply << result;
+    reply.send();
     
     // Emit 'concatenated' signal
     const char* interfaceName = "org.sdbuscpp.Concatenator";
@@ -205,7 +207,7 @@ int main(int argc, char *argv[])
 
 We establish a D-Bus sytem connection and request `org.sdbuscpp.concatenator` D-Bus name on it. This name will be used by D-Bus clients to find the service. We then create an object with path `/org/sdbuscpp/concatenator` on this connection. We register  interfaces, its methods, signals that the object provides, and, through `finishRegistration()`, export the object (i.e., make it visible to clients) on the bus. Then we need to make sure to run the event loop upon the connection, which handles all incoming, outgoing and other requests.
 
-The callback for any D-Bus object method on this level is any callable of signature `void(sdbus::MethodCall& call, sdbus::MethodReply& reply)`. The first parameter `call` is the incoming method call message. We need to deserialize input arguments from it. When we can invoke the logic and get the results. Then we serialize the results to the second parameter, the pre-constructed `reply` message. The reply is then sent automatically by sdbus-c++. We also fire a signal with the results. To do this, we need to create a signal message via object's `createSignal()`, serialize the results into it, and then send it out to subscribers by invoking object's `emitSignal()`.
+The callback for any D-Bus object method on this level is any callable of signature `void(sdbus::MethodCall call)`. The `call` parameter is the incoming method call message. We need to deserialize our method input arguments from it. Then we can invoke the logic of the method and get the results. Then for the given `call`, we create a `reply` message, pack results into it and send it back to the caller through `send()`. (If we had a void-returning method, we'd just send an empty `reply` back.) We also fire a signal with the results. To do this, we need to create a signal message via object's `createSignal()`, serialize the results into it, and then send it out to subscribers by invoking object's `emitSignal()`.
 
 Please note that we can create and destroy D-Bus objects on a connection dynamically, at any time during runtime, even while there is an active event loop upon the connection. So managing D-Bus objects' lifecycle (creating, exporting and destroying D-Bus objects) is completely thread-safe.
 
@@ -444,12 +446,12 @@ sdbus-c++ users shall prefer the convenience API to the lower level, basic API.
 Implementing the Concatenator example using sdbus-c++-generated stubs
 ---------------------------------------------------------------------
 
-sdbus-c++ ships with the native stub generator tool called sdbuscpp-xml2cpp. The tool is very similar to dbusxx-xml2cpp tool that comes from dbus-c++ project.
+sdbus-c++ ships with the native stub generator tool called `sdbus-c++-xml2cpp`. The tool is very similar to `dbusxx-xml2cpp` tool that comes from dbus-c++ project.
 
 The generator tool takes D-Bus XML IDL description of D-Bus interfaces on its input, and can be instructed to generate one or both of these: an adaptor header file for use at server side, and a proxy header file for use at client side. Like this:
 
 ```bash
-sdbuscpp-xml2cpp database-bindings.xml --adaptor=database-server-glue.h --proxy=database-client-glue.h
+sdbus-c++-xml2cpp database-bindings.xml --adaptor=database-server-glue.h --proxy=database-client-glue.h
 ```
 
 The adaptor header file contains classes that can be used to implement described interfaces. The proxy header file contains classes that can be used to make calls to remote objects.
@@ -483,7 +485,7 @@ There is specific class for each interface in the XML IDL file. The class is de
 
 ```cpp
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__concatenator_server_glue_h__adaptor__H__
@@ -533,7 +535,7 @@ Analogously to the adaptor classes described above, there is specific class for
 
 ```cpp
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__concatenator_client_glue_h__proxy__H__
@@ -709,12 +711,12 @@ Asynchronous server-side methods
 
 So far in our tutorial, we have only considered simple server methods that are executed in a synchronous way. Sometimes the method call may take longer, however, and we don't want to block (potentially starve) other clients (whose requests may take relative short time). The solution is to execute the D-Bus methods asynchronously, and return the control quickly back to the D-Bus dispatching thread. sdbus-c++ provides API supporting async methods, and gives users the freedom to come up with their own concrete implementation mechanics (one worker thread? thread pool? ...).
 
-### Lower-level API
+### Using basic sdbus-c++ API
 
-Considering the Concatenator example based on lower-level API, if we wanted to write `concatenate` method in an asynchronous way, you only have to adapt method signature and its body (registering the method and all the other stuff stays the same):
+This is how the concatenate method would look like if wrote it as an asynchronous D-Bus method using the basic, lower-level API of sdbus-c++:
 
 ```c++
-void concatenate(sdbus::MethodCall& call, sdbus::MethodResult result)
+void concatenate(sdbus::MethodCall call)
 {
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
@@ -725,62 +727,84 @@ void concatenate(sdbus::MethodCall& call, sdbus::MethodResult result)
     call >> separator;
     
     // Launch a thread for async execution...
-    std::thread([numbers, separator, result = std::move(result)]()
+    std::thread([numbers = std::move(numbers), separator = std::move(separator), call = std::move(call)]()
     {
         // Return error if there are no numbers in the collection
         if (numbers.empty())
         {
-            // This will send the error reply message back to the client
-            result.returnError("org.sdbuscpp.Concatenator.Error", "No numbers provided");
+            // Let's send the error reply message back to the client
+            auto reply = call.createErrorReply({"org.sdbuscpp.Concatenator.Error", "No numbers provided"});
+            reply.send();
             return;
         }
         
-        std::string concatenatedStr;
+        std::string result;
         for (auto number : numbers)
         {
-            concatenatedStr += (result.empty() ? std::string() : separator) + std::to_string(number);
+            result += (result.empty() ? std::string() : separator) + std::to_string(number);
         }
         
-        // This will send the reply message back to the client
-        result.returnResults(concatenatedStr);
+        // Let's send the reply message back to the client
+        auto reply = call.createReply();
+        reply << result;
+        reply.send();
         
-        // Note: emitting signals from other than D-Bus dispatcher thread is not supported yet...
-        /*
-        // Emit 'concatenated' signal
+        // Emit 'concatenated' signal (creating and emitting signals is thread-safe)
         const char* interfaceName = "org.sdbuscpp.Concatenator";
         auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
         signal << result;
         g_concatenator->emitSignal(signal);
-        */
     }).detach();
 }
 ```
 
-Notice these differences as compared to the synchronous version:
+There are a few slight differences compared to the synchronous version. Notice that we `std::move` the `call` message to the worker thread (btw we might also do input arguments deserialization in the worker thread, we don't have to do it in the current thread and then move input arguments to the worker thread...). We need the `call` message there to create the reply message once we have the (normal or error) result. Creating and sending replies, as well as creating and emitting signals is thread-safe by design. Also notice that, unlike in sync methods, sending back errors cannot be done by throwing `Error`, since we are now in the context of the worker thread, not that of the D-Bus dispatcher thread. Instead, we pass the `Error` object to the `createErrorReply()` method of the call message (this way of sending back errors, in addition to throwing, we can actually use also in classic synchronous D-Bus methods).
 
-  * Instead of `MethodReply` message given by reference, there is `MethodResult` as a second parameter of the callback, which will hold method results and can be written to from any thread.
-
-  * You shall pass the result holder (`MethodResult` instance) by moving it to the thread of execution, and eventually write method results (or method error) to it via its `returnResults()` or `returnError()` method, respectively.
-
-  * Unlike in sync methods, reporting errors cannot be done by throwing sdbus::Error, since the execution takes place out of context of the D-Bus dispatcher thread. Instead, just pass the error name and message to the `returnError` method of the result holder.
-
-That's all.
+Method callback signature is the same in sync and async version. That means sdbus-c++ doesn't care how we execute our D-Bus method. We might very well in run-time decide whether we execute it synchronously, or whether (perhaps in case of longer, more complex calculations) we move the execution to a worker thread.
 
 ### Convenience API
 
-Method callbacks in convenience sdbus-c++ API also need to take the result object as a parameter. The requirements are:
+Callbacks of async methods based on convenience sdbus-c++ API have slightly different signature. They take a result object parameter in addition to other input parameters. The requirements are:
 
-  * The result holder is of type `sdbus::Result<Types...>`, where `Types...` is a list of method output argument types.
-  * The result object must be a first physical parameter of the callback taken by value.
+  * The result holder is of type `Result<Types...>&&`, where `Types...` is a list of method output argument types.
+  * The result object must be the first physical parameter of the callback taken by r-value ref. `Result` class template is move-only.
   * The callback itself is physically a void-returning function.
+  * Method input arguments are taken by value rathern than by const ref, because we usually want to `std::move` them to the worker thread. Moving is usually a lot cheaper than copying, and it's idiomatic. For non-movable types, this falls back to copying.
 
-For example, we would have to change the concatenate callback signature from `std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)` to `void concatenate(sdbus::Result<std::string> result, const std::vector<int32_t>& numbers, const std::string& separator)`.
+So the concatenate callback signature would change from `std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)` to `void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbers, std::string separator)`:
 
-`sdbus::Result` class template has effectively the same API as `sdbus::MethodResult` class mentioned in the above example (it inherits from `MethodResult`), so you use it in the very same way to send the results or an error back to the client.
+```c++
+void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbers, std::string separator) override
+{
+    // Launch a thread for async execution...
+    std::thread([this, methodResult = std::move(result), numbers = std::move(numbers), separator = std::move(separator)]()
+    {
+        // Return error if there are no numbers in the collection
+        if (numbers.empty())
+        {
+            // Let's send the error reply message back to the client
+            methodResult.returnError({"org.sdbuscpp.Concatenator.Error", "No numbers provided"});
+            return;
+        }
+        
+        std::string result;
+        for (auto number : numbers)
+        {
+            result += (result.empty() ? std::string() : separator) + std::to_string(number);
+        }
+        
+        // Let's send the reply message back to the client
+        methodResult.returnReply(result);
+        
+        // Emit the 'concatenated' signal with the resulting string
+        this->concatenated(result);
+    }).detach();
+}
+```
 
-Nothing else has to be changed. The registration of the method callback (`implementedAs`) and all the mechanics around remains completely the same.
+The `Result` is a convenience class that represents a future method result, and it is where we write the results (`returnReply()`) or an error (`returnError()`) which we want to send back to the client.
 
-Note: Async D-Bus method doesn't necessarily mean we always have to delegate the work to a different thread and immediately return. We can very well execute the work and return the results (via `returnResults()`) or an error (via `return Error()`) synchronously -- i.e. directly in this thread. dbus-c++ doesn't care, it supports both approaches. This has the benefit that we can decide at run-time, per each method call, whether we execute it synchronously or (in case of complex operation, for example) execute it asynchronously by moving the work to a worker thread.
+Registraion (`implementedAs()`) doesn't change. Nothing else needs to change.
 
 ### Marking server-side async methods in the IDL
 
@@ -804,6 +828,8 @@ sdbus-c++ stub generator can generate stub code for server-side async methods. W
 </node>
 ```
 
+For a real example of a server-side asynchronous D-Bus method, please look at sdbus-c++ [stress tests](/test/stresstests).
+
 Asynchronous client-side methods
 --------------------------------
 
@@ -919,6 +945,8 @@ For each client-side async method, a corresponding `on<MethodName>Reply` pure vi
     
 So in the specific example above, the stub generator will generate a `Concatenator_proxy` class similar to one shown in a [dedicated section above](#concatenator-client-glueh), with the difference that it will also generate an additional `virtual void onConcatenateReply(const sdbus::Error* error, const std::string& concatenatedString);` method, which we shall override in derived `ConcatenatorProxy`.
 
+For a real example of a client-side asynchronous D-Bus method, please look at sdbus-c++ [stress tests](/test/stresstests).
+
 Using D-Bus properties
 ----------------------
 

include/sdbus-c++/ConvenienceClasses.h

@@ -65,8 +65,7 @@ namespace sdbus {
         std::string interfaceName_;
         std::string inputSignature_;
         std::string outputSignature_;
-        method_callback syncCallback_;
-        async_method_callback asyncCallback_;
+        method_callback methodCallback_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };

include/sdbus-c++/ConvenienceClasses.inl

@@ -55,6 +55,7 @@ namespace sdbus {
             return;
 
         SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
+        SDBUS_THROW_ERROR_IF(!methodCallback_, "Method handler not specified when registering a DBus method", EINVAL);
 
         // registerMethod() can throw. But as the MethodRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -65,12 +66,7 @@ namespace sdbus {
         // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        if (syncCallback_)
-            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(syncCallback_));
-        else if(asyncCallback_)
-            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(asyncCallback_));
-        else
-            SDBUS_THROW_ERROR("Method handler not specified when registering a DBus method", EINVAL);
+        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
     }
     */
 
@@ -86,14 +82,14 @@ namespace sdbus {
     {
         inputSignature_ = signature_of_function_input_arguments<_Function>::str();
         outputSignature_ = signature_of_function_output_arguments<_Function>::str();
-        syncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodReply& reply)
+        methodCallback_ = [callback = std::forward<_Function>(callback)](MethodCall call)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the message.
             tuple_of_function_input_arg_types_t<_Function> inputArgs;
 
             // Deserialize input arguments from the message into the tuple
-            msg >> inputArgs;
+            call >> inputArgs;
 
             // Invoke callback with input arguments from the tuple.
             // For callbacks returning a non-void value, `apply' also returns that value.
@@ -102,7 +98,9 @@ namespace sdbus {
 
             // The return value is stored to the reply message.
             // In case of void functions, ret is an empty tuple and thus nothing is stored.
+            auto reply = call.createReply();
             reply << ret;
+            reply.send();
         };
 
         return *this;
@@ -113,17 +111,17 @@ namespace sdbus {
     {
         inputSignature_ = signature_of_function_input_arguments<_Function>::str();
         outputSignature_ = signature_of_function_output_arguments<_Function>::str();
-        asyncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall msg, MethodResult&& result)
+        methodCallback_ = [callback = std::forward<_Function>(callback)](MethodCall call)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the message.
             tuple_of_function_input_arg_types_t<_Function> inputArgs;
 
             // Deserialize input arguments from the message into the tuple.
-            msg >> inputArgs;
+            call >> inputArgs;
 
             // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, std::move(result), std::move(inputArgs)); // TODO: Use std::apply when switching to full C++17 support
+            sdbus::apply(callback, typename function_traits<_Function>::async_result_t{std::move(call)}, std::move(inputArgs));
         };
 
         return *this;

include/sdbus-c++/IConnection.h

@@ -38,8 +38,8 @@ namespace sdbus {
      * An interface to D-Bus bus connection. Incorporates implementation
      * of both synchronous and asynchronous processing loop.
      *
-     * All methods throw @sdbus::Error in case of failure. The class is
-     * thread-aware, but not thread-safe.
+     * All methods throw sdbus::Error in case of failure. All methods in
+     * this class are thread-aware, but not thread-safe.
      *
      ***********************************************/
     class IConnection
@@ -67,7 +67,7 @@ namespace sdbus {
         * @brief Enters the D-Bus processing loop
         *
         * The incoming D-Bus messages are processed in the loop. The method
-        * blocks indefinitely, until unblocked via @leaveProcessingLoop.
+        * blocks indefinitely, until unblocked via leaveProcessingLoop.
         *
         * @throws sdbus::Error in case of failure
         */
@@ -76,7 +76,7 @@ namespace sdbus {
         /*!
         * @brief Enters the D-Bus processing loop in a separate thread
         *
-        * The same as @enterProcessingLoop, except that it doesn't block
+        * The same as enterProcessingLoop, except that it doesn't block
         * because it runs the loop in a separate thread managed internally.
         */
         virtual void enterProcessingLoopAsync() = 0;

include/sdbus-c++/IObject.h

@@ -47,8 +47,11 @@ namespace sdbus {
      * An interface to D-Bus object. Provides API for registration
      * of methods, signals, properties, and for emitting signals.
      *
-     * All methods throw @c sdbus::Error in case of failure. The class is
-     * thread-aware, but not thread-safe.
+     * All methods throw @c sdbus::Error in case of failure.
+     * In general, the class is thread-aware, but not thread-safe.
+     * However, the operation of creating and sending asynchronous
+     * method replies, as well as creating and emitting
+     * signals, is thread-safe.
      *
      ***********************************************/
     class IObject
@@ -62,7 +65,7 @@ namespace sdbus {
         * @param[in] inputSignature D-Bus signature of method input parameters
         * @param[in] outputSignature D-Bus signature of method output parameters
         * @param[in] methodCallback Callback that implements the body of the method
-        * @param[in] noReply If true, the method isn't expected to send reply
+        * @param[in] flags D-Bus method flags (privileged, deprecated, or no reply)
         *
         * @throws sdbus::Error in case of failure
         */
@@ -73,36 +76,13 @@ namespace sdbus {
                                    , method_callback methodCallback
                                    , Flags flags = {} ) = 0;
 
-        /*!
-        * @brief Registers method that the object will provide on D-Bus
-        *
-        * @param[in] interfaceName Name of an interface that the method will belong to
-        * @param[in] methodName Name of the method
-        * @param[in] inputSignature D-Bus signature of method input parameters
-        * @param[in] outputSignature D-Bus signature of method output parameters
-        * @param[in] asyncMethodCallback Callback that implements the body of the method
-        * @param[in] noReply If true, the method isn't expected to send reply
-        *
-        * This overload register a method callback that will have a freedom to execute
-        * its body in asynchronous contexts, and send the results from those contexts.
-        * This can help in e.g. long operations, which then don't block the D-Bus processing
-        * loop thread.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void registerMethod( const std::string& interfaceName
-                                   , const std::string& methodName
-                                   , const std::string& inputSignature
-                                   , const std::string& outputSignature
-                                   , async_method_callback asyncMethodCallback
-                                   , Flags flags = {} ) = 0;
-
         /*!
         * @brief Registers signal that the object will emit on D-Bus
         *
         * @param[in] interfaceName Name of an interface that the signal will fall under
         * @param[in] signalName Name of the signal
         * @param[in] signature D-Bus signature of signal parameters
+        * @param[in] flags D-Bus signal flags (deprecated)
         *
         * @throws sdbus::Error in case of failure
         */
@@ -118,6 +98,7 @@ namespace sdbus {
         * @param[in] propertyName Name of the property
         * @param[in] signature D-Bus signature of property parameters
         * @param[in] getCallback Callback that implements the body of the property getter
+        * @param[in] flags D-Bus property flags (deprecated, property update behavior)
         *
         * @throws sdbus::Error in case of failure
         */
@@ -135,6 +116,7 @@ namespace sdbus {
         * @param[in] signature D-Bus signature of property parameters
         * @param[in] getCallback Callback that implements the body of the property getter
         * @param[in] setCallback Callback that implements the body of the property setter
+        * @param[in] flags D-Bus property flags (deprecated, property update behavior)
         *
         * @throws sdbus::Error in case of failure
         */
@@ -327,6 +309,9 @@ namespace sdbus {
     * The provided connection will be used by the object to export methods,
     * issue signals and provide properties.
     *
+    * Creating a D-Bus object instance is (thread-)safe even upon the connection
+    * which is already running its processing loop.
+    *
     * Code example:
     * @code
     * auto proxy = sdbus::createObject(connection, "/com/kistler/foo");

include/sdbus-c++/IObjectProxy.h

@@ -47,8 +47,10 @@ namespace sdbus {
      * An interface to D-Bus object proxy. Provides API for calling
      * methods, getting/setting properties, and for registering to signals.
      *
-     * All methods throw @c sdbus::Error in case of failure. The class is
-     * thread-aware, but not thread-safe.
+     * All methods throw @c sdbus::Error in case of failure.
+     * In general, the class is thread-aware, but not thread-safe.
+     * However, the operation of creating and sending method calls
+     * (both synchronously and asynchronously) is thread-safe.
      *
      ***********************************************/
     class IObjectProxy
@@ -107,7 +109,7 @@ namespace sdbus {
         * @brief Calls method on the proxied D-Bus object asynchronously
         *
         * @param[in] message Message representing an async method call
-        * @param[in] asyncReplyHandler Handler for the async reply
+        * @param[in] asyncReplyCallback Handler for the async reply
         *
         * The call is non-blocking. It doesn't wait for the reply. Once the reply arrives,
         * the provided async reply handler will get invoked from the context of the connection
@@ -284,11 +286,10 @@ namespace sdbus {
     * @return Pointer to the object proxy instance
     *
     * The provided connection will be used by the proxy to issue calls against the object,
-    * and signals, if any, will be subscribed to on this connection. Since the caller still
-    * remains the owner of the connection (the proxy just keeps reference to it) after the call,
-    * the proxy will not start its own background processing loop for incoming signals (if any),
-    * as it will rely on the client as an owner of the connection to handle processing of
-    * incoming messages on that connection by themselves.
+    * and signals, if any, will be subscribed to on this connection. The caller still
+    * remains the owner of the connection (the proxy just keeps a reference to it), and
+    * should make sure that a processing loop is running on that connection, so the proxy
+    * may receive incoming signals and asynchronous method replies.
     *
     * Code example:
     * @code
@@ -308,11 +309,10 @@ namespace sdbus {
     * @return Pointer to the object proxy instance
     *
     * The provided connection will be used by the proxy to issue calls against the object,
-    * and signals, if any, will be subscribed to on this connection. Object proxy becomes
-    * an exclusive owner of this connection. The effect of this is that when there is at
-    * least one signal in proxy's interface, then the proxy will immediately start its own
-    * processing loop for this connection in a separate internal thread, causing incoming
-    * signals to be correctly received and processed in the context of that internal thread.
+    * and signals, if any, will be subscribed to on this connection. The Object proxy becomes
+    * an exclusive owner of this connection, and will automatically start a procesing loop
+    * upon that connection in a separate internal thread. Handlers for incoming signals and
+    * asynchronous method replies will be executed in the context of that thread.
     *
     * Code example:
     * @code
@@ -330,14 +330,14 @@ namespace sdbus {
     * @param[in] objectPath Path of the D-Bus object
     * @return Pointer to the object proxy instance
     *
-    * This factory overload creates a proxy that manages its own D-Bus connection(s).
-    * When there is at least one signal in proxy's interface, then the proxy will immediately
-    * start its own processing loop for this connection in its own separate thread, causing
-    * incoming signals to be correctly received and processed in the context of that thread.
+    * No D-Bus connection is provided here, so the object proxy will create and manage
+    * his own connection, and will automatically start a procesing loop upon that connection
+    * in a separate internal thread. Handlers for incoming signals and asynchronous
+    * method replies will be executed in the context of that thread.
     *
     * Code example:
     * @code
-    * auto proxy = sdbus::createObjectProxy(connection, "com.kistler.foo", "/com/kistler/foo");
+    * auto proxy = sdbus::createObjectProxy("com.kistler.foo", "/com/kistler/foo");
     * @endcode
     */
     std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::string destination

include/sdbus-c++/MethodResult.h

@@ -31,43 +31,11 @@
 
 // Forward declaration
 namespace sdbus {
-    namespace internal {
-        class Object;
-    }
     class Error;
 }
 
 namespace sdbus {
 
-    /********************************************//**
-     * @class MethodResult
-     *
-     * Represents result of an asynchronous server-side method.
-     * An instance is provided to the method and shall be set
-     * by the method to either method return value or an error.
-     *
-     ***********************************************/
-    class MethodResult
-    {
-    protected:
-        friend sdbus::internal::Object;
-
-        MethodResult() = default;
-        MethodResult(MethodCall msg);
-
-        MethodResult(const MethodResult&) = delete;
-        MethodResult& operator=(const MethodResult&) = delete;
-
-        MethodResult(MethodResult&& other) = default;
-        MethodResult& operator=(MethodResult&& other) = default;
-
-        template <typename... _Results> void returnResults(const _Results&... results) const;
-        void returnError(const Error& error) const;
-
-    private:
-        MethodCall call_;
-    };
-
     /********************************************//**
      * @class Result
      *
@@ -77,18 +45,52 @@ namespace sdbus {
      *
      ***********************************************/
     template <typename... _Results>
-    class Result : protected MethodResult
+    class Result
     {
     public:
         Result() = default;
-        Result(MethodResult&& result);
+        Result(MethodCall call);
+
+        Result(const Result&) = delete;
+        Result& operator=(const Result&) = delete;
+
+        Result(Result&& other) = default;
+        Result& operator=(Result&& other) = default;
 
         void returnResults(const _Results&... results) const;
         void returnError(const Error& error) const;
+
+    private:
+        MethodCall call_;
     };
 
+    template <typename... _Results>
+    inline Result<_Results...>::Result(MethodCall call)
+        : call_(std::move(call))
+    {
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnResults(const _Results&... results) const
+    {
+        assert(call_.isValid());
+        auto reply = call_.createReply();
+#ifdef __cpp_fold_expressions
+        (reply << ... << results);
+#else
+        using _ = std::initializer_list<int>;
+        (void)_{(void(reply << results), 0)...};
+#endif
+        reply.send();
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnError(const Error& error) const
+    {
+        auto reply = call_.createErrorReply(error);
+        reply.send();
+    }
+
 }
 
-#include <sdbus-c++/MethodResult.inl>
-
 #endif /* SDBUS_CXX_METHODRESULT_H_ */

include/sdbus-c++/MethodResult.inl

@@ -1,79 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file MethodResult.inl
- *
- * Created on: Mar 21, 2019
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SDBUS_CXX_METHODRESULT_INL_
-#define SDBUS_CXX_METHODRESULT_INL_
-
-#include <sdbus-c++/MethodResult.h>
-#include <cassert>
-
-namespace sdbus {
-
-    inline MethodResult::MethodResult(MethodCall msg)
-        : call_(std::move(msg))
-    {
-    }
-
-    template <typename... _Results>
-    inline void MethodResult::returnResults(const _Results&... results) const
-    {
-        assert(call_.isValid());
-        auto reply = call_.createReply();
-#ifdef __cpp_fold_expressions
-        (reply << ... << results);
-#else
-        using _ = std::initializer_list<int>;
-        (void)_{(void(reply << results), 0)...};
-#endif
-        reply.send();
-    }
-
-    inline void MethodResult::returnError(const Error& error) const
-    {
-        auto reply = call_.createErrorReply(error);
-        reply.send();
-    }
-
-    template <typename... _Results>
-    inline Result<_Results...>::Result(MethodResult&& result)
-        : MethodResult(std::move(result))
-    {
-    }
-
-    template <typename... _Results>
-    inline void Result<_Results...>::returnResults(const _Results&... results) const
-    {
-        MethodResult::returnResults(results...);
-    }
-
-    template <typename... _Results>
-    inline void Result<_Results...>::returnError(const Error& error) const
-    {
-        MethodResult::returnError(error);
-    }
-
-}
-
-#endif /* SDBUS_CXX_METHODRESULT_INL_ */

include/sdbus-c++/TypeTraits.h

@@ -44,15 +44,13 @@ namespace sdbus {
     class MethodCall;
     class MethodReply;
     class Signal;
-    class MethodResult;
     template <typename... _Results> class Result;
     class Error;
 }
 
 namespace sdbus {
 
-    using method_callback = std::function<void(MethodCall& msg, MethodReply& reply)>;
-    using async_method_callback = std::function<void(MethodCall msg, MethodResult&& result)>;
+    using method_callback = std::function<void(MethodCall msg)>;
     using async_reply_handler = std::function<void(MethodReply& reply, const Error* error)>;
     using signal_handler = std::function<void(Signal& signal)>;
     using property_set_callback = std::function<void(Message& msg)>;
@@ -381,6 +379,7 @@ namespace sdbus {
         : public function_traits_base<std::tuple<_Results...>, _Args...>
     {
         static constexpr bool is_async = true;
+        using async_result_t = Result<_Results...>;
     };
 
     template <typename... _Args, typename... _Results>
@@ -388,6 +387,7 @@ namespace sdbus {
         : public function_traits_base<std::tuple<_Results...>, _Args...>
     {
         static constexpr bool is_async = true;
+        using async_result_t = Result<_Results...>;
     };
 
     template <typename _ReturnType, typename... _Args>
@@ -504,9 +504,9 @@ namespace sdbus {
 
     namespace detail
     {
-        template <class _Function, class _Tuple, std::size_t... _I>
+        template <class _Function, class _Tuple, typename... _Args, std::size_t... _I>
         constexpr decltype(auto) apply_impl( _Function&& f
-                                           , MethodResult&& r
+                                           , Result<_Args...>&& r
                                            , _Tuple&& t
                                            , std::index_sequence<_I...> )
         {
@@ -558,8 +558,8 @@ namespace sdbus {
 
     // Convert tuple `t' of values into a list of arguments
     // and invoke function `f' with those arguments.
-    template <class _Function, class _Tuple>
-    constexpr decltype(auto) apply(_Function&& f, MethodResult&& r, _Tuple&& t)
+    template <class _Function, class _Tuple, typename... _Args>
+    constexpr decltype(auto) apply(_Function&& f, Result<_Args...>&& r, _Tuple&& t)
     {
         return detail::apply_impl( std::forward<_Function>(f)
                                  , std::move(r)

src/ConvenienceClasses.cpp

@@ -39,12 +39,13 @@ MethodRegistrator::MethodRegistrator(IObject& object, const std::string& methodN
 }
 
 MethodRegistrator::~MethodRegistrator() noexcept(false) // since C++11, destructors must
-{                                                              // explicitly be allowed to throw
+{                                                       // explicitly be allowed to throw
     // Don't register the method if MethodRegistrator threw an exception in one of its methods
     if (std::uncaught_exceptions() != exceptions_)
         return;
 
     SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
+    SDBUS_THROW_ERROR_IF(!methodCallback_, "Method handler not specified when registering a DBus method", EINVAL);
 
     // registerMethod() can throw. But as the MethodRegistrator shall always be used as an unnamed,
     // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -55,12 +56,7 @@ MethodRegistrator::~MethodRegistrator() noexcept(false) // since C++11, destruct
     // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
     // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
     // to the exception thrown from here if the caller is a destructor itself.
-    if (syncCallback_)
-        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(syncCallback_), flags_);
-    else if(asyncCallback_)
-        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(asyncCallback_), flags_);
-    else
-        SDBUS_THROW_ERROR("Method handler not specified when registering a DBus method", EINVAL);
+    object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
 }
 
 SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)

src/Object.cpp

@@ -51,37 +51,8 @@ void Object::registerMethod( const std::string& interfaceName
 {
     SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
-    auto syncCallback = [callback = std::move(methodCallback)](MethodCall& msg)
-    {
-        auto reply = msg.createReply();
-        callback(msg, reply);
-        reply.send();
-    };
-
     auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(syncCallback), flags};
-    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
-
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
-}
-
-void Object::registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback
-                           , Flags flags )
-{
-    SDBUS_THROW_ERROR_IF(!asyncMethodCallback, "Invalid method callback provided", EINVAL);
-
-    auto asyncCallback = [callback = std::move(asyncMethodCallback)](MethodCall& msg)
-    {
-        MethodResult result{msg};
-        callback(std::move(msg), std::move(result));
-    };
-
-    auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(asyncCallback), flags};
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(methodCallback), flags};
     auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
@@ -245,7 +216,7 @@ int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData,
 
     try
     {
-        callback(message);
+        callback(std::move(message));
     }
     catch (const sdbus::Error& e)
     {

src/Object.h

@@ -52,13 +52,6 @@ namespace internal {
                            , method_callback methodCallback
                            , Flags flags ) override;
 
-        void registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback
-                           , Flags flags ) override;
-
         void registerSignal( const std::string& interfaceName
                            , const std::string& signalName
                            , const std::string& signature
@@ -93,7 +86,7 @@ namespace internal {
             {
                 std::string inputArgs_;
                 std::string outputArgs_;
-                std::function<void(MethodCall&)> callback_;
+                method_callback callback_;
                 Flags flags_;
             };
             std::map<MethodName, MethodData> methods_;

stub-generator/CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.5)
 
-project(sdbuscpp-xml2cpp)
+project(sdbus-c++-xml2cpp)
 
 include(GNUInstallDirs)
 

stub-generator/generator_utils.h

@@ -17,6 +17,6 @@ std::string signature_to_type(const std::string& signature);
 
 std::string underscorize(const std::string& str);
 
-constexpr const char* getHeaderComment() noexcept { return "\n/*\n * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!\n */\n\n"; }
+constexpr const char* getHeaderComment() noexcept { return "\n/*\n * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!\n */\n\n"; }
 
 #endif  //__SDBUSCPP_TOOLS_GENERATOR_UTILS_H

test/CMakeLists.txt

@@ -33,7 +33,7 @@ add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
 
 set(UNITTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/unittests)
 set(UNITTESTS_SRCS
-    ${UNITTESTS_SOURCE_DIR}/libsdbus-c++_unittests.cpp
+    ${UNITTESTS_SOURCE_DIR}/sdbus-c++-unit-tests.cpp
     ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
     ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
@@ -44,7 +44,7 @@ set(INTEGRATIONTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/integrationtests)
 set(INTEGRATIONTESTS_SRCS
     ${INTEGRATIONTESTS_SOURCE_DIR}/AdaptorAndProxy_test.cpp
     ${INTEGRATIONTESTS_SOURCE_DIR}/Connection_test.cpp
-    ${INTEGRATIONTESTS_SOURCE_DIR}/libsdbus-c++_integrationtests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/sdbus-c++-integration-tests.cpp
     ${INTEGRATIONTESTS_SOURCE_DIR}/adaptor-glue.h
     ${INTEGRATIONTESTS_SOURCE_DIR}/defs.h
     ${INTEGRATIONTESTS_SOURCE_DIR}/proxy-glue.h
@@ -61,7 +61,7 @@ set(STRESSTESTS_SERVER_SRCS
 
 set(STRESSTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/stresstests)
 set(STRESSTESTS_SRCS
-    ${STRESSTESTS_SOURCE_DIR}/stresstests.cpp
+    ${STRESSTESTS_SOURCE_DIR}/sdbus-c++-stress-tests.cpp
     ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-adaptor.h
     ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-proxy.h
     ${STRESSTESTS_SOURCE_DIR}/concatenator-adaptor.h
@@ -81,68 +81,59 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 # targets even when INTERFACE_INCLUDE_DIRECTORIES is used.
 set(CMAKE_NO_SYSTEM_FROM_IMPORTED "1")
 
-add_executable(libsdbus-c++_unittests ${UNITTESTS_SRCS} $<TARGET_OBJECTS:sdbuscppobjects>)
-target_link_libraries(libsdbus-c++_unittests ${SYSTEMD_LIBRARIES} gmock gmock_main)
+add_executable(sdbus-c++-unit-tests ${UNITTESTS_SRCS} $<TARGET_OBJECTS:sdbus-cpp>)
+target_link_libraries(sdbus-c++-unit-tests ${SYSTEMD_LIBRARIES} gmock gmock_main)
 
-add_executable(libsdbus-c++_integrationtests ${INTEGRATIONTESTS_SRCS})
-target_link_libraries(libsdbus-c++_integrationtests sdbus-c++ gmock gmock_main)
+add_executable(sdbus-c++-integration-tests ${INTEGRATIONTESTS_SRCS})
+target_link_libraries(sdbus-c++-integration-tests sdbus-c++ gmock gmock_main)
 
-# Manual performance tests
-option(ENABLE_PERFTESTS "Build and install manual performance tests (default OFF)" OFF)
-if(ENABLE_PERFTESTS)
-    add_executable(libsdbus-c++_perftests_client ${STRESSTESTS_CLIENT_SRCS})
-    target_link_libraries(libsdbus-c++_perftests_client sdbus-c++)
-    add_executable(libsdbus-c++_perftests_server ${STRESSTESTS_SERVER_SRCS})
-    target_link_libraries(libsdbus-c++_perftests_server sdbus-c++)
-endif()
+# Manual performance and stress tests
+option(ENABLE_PERF_TESTS "Build and install manual performance tests (default OFF)" OFF)
+option(ENABLE_STRESS_TESTS "Build and install manual stress tests (default OFF)" OFF)
 
-# Manual stress tests
-option(ENABLE_STRESSTESTS "Build and install manual stress tests (default OFF)" ON)
-if(ENABLE_STRESSTESTS)
+if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads REQUIRED)
 
-    add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
-    target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
+    if(ENABLE_PERF_TESTS)
+        add_executable(sdbus-c++-perf-tests-client ${STRESSTESTS_CLIENT_SRCS})
+        target_link_libraries(sdbus-c++-perf-tests-client sdbus-c++ Threads::Threads)
+        add_executable(sdbus-c++-perf-tests-server ${STRESSTESTS_SERVER_SRCS})
+        target_link_libraries(sdbus-c++-perf-tests-server sdbus-c++ Threads::Threads)
+    endif()
+
+    if(ENABLE_STRESS_TESTS)
+        add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
+        target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
+    endif()
 endif()
 
 #----------------------------------
 # INSTALLATION
 #----------------------------------
 
-install(TARGETS libsdbus-c++_unittests DESTINATION /opt/test/bin)
-install(TARGETS libsdbus-c++_integrationtests DESTINATION /opt/test/bin)
-install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/libsdbus-cpp-test.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
+set(TESTS_INSTALL_PATH "/opt/test/bin" CACHE STRING "Specifies where the test binaries will be installed")
 
-if(ENABLE_PERFTESTS)
-    install(TARGETS libsdbus-c++_perftests_client DESTINATION /opt/test/bin)
-    install(TARGETS libsdbus-c++_perftests_server DESTINATION /opt/test/bin)
-    install(FILES perftests/files/org.sdbuscpp.perftest.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
+install(TARGETS sdbus-c++-unit-tests DESTINATION ${TESTS_INSTALL_PATH})
+install(TARGETS sdbus-c++-integration-tests DESTINATION ${TESTS_INSTALL_PATH})
+install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf DESTINATION /etc/dbus-1/system.d)
+
+if(ENABLE_PERF_TESTS)
+    install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${TESTS_INSTALL_PATH})
+    install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${TESTS_INSTALL_PATH})
+    install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf DESTINATION /etc/dbus-1/system.d)
 endif()
 
-if(ENABLE_STRESSTESTS)
-    install(TARGETS sdbus-c++-stress-tests DESTINATION /opt/test/bin)
-    install(FILES perftests/files/org.sdbuscpp.stresstest.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
+if(ENABLE_STRESS_TESTS)
+    install(TARGETS sdbus-c++-stress-tests DESTINATION ${TESTS_INSTALL_PATH})
+    install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf DESTINATION /etc/dbus-1/system.d)
 endif()
 
 #----------------------------------
 # RUNNING THE TESTS UPON BUILD
 #----------------------------------
 
-if(CMAKE_CROSSCOMPILING)
-    if(NOT DEFINED UNIT_TESTS_RUNNER)
-        set(UNIT_TESTS_RUNNER $ENV{UNIT_TESTS_RUNNER})
-    endif()
-    if(NOT DEFINED TEST_DEVICE_IP)
-        set(TEST_DEVICE_IP $ENV{TEST_DEVICE_IP})
-    endif()
-
-    if(NOT (UNIT_TESTS_RUNNER AND TEST_DEVICE_IP))
-        message(WARNING "UNIT_TESTS_RUNNER and TEST_DEVICE_IP variables must be defined to run tests remotely")
-    endif()
-    add_test(NAME libsdbus-c++_unittests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_unittests)
-    add_test(NAME libsdbus-c++_integrationtests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_integrationtests)
-else()
-    add_test(NAME libsdbus-c++_unittests COMMAND libsdbus-c++_unittests)
-    add_test(NAME libsdbus-c++_integrationtests COMMAND libsdbus-c++_integrationtests)
+if(NOT CMAKE_CROSSCOMPILING)
+    add_test(NAME sdbus-c++-unit-tests COMMAND sdbus-c++-unit-tests)
+    add_test(NAME sdbus-c++-integration-tests COMMAND sdbus-c++-integration-tests)
 endif() 

test/integrationtests/adaptor-glue.h

@@ -210,7 +210,7 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <arg type="as" name="invalidated_properties"/>
   </signal>
  </interface>
- <interface name="com.kistler.testsdbuscpp">
+ <interface name="org.sdbuscpp.integrationtests">
   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
   <method name="doOperation">
    <arg type="u" direction="in"/>

test/integrationtests/defs.h

@@ -28,7 +28,7 @@
 
 #include "sdbus-c++/Types.h"
 
-const std::string INTERFACE_NAME{"com.kistler.testsdbuscpp"};
+const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 const std::string OBJECT_PATH{"/"};
 
 constexpr const uint8_t UINT8_VALUE{1};

test/integrationtests/files/org.sdbuscpp.integrationtests.conf

@@ -8,9 +8,9 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="com.kistler.testsdbuscpp"/>
-    <allow send_destination="com.kistler.testsdbuscpp"/>
-    <allow send_interface="com.kistler.testsdbuscpp"/>
+    <allow own="org.sdbuscpp.integrationtests"/>
+    <allow send_destination="org.sdbuscpp.integrationtests"/>
+    <allow send_interface="org.sdbuscpp.integrationtests"/>
   </policy>
 
 </busconfig>

test/integrationtests/sdbus-c++-integration-tests.cpp

@@ -1,7 +1,7 @@
 /**
  * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  *
- * @file libsdbus-c++_integrationtests.cpp
+ * @file sdbus-c++-integration-tests.cpp
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++

test/perftests/client.cpp

@@ -89,8 +89,8 @@ std::string createRandomString(size_t length)
 //-----------------------------------------
 int main(int /*argc*/, char */*argv*/[])
 {
-    const char* destinationName = "org.sdbuscpp.perftest";
-    const char* objectPath = "/org/sdbuscpp/perftest";
+    const char* destinationName = "org.sdbuscpp.perftests";
+    const char* objectPath = "/org/sdbuscpp/perftests";
     PerftestClient client(destinationName, objectPath);
 
     const unsigned int repetitions{20};

test/perftests/files/org.sdbuscpp.perftests.conf

@@ -8,9 +8,9 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="org.sdbuscpp.perftest"/>
-    <allow send_destination="org.sdbuscpp.perftest"/>
-    <allow send_interface="org.sdbuscpp.perftest"/>
+    <allow own="org.sdbuscpp.perftests"/>
+    <allow send_destination="org.sdbuscpp.perftests"/>
+    <allow send_interface="org.sdbuscpp.perftests"/>
   </policy>
 
 </busconfig>

test/perftests/perftest-adaptor.h

@@ -16,7 +16,7 @@ namespace sdbuscpp {
 class perftest_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.perftest";
+    static constexpr const char* interfaceName = "org.sdbuscpp.perftests";
 
 protected:
     perftest_adaptor(sdbus::IObject& object)

test/perftests/perftest-proxy.h

@@ -16,7 +16,7 @@ namespace sdbuscpp {
 class perftest_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.perftest";
+    static constexpr const char* interfaceName = "org.sdbuscpp.perftests";
 
 protected:
     perftest_proxy(sdbus::IObjectProxy& object)

test/perftests/server.cpp

@@ -85,10 +85,10 @@ std::string createRandomString(size_t length)
 //-----------------------------------------
 int main(int /*argc*/, char */*argv*/[])
 {
-    const char* serviceName = "org.sdbuscpp.perftest";
+    const char* serviceName = "org.sdbuscpp.perftests";
     auto connection = sdbus::createSystemBusConnection(serviceName);
 
-    const char* objectPath = "/org/sdbuscpp/perftest";
+    const char* objectPath = "/org/sdbuscpp/perftests";
     PerftestServer server(*connection, objectPath);
 
     connection->enterProcessingLoop();

test/stresstests/celsius-thermometer-adaptor.h

@@ -18,7 +18,7 @@ namespace celsius {
 class thermometer_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.celsius.thermometer";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)

test/stresstests/celsius-thermometer-proxy.h

@@ -18,7 +18,7 @@ namespace celsius {
 class thermometer_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.celsius.thermometer";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
     thermometer_proxy(sdbus::IObjectProxy& object)

test/stresstests/concatenator-adaptor.h

@@ -17,7 +17,7 @@ namespace stresstest {
 class concatenator_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.concatenator";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.concatenator";
 
 protected:
     concatenator_adaptor(sdbus::IObject& object)

test/stresstests/concatenator-proxy.h

@@ -17,7 +17,7 @@ namespace stresstest {
 class concatenator_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.concatenator";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.concatenator";
 
 protected:
     concatenator_proxy(sdbus::IObjectProxy& object)

test/stresstests/fahrenheit-thermometer-adaptor.h

@@ -18,7 +18,7 @@ namespace fahrenheit {
 class thermometer_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.fahrenheit.thermometer";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)

test/stresstests/fahrenheit-thermometer-proxy.h

@@ -18,7 +18,7 @@ namespace fahrenheit {
 class thermometer_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.fahrenheit.thermometer";
+    static constexpr const char* interfaceName = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
 
 protected:
     thermometer_proxy(sdbus::IObjectProxy& object)

test/stresstests/files/org.sdbuscpp.stresstests.conf

@@ -8,15 +8,15 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="org.sdbuscpp.stresstest.service1"/>
-    <allow send_destination="org.sdbuscpp.stresstest.service1"/>
-    <allow send_interface="org.sdbuscpp.stresstest.service1"/>
+    <allow own="org.sdbuscpp.stresstests.service1"/>
+    <allow send_destination="org.sdbuscpp.stresstests.service1"/>
+    <allow send_interface="org.sdbuscpp.stresstests.service1"/>
   </policy>
   
   <policy context="default">
-    <allow own="org.sdbuscpp.stresstest.service2"/>
-    <allow send_destination="org.sdbuscpp.stresstest.service2"/>
-    <allow send_interface="org.sdbuscpp.stresstest.service2"/>
+    <allow own="org.sdbuscpp.stresstests.service2"/>
+    <allow send_destination="org.sdbuscpp.stresstests.service2"/>
+    <allow send_interface="org.sdbuscpp.stresstests.service2"/>
   </policy>
 
 </busconfig>

test/stresstests/sdbus-c++-stress-tests.cpp

@@ -1,7 +1,7 @@
 /**
  * (C) 2019 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  *
- * @file stresstests.cpp
+ * @file sdbus-c++-stress-tests.cpp
  *
  * Created on: Jan 25, 2019
  * Project: sdbus-c++
@@ -46,11 +46,11 @@
 using namespace std::chrono_literals;
 using namespace std::string_literals;
 
-#define SERVICE_1_BUS_NAME "org.sdbuscpp.stresstest.service1"
-#define SERVICE_2_BUS_NAME "org.sdbuscpp.stresstest.service2"
-#define CELSIUS_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstest/celsius/thermometer"
-#define FAHRENHEIT_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstest/fahrenheit/thermometer"
-#define CONCATENATOR_OBJECT_PATH "/org/sdbuscpp/stresstest/concatenator"
+#define SERVICE_1_BUS_NAME "org.sdbuscpp.stresstests.service1"
+#define SERVICE_2_BUS_NAME "org.sdbuscpp.stresstests.service2"
+#define CELSIUS_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstests/celsius/thermometer"
+#define FAHRENHEIT_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstests/fahrenheit/thermometer"
+#define CONCATENATOR_OBJECT_PATH "/org/sdbuscpp/stresstests/concatenator"
 
 class CelsiusThermometerAdaptor : public sdbus::Interfaces<org::sdbuscpp::stresstest::celsius::thermometer_adaptor>
 {

test/unittests/sdbus-c++-unit-tests.cpp

@@ -1,7 +1,7 @@
 /**
  * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  *
- * @file libsdbus-c++_unittests.cpp
+ * @file sdbus-c++-unit-tests.cpp
  *
  * Created on: Nov 27, 2016
  * Project: sdbus-c++