update changelog: v0.9.0

add dependency to libsytemd-dev to sdbus-c++-dev package
add cpack to build debian packages, split the packages by components
2021-10-15 15:20:46 +02:00 · 2021-09-23 20:18:14 +02:00 · 2021-09-23 20:18:14 +02:00 · 2021-09-17 19:25:39 +02:00 · 2021-09-17 19:03:15 +02:00 · 2021-09-17 18:31:04 +02:00
61 changed files with 3439 additions and 1300 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -0,0 +1,68 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04, ubuntu-20.04]
+        compiler: [g++, clang]
+        build: [shared-libsystemd]
+        include:
+          - os: ubuntu-20.04
+            compiler: g++
+            build: embedded-static-libsystemd
+    steps:
+    - uses: actions/checkout@v2
+    - name: install-libsystemd-toolchain
+      if: matrix.build == 'embedded-static-libsystemd'
+      run: |
+        sudo apt-get update -y
+        sudo apt-get install -y meson ninja-build libcap-dev libmount-dev m4 gperf
+    - name: install-libsystemd-dev
+      if: matrix.build == 'shared-libsystemd'
+      run: |
+        sudo apt-get update -y
+        sudo apt-get install -y libsystemd-dev
+    - name: install-clang
+      if: matrix.compiler == 'clang'
+      run: |
+        sudo apt-get install -y clang
+        sudo update-alternatives --remove-all cc
+        sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 10
+        sudo update-alternatives --remove-all c++
+        sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 10
+    - name: configure-debug
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-18.04'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-O0 -g -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+    - name: configure-release
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-O3 -DNDEBUG -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+    - name: configure-with-embedded-libsystemd
+      if: matrix.build == 'embedded-static-libsystemd'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON -DBUILD_LIBSYSTEMD=ON -DLIBSYSTEMD_VERSION=244 ..
+    - name: make
+      run: |
+        cd build
+        make -j2
+    - name: verify
+      run: |
+        cd build
+        sudo make install
+        ctest
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -4,7 +4,7 @@

 cmake_minimum_required(VERSION 3.13)

-project(sdbus-c++ VERSION 0.8.2 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.8.3 LANGUAGES C CXX)

 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file

@ -23,12 +23,16 @@ if(NOT BUILD_LIBSYSTEMD)
                            "and building libsystemd in as part of sdbus-c++ during configuration)")
    endif()
    add_library(Systemd::Libsystemd ALIAS PkgConfig::Systemd)
-    set(LIBSYSTEMD_VERSION ${Systemd_VERSION})
+    string(REGEX MATCHALL "([0-9]+)" SYSTEMD_VERSION_LIST "${Systemd_VERSION}")
+    list(GET SYSTEMD_VERSION_LIST 0 LIBSYSTEMD_VERSION)
+    message(STATUS "Building with libsystemd v${LIBSYSTEMD_VERSION}")
 else()
    # Build static libsystemd library as an external project
    include(cmake/LibsystemdExternalProject.cmake)
 endif()

+find_package(Threads REQUIRED)
+
 #-------------------------------
 # SOURCE FILES CONFIGURATION
 #-------------------------------
@ -107,7 +111,10 @@ endif()
 if(BUILD_LIBSYSTEMD)
    add_dependencies(sdbus-c++-objlib LibsystemdBuildProject)
 endif()
-target_link_libraries(sdbus-c++-objlib PUBLIC Systemd::Libsystemd)
+target_link_libraries(sdbus-c++-objlib
+        PUBLIC
+            Systemd::Libsystemd
+            Threads::Threads)

 add_library(sdbus-c++)
 target_include_directories(sdbus-c++ PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
@ -129,9 +136,9 @@ endif()

 install(TARGETS ${EXPORT_SET}
        EXPORT sdbus-c++-targets
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT libraries
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT static_libraries
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT runtime
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT runtime
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT dev
        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT dev)

 #----------------------------------
@ -141,6 +148,7 @@ install(TARGETS ${EXPORT_SET}
 option(BUILD_TESTS "Build and install tests (default OFF)" OFF)

 if(BUILD_TESTS)
+    message(STATUS "Building with tests")
    enable_testing()
    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tests")
 endif()
@ -152,6 +160,7 @@ endif()
 option(BUILD_CODE_GEN "Build and install interface stub code generator (default OFF)" OFF)

 if(BUILD_CODE_GEN)
+    message(STATUS "Building with code generator tool")
    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tools")
 endif()

@ -162,9 +171,10 @@ endif()
 option(BUILD_DOC "Build documentation for sdbus-c++" ON)

 if(BUILD_DOC)
+    message(STATUS "Building with documentation")
    option(BUILD_DOXYGEN_DOC "Build doxygen documentation for sdbus-c++ API" OFF)
    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/docs")
-    install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR})
+    install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT doc)
 endif()

 #----------------------------------
@ -189,3 +199,24 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-config.cmake
 configure_file(pkgconfig/sdbus-c++.pc.in pkgconfig/sdbus-c++.pc @ONLY)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++.pc
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
+
+#----------------------------------
+# CPack
+#----------------------------------
+set(CPACK_PACKAGE_VENDOR "Kistler")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "high-level C++ D-Bus library")
+set(CPACK_PACKAGE_CONTACT "info@kistler.com")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
+set(CPACK_COMPONENT_DEV_DEPENDS "runtime")
+
+# specific for DEB generator
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_RUNTIME_DEBUGINFO_PACKAGE ON)
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME ${PROJECT_NAME})
+set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS ON)
+set(CPACK_DEBIAN_DEV_PACKAGE_DEPENDS "libsystemd-dev (>=236)")
+
+include(CPack)
--- a/22
+++ b/22
@ -0,0 +1,22 @@
+sdbus-c++ LGPL Exception version 1.0
+
+As an additional permission to the GNU Lesser General Public License version
+2.1, the object code form of a "work that uses the Library" may incorporate
+material from a header file that is part of the Library.  You may distribute
+such object code under terms of your choice, provided that:
+    (i)   the header files of the Library have not been modified; and 
+    (ii)  the incorporated material is limited to numerical parameters, data
+          structure layouts, accessors, macros, inline functions and
+          templates; and
+    (iii) you comply with the terms of Section 6 of the GNU Lesser General
+          Public License version 2.1.
+
+Moreover, you may apply this exception to a modified version of the Library,
+provided that such modification does not involve copying material from the
+Library into the modified Library's header files unless such material is
+limited to (i) numerical parameters; (ii) data structure layouts;
+(iii) accessors; and (iv) small macros, templates and inline functions of
+five lines or less in length.
+
+Furthermore, you are not required to apply this additional permission to a
+modified version of the Library.
--- a/32
+++ b/32
@ -160,3 +160,35 @@ v0.8.2
 - Fix integration test cases failing in specific situations
 - Fix build with clang 9.0.1 and libcxx
 - Fix potential data race in Proxy's condition variable
+
+v0.8.3
+- Fix build with gcc 8.3
+- Address a few inconsistencies and make code more idiomatic
+- Clean up integration tests
+- Remove non-virtual-dtor warnings by making classes final
+- Update CMake configuration flag names
+- Fix unused variable warning for release builds
+- Introduce CI workflow based on GitHub Actions
+
+v0.8.4
+- fix issue #145: signals are not filtered by sender
+
+v0.9.0
+- Provide CMake config and PkgConfig files for tools
+- Provide access to D-Bus message in high-level API
+- Add API to set signal destination
+- Add IProxy::getConnection() method
+- Add README and sdbus-c++ tutorial as additional pages in doxydocs
+- Enable default construction of PendingAsyncCall
+- Add API to get message path and message destination
+- Avoid propagating msg unpack exceptions to the event loop
+- Fix race condition in Proxy and Object destructor
+- Fix seg fault in Message::peekType()
+- Add information to documentation about conan recipe
+- Add cpack to build debian packages, split the packages by components
+- Catch sdbus-c++ exceptions flying from Proxy callbacks to libsystemd
+- Add createDefaultBusConnection() method
+- Make resetting loop thread ID exception-safe
+- Support Error parameter in signal handlers
+- Add specific sections for tips and notes in the tutorial
+- A few additional documentation and test updates and improvements
--- a/README.md
+++ b/README.md
@ -1,6 +1,10 @@
 sdbus-c++
 =========

+![ci](https://github.com/Kistler-Group/sdbus-cpp/workflows/CI/badge.svg)
+![license](https://img.shields.io/github/license/Kistler-Group/sdbus-cpp)
+![release](https://img.shields.io/github/v/release/Kistler-Group/sdbus-cpp)
+
 sdbus-c++ is a high-level C++ D-Bus library for Linux designed to provide expressive, easy-to-use API in modern C++. It adds another layer of abstraction on top of sd-bus, a nice, fresh C D-Bus implementation by systemd.

 sdbus-c++ has been written primarily as a replacement of dbus-c++, which currently suffers from a number of (unresolved) bugs, concurrency issues and inherent design complexities and limitations. sdbus-c++ has learned from dbus-c++ and has chosen a different path, a path of simple yet powerful design that is intuitive and friendly to the user and inherently free of those bugs.
@ -16,8 +20,8 @@ The library is built using CMake:
 $ mkdir build
 $ cd build
 $ cmake .. -DCMAKE_BUILD_TYPE=Release ${OTHER_CONFIG_FLAGS}
-$ make
-$ sudo make install
+$ cmake --build .
+$ sudo cmake --build . --target install
 ```

 ### CMake configuration flags for sdbus-c++
@ -32,17 +36,17 @@ $ sudo make install

    * `BUILD_DOXYGEN_DOC` [boolean]

-      Option for building Doxygen documentation of sdbus-c++ API. If enabled, the documentation must still be built explicitly through `make doc`. Default value: `OFF`. Use `-DBUILD_DOXYGEN_DOC=OFF` to disable searching for Doxygen and building Doxygen documentation of sdbus-c++ API.
+      Option for building Doxygen documentation of sdbus-c++ API. If enabled, the documentation must still be built explicitly through `cmake --build . --target doc`. Default value: `OFF`. Use `-DBUILD_DOXYGEN_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:
+  Option for building sdbus-c++ unit and integration tests, invokable by `cmake --build . --target test` (Note: before invoking `cmake --build . --target test`, make sure you copy `tests/integrationtests/files/org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory). 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]
+    * `ENABLE_PERF_TESTS` [boolean]

      Option for building sdbus-c++ performance tests. Default value: `OFF`.

-    * `BUILD_STRESS_TESTS` [boolean]
+    * `ENABLE_STRESS_TESTS` [boolean]

      Option for building sdbus-c++ stress tests. Default value: `OFF`.

@ -62,6 +66,10 @@ $ sudo make install

  This is a CMake-builtin option. Set to `Release` to build sdbus-c++ for production use. Set to `Debug` if you want to help further develop (and debug) the library :)

+* `BUILD_SHARED_LIBS` [boolean]
+
+  This is a global CMake flag, promoted in sdbus-c++ project to a CMake option. Use this to control whether sdbus-c++ is built as either a shared or static library. Default value: `ON`.
+
 Dependencies
 ------------

@ -69,11 +77,12 @@ Dependencies
 * `libsystemd` - systemd library containing sd-bus implementation. This library is part of systemd. Systemd at least v236 is needed. (In case you have a non-systemd environment, don't worry, see [Solving libsystemd dependency](docs/using-sdbus-c++.md#solving-libsystemd-dependency) for more information.)
 * `googletest` - google unit testing framework, only necessary when building tests, will be downloaded and built automatically.
 * `pkgconfig` - required for sdbus-c++ to be able to find some dependency packages.
+* `expat` - necessary when building xml2cpp code generator (`BUILD_CODE_GEN` option is ON).

 Licensing
 ---------

-The library is distributed under LGPLv2.1 license.
+The library is distributed under LGPLv2.1 license, with a specific exception for macro/template/inline code in library header files.

 References/documentation
 ------------------------
--- a/cmake/LibsystemdExternalProject.cmake
+++ b/cmake/LibsystemdExternalProject.cmake
@ -1,5 +1,6 @@
 find_program(MESON meson)
 find_program(NINJA ninja)
+find_program(GPERF gperf)

 if((NOT MESON) OR (NOT NINJA))
    message(FATAL_ERROR "Meson and Ninja are required to build libsystemd")
@ -30,20 +31,23 @@ if(LIBSYSTEMD_VERSION GREATER "240")
    set(BUILD_VERSION_H ${NINJA} -C <BINARY_DIR> version.h)
 endif()

+message(STATUS "Building with embedded libsystemd v${LIBSYSTEMD_VERSION}")
+
 include(ExternalProject)
 ExternalProject_Add(LibsystemdBuildProject
                    PREFIX libsystemd-v${LIBSYSTEMD_VERSION}
-                    GIT_REPOSITORY    https://github.com/systemd/systemd.git
-                    GIT_TAG           v${LIBSYSTEMD_VERSION}
+                    GIT_REPOSITORY    https://github.com/systemd/systemd-stable.git
+                    GIT_TAG           v${LIBSYSTEMD_VERSION}-stable
                    GIT_SHALLOW       1
                    UPDATE_COMMAND    ""
                    CONFIGURE_COMMAND ${CMAKE_COMMAND} -E remove <BINARY_DIR>/*
-                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic <SOURCE_DIR> <BINARY_DIR>
+                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic -Dselinux=false <SOURCE_DIR> <BINARY_DIR>
                    BUILD_COMMAND     ${BUILD_VERSION_H}
                          COMMAND     ${NINJA} -C <BINARY_DIR> libsystemd.a
                    BUILD_ALWAYS      0
                    INSTALL_COMMAND   ${CMAKE_COMMAND} -E copy_directory <SOURCE_DIR>/src/systemd <INSTALL_DIR>/include/systemd
-                    LOG_DOWNLOAD 1 LOG_UPDATE 1 LOG_CONFIGURE 1 LOG_BUILD 1)
+                    LOG_DOWNLOAD 1 LOG_UPDATE 1 LOG_CONFIGURE 1 LOG_BUILD 1
+                    BUILD_BYPRODUCTS <BINARY_DIR>/libsystemd.a)

 ExternalProject_Get_property(LibsystemdBuildProject SOURCE_DIR)
 ExternalProject_Get_property(LibsystemdBuildProject BINARY_DIR)
--- a/docs/CMakeLists.txt
+++ b/docs/CMakeLists.txt
@ -12,7 +12,11 @@ if(BUILD_DOXYGEN_DOC)
            COMMENT "Generating API documentation with Doxygen"
            VERBATIM)

-        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+        # workaround bug https://github.com/doxygen/doxygen/pull/6787
+        add_custom_command(TARGET doc POST_BUILD
+          COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/sdbus-c++-class-diagram.png ${CMAKE_CURRENT_BINARY_DIR}/html/.)
+        
+        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL COMPONENT doc)
    else()
        message(WARNING "Documentation enabled, but Doxygen cannot be found")
    endif()
@ -22,4 +26,4 @@ install(FILES sdbus-c++-class-diagram.png
              sdbus-c++-class-diagram.uml
              systemd-dbus-config.md
              using-sdbus-c++.md
-        DESTINATION ${CMAKE_INSTALL_DOCDIR})
+        DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT doc)
--- a/docs/Doxyfile.in
+++ b/docs/Doxyfile.in
@ -790,7 +790,9 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.

-INPUT                  = "@CMAKE_CURRENT_SOURCE_DIR@/../include"
+INPUT                  = "@CMAKE_CURRENT_SOURCE_DIR@/../include" \
+                          @CMAKE_CURRENT_SOURCE_DIR@/../README.md \
+                          @CMAKE_CURRENT_SOURCE_DIR@/using-sdbus-c++.md

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@ -982,7 +984,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.

-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = README.md

 #---------------------------------------------------------------------------
 # Configuration options related to source browsing
--- a/docs/using-sdbus-c++.md
+++ b/docs/using-sdbus-c++.md
@ -51,7 +51,23 @@ PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.6],,
 )
 ```

-Note: sdbus-c++ library uses a number of modern C++17 features. Please make certain you have a recent compiler (gcc >= 7, clang >= 6).
+> **_Note_:** sdbus-c++ library uses a number of modern C++17 features. Please make certain you have a recent compiler (gcc >= 7, clang >= 6).
+
+If you intend to use stub generator (explained later) in your project to generate interface headers from XML, you can integrate that too with CMake or `pkg-config`:
+
+```cmake
+# First, find sdbus-c++-tools
+find_package(sdbus-c++-tools REQUIRED)
+
+# Use the sdbus-c++-xml2cpp in SDBusCpp namespace to generate the headers
+add_custom_command(
+    OUTPUT myproject-client-glue.h myproject-server-glue.h
+    COMMAND SDBusCpp::sdbus-c++-xml2cpp ${PROJECT_SOURCE_DIR}/dbus/myproject-bindings.xml
+        --proxy=myproject-client-glue.h --adaptor=myproject-server-glue.h
+    DEPENDS dbus/myproject-bindings.xml
+    COMMENT "Generating D-Bus interfaces for ${PROJECT_NAME}."
+)
+```

 Solving libsystemd dependency
 -----------------------------
@ -82,7 +98,7 @@ $ ninja libsystemd.so.0.26.0  # or another version number depending which system

 ### Building and distributing libsystemd as part of sdbus-c++

-sdbus-c++ provides `BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd enviroments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes `meson`, `ninja`, `git` programs and mainly libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Also when distributing, make sure these dependency libraries are installed on the production machine.
+sdbus-c++ provides `BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd enviroments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes, among others, `meson`, `ninja`, `git`, `gperf`, and -- primarily -- libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Be sure to check out the systemd documentation for the  Also, when distributing, make sure these dependency libraries are installed on the production machine.

 You may additionally set the `LIBSYSTEMD_VERSION` configuration flag to fine-tune the version of systemd to be taken in. (The default value is 242).

@ -96,10 +112,26 @@ There are Yocto recipes for sdbus-c++ available in the [`meta-oe`](https://githu
  * One for sdbus-c++ itself. It detects whether systemd feature is turned on in the poky linux configuration. If so, it simply depends on systemd and makes use of libsystemd shared library available in the target system. Otherwise it automatically downloads and builds libsystemd static library and links it into the sdbus-c++ shared library. The recipe also supports ptest.
  * One for sdbus-c++ native tools, namely sdbus-c++ code generator to generate C++ adaptor and proxy binding classes.

-Tip: If you get `ERROR: Program or command 'getent' not found or not executable` when building sdbus-c++ in Yocto, please make sure you've added `getent` to `HOSTTOOLS`. For example, you can add `HOSTTOOLS_NONFATAL += "getent"` into your local.conf file.
+> **_Tip_:** If you get `ERROR: Program or command 'getent' not found or not executable` when building sdbus-c++ in Yocto, please make sure you've added `getent` to `HOSTTOOLS`. For example, you can add `HOSTTOOLS_NONFATAL += "getent"` into your local.conf file.
+
+### Conan
+
+sdbus-c++ recipe is available in ConanCenter repository as [`sdbus-cpp`](https://conan.io/center/sdbus-cpp).

 Contributors willing to help with bringing sdbus-c++ to other popular package systems are welcome.

+Verifying sdbus-c++
+-------------------
+
+You can build and run sdbus-c++ unit and integration tests to verify sdbus-c++ build:
+
+```
+$ cd build
+$ cmake .. -DBUILD_TESTS=ON
+$ sudo cp ../tests/integrationtests/files/org.sdbuscpp.integrationtests.conf /etc/dbus-1/system.d/
+$ cmake --build . --target test
+```
+
 Header files and namespaces
 ---------------------------

@ -189,6 +221,8 @@ Let's have an object `/org/sdbuscpp/concatenator` that implements the `org.sdbus

 In the following sections, we will elaborate on the ways of implementing such an object on both the server and the client side.

+> **_Note_:** In order to be able to call methods of your system bus-based D-Bus service, a D-Bus security policy file has to be put in place for that service. See [dbus-daemon documentation](https://dbus.freedesktop.org/doc/dbus-daemon.1.html), sections *INTEGRATING SYSTEM SERVICES* and *CONFIGURATION FILE*. As an example, you may look at the [policy file for sdbus-c++ integration tests](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf).
+
 Implementing the Concatenator example using basic sdbus-c++ API layer
 ---------------------------------------------------------------------

@ -207,7 +241,7 @@ This is how a simple Concatenator service implemented upon the basic sdbus-c++ A
 #include <vector>
 #include <string>

-// Yeah, global variable is ugly, but this is just an example and we want to access 
+// Yeah, global variable is ugly, but this is just an example and we want to access
 // the concatenator instance from within the concatenate method handler to be able
 // to emit signals.
 sdbus::IObject* g_concatenator{};
@ -217,26 +251,26 @@ void concatenate(sdbus::MethodCall call)
    // Deserialize the collection of numbers from the message
    std::vector<int> numbers;
    call >> numbers;
-    
+
    // Deserialize separator from the message
    std::string separator;
    call >> separator;
-    
+
    // Return error if there are no numbers in the collection
    if (numbers.empty())
        throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-    
+
    std::string result;
    for (auto number : numbers)
    {
        result += (result.empty() ? std::string() : separator) + std::to_string(number);
    }
-    
+
    // 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";
    auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
@ -253,9 +287,9 @@ int main(int argc, char *argv[])
    // Create concatenator D-Bus object.
    const char* objectPath = "/org/sdbuscpp/concatenator";
    auto concatenator = sdbus::createObject(*connection, objectPath);
-    
+
    g_concatenator = concatenator.get();
-    
+
    // Register D-Bus methods and signals on the concatenator object, and exports the object.
    const char* interfaceName = "org.sdbuscpp.Concatenator";
    concatenator->registerMethod(interfaceName, "concatenate", "ais", "s", &concatenate);
@ -286,7 +320,7 @@ void onConcatenated(sdbus::Signal& signal)
 {
    std::string concatenatedString;
    signal >> concatenatedString;
-    
+
    std::cout << "Received signal with concatenated string " << concatenatedString << std::endl;
 }

@ -298,15 +332,15 @@ int main(int argc, char *argv[])
    const char* destinationName = "org.sdbuscpp.concatenator";
    const char* objectPath = "/org/sdbuscpp/concatenator";
    auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
-    
+
    // Let's subscribe for the 'concatenated' signals
    const char* interfaceName = "org.sdbuscpp.Concatenator";
    concatenatorProxy->registerSignalHandler(interfaceName, "concatenated", &onConcatenated);
    concatenatorProxy->finishRegistration();
-    
+
    std::vector<int> numbers = {1, 2, 3};
    std::string separator = ":";
-    
+
    // Invoke concatenate on given interface of the object
    {
        auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@ -316,7 +350,7 @@ int main(int argc, char *argv[])
        reply >> result;
        assert(result == "1:2:3");
    }
-    
+
    // Invoke concatenate again, this time with no numbers and we shall get an error
    {
        auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@ -331,10 +365,10 @@ int main(int argc, char *argv[])
            std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
        }
    }
-    
+
    // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
    sleep(1);
-    
+
    return 0;
 }
 ```
@ -378,9 +412,9 @@ Of course, at any time before or after running the event loop on the connection,
 On the **client** side we have more options when creating D-Bus proxies. That corresponds to three overloads of the `createProxy()` factory:

  * In case we (the application) already maintain a D-Bus connection, e.g. because we a D-Bus service anyway, the simple and typical approach is to create proxy upon that connection. The proxy will share the connection with others. So we pass connection reference to proxy factory. With this approach we must of course ensure that the connection exists as long as the proxy exists.
-  
+
  * Or -- and this is typical when we have a simple D-Bus client application -- we have another option: we let proxy maintain its own connection (and an associated thread):
-  
+
    * We either create the connection ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This had the advantage that we may choose the type of connection (system, session, remote).

    * Or we don't bother about any connection at all when creating a proxy (the factory overload with no connection parameter). Under the hood, the proxy creates its own *system bus* connection, creates a separate thread and runs an event loop in it. This is **the simplest approach** for non-complex D-Bus clients. For more complex ones, with big number of proxies, this hurts scalability but may improve concurrency (see discussion higher above), so we should make a conscious choice.
@ -403,7 +437,7 @@ Thus, in the end of the day, the code written using the convenience API is:
  - significantly shorter,
  - almost as fast as one written using the basic API layer.

-The code written using this layer expresses in a declarative way *what* it does, rather then *how*. Let's look at code samples.
+The code written using this layer expresses in a declarative way *what* it does, rather than *how*. Let's look at code samples.

 ### Server side

@ -412,30 +446,6 @@ The code written using this layer expresses in a declarative way *what* it does,
 #include <vector>
 #include <string>

-// Yeah, global variable is ugly, but this is just an example and we want to access 
-// the concatenator instance from within the concatenate method handler to be able
-// to emit signals.
-sdbus::IObject* g_concatenator{};
-
-std::string concatenate(const std::vector<int> numbers, const std::string& separator)
-{
-    // Return error if there are no numbers in the collection
-    if (numbers.empty())
-        throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-    
-    std::string result;
-    for (auto number : numbers)
-    {
-        result += (result.empty() ? std::string() : separator) + std::to_string(number);
-    }
-    
-    // Emit 'concatenated' signal
-    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    g_concatenator->emitSignal("concatenated").onInterface(interfaceName).withArguments(result);
-    
-    return result;
-}
-
 int main(int argc, char *argv[])
 {
    // Create D-Bus connection to the system bus and requests name on it.
@ -446,11 +456,28 @@ int main(int argc, char *argv[])
    const char* objectPath = "/org/sdbuscpp/concatenator";
    auto concatenator = sdbus::createObject(*connection, objectPath);
    
-    g_concatenator = concatenator.get();
-    
+    auto concatenate = [&concatenator](const std::vector<int> numbers, const std::string& separator)
+    {
+        // Return error if there are no numbers in the collection
+        if (numbers.empty())
+            throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
+
+        std::string result;
+        for (auto number : numbers)
+        {
+            result += (result.empty() ? std::string() : separator) + std::to_string(number);
+        }
+
+        // Emit 'concatenated' signal
+        const char* interfaceName = "org.sdbuscpp.Concatenator";
+        concatenator->emitSignal("concatenated").onInterface(interfaceName).withArguments(result);
+
+        return result;
+    };
+
    // Register D-Bus methods and signals on the concatenator object, and exports the object.
    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    concatenator->registerMethod("concatenate").onInterface(interfaceName).implementedAs(&concatenate);
+    concatenator->registerMethod("concatenate").onInterface(interfaceName).implementedAs(std::move(concatenate));
    concatenator->registerSignal("concatenated").onInterface(interfaceName).withParameters<std::string>();
    concatenator->finishRegistration();

@ -479,22 +506,22 @@ int main(int argc, char *argv[])
    const char* destinationName = "org.sdbuscpp.concatenator";
    const char* objectPath = "/org/sdbuscpp/concatenator";
    auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
-    
+
    // Let's subscribe for the 'concatenated' signals
    const char* interfaceName = "org.sdbuscpp.Concatenator";
    concatenatorProxy->uponSignal("concatenated").onInterface(interfaceName).call([](const std::string& str){ onConcatenated(str); });
    concatenatorProxy->finishRegistration();
-    
+
    std::vector<int> numbers = {1, 2, 3};
    std::string separator = ":";
-    
+
    // Invoke concatenate on given interface of the object
    {
        std::string concatenatedString;
        concatenatorProxy->callMethod("concatenate").onInterface(interfaceName).withArguments(numbers, separator).storeResultsTo(concatenatedString);
        assert(concatenatedString == "1:2:3");
    }
-    
+
    // Invoke concatenate again, this time with no numbers and we shall get an error
    {
        try
@ -507,10 +534,10 @@ int main(int argc, char *argv[])
            std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
        }
    }
-    
+
    // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
    sleep(1);
-    
+
    return 0;
 }
 ```
@ -519,11 +546,49 @@ When registering methods, calling methods or emitting signals, multiple lines of

 sdbus-c++ users shall prefer the convenience API to the lower level, basic API. When feasible, using generated adaptor and proxy stubs is even better. These stubs provide yet another, higher API level built on top of the convenience API. They are described in the following section.

-Tip: When registering a D-Bus object, we can additionally provide names of input and output parameters of its methods and names of parameters of its signals. When the object is introspected, these names are listed in the resulting introspection XML, which improves the description of object's interfaces:
+> **_Note_:** By default, signal callback handlers are not invoked (i.e., the signal is silently dropped) if there is a signal signature mismatch. If clients want to be informed of such situations, they can prepend `const sdbus::Error*` parameter to their signal callback handler's parameter list. This argument will be `nullptr` in normal cases, and will provide access to the corresponding `sdbus::Error` object in case of deserialization failures. An example of a handler with the signature (`int`) different from the real signal contents (`string`):
+> ```c++
+>     void onConcatenated(const sdbus::Error* e, int wrongParameter)
+>     {
+>         assert(e);
+>         assert(e->getMessage() == "Failed to deserialize a int32 value");
+>     }
+> ```
+
+> **_Tip_:** When registering a D-Bus object, we can additionally provide names of input and output parameters of its methods and names of parameters of its signals. When the object is introspected, these names are listed in the resulting introspection XML, which improves the description of object's interfaces:
+> ```c++
+>    concatenator->registerMethod("concatenate")
+>                 .onInterface(interfaceName)
+>                 .withInputParamNames("numbers", "separator")
+>                 .withOutputParamNames("concatenatedString")
+>                 .implementedAs(&concatenate);
+>    concatenator->registerSignal("concatenated")
+>                 .onInterface(interfaceName)
+>                 .withParameters<std::string>("concatenatedString");
+> ```
+
+### Accessing a corresponding D-Bus message
+
+The convenience API hides away the level of D-Bus messages. But the messages carry with them additional information that may need in some implementations. For example, a name of a method call sender; or info on credentials. Is there a way to access a corresponding D-Bus message in a high-level callback handler?
+
+Yes, there is -- we can access the corresponding D-Bus message in:
+
+* method implementation callback handlers (server side),
+* property set implementation callback handlers (server side),
+* signal callback handlers (client side).
+
+Both `IObject` and `IProxy` provide the `getCurrentlyProcessedMessage()` method. This method is meant to be called from within a callback handler. It returns a pointer to the corresponding D-Bus message that caused invocation of the handler. The pointer is only valid (dereferencable) as long as the flow of execution does not leave the callback handler. When called from other contexts/threads, the pointer may be both zero or non-zero, and its dereferencing is undefined behavior.
+
+An excerpt of the above example of concatenator modified to print out a name of the sender of method call:

 ```c++
-    concatenator->registerMethod("concatenate").onInterface(interfaceName).withInputParamNames("numbers", "separator").withOutputParamNames("concatenatedString").implementedAs(&concatenate);
-    concatenator->registerSignal("concatenated").onInterface(interfaceName).withParameters<std::string>("concatenatedString");
+    auto concatenate = [&concatenator](const std::vector<int> numbers, const std::string& separator)
+    {
+        const auto* methodCallMsg = concatenator->getCurrentlyProcessedMessage();
+        std::cout << "Sender of this method call: " << methodCallMsg.getSender() << std::endl;
+
+        /*...*/
+    };
 ```

 Implementing the Concatenator example using sdbus-c++-generated stubs
@ -688,7 +753,7 @@ class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator
 {
 public:
    Concatenator(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::AdaptorInterfaces(connection, std::move(objectPath))
+        : AdaptorInterfaces(connection, std::move(objectPath))
    {
        registerAdaptor();
    }
@ -704,23 +769,25 @@ protected:
        // Return error if there are no numbers in the collection
        if (numbers.empty())
            throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-        
+
        // Concatenate the numbers
        std::string result;
        for (auto number : numbers)
        {
            result += (result.empty() ? std::string() : separator) + std::to_string(number);
        }
-        
+
        // Emit the 'concatenated' signal with the resulting string
        emitConcatenated(result);
-        
+
        // Return the resulting string
        return result;
    }
 };
 ```

+> **_Tip_:** By inheriting from `sdbus::AdaptorInterfaces`, we get access to the protected `getObject()` method. We can call this method inside our adaptor implementation class to access the underlying `IObject` object.
+
 That's it. We now have an implementation of a D-Bus object implementing `org.sdbuscpp.Concatenator` interface. Let's now create a service publishing the object.

 ```cpp
@ -765,12 +832,12 @@ class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::Concatena
 {
 public:
    ConcatenatorProxy(std::string destination, std::string objectPath)
-        : sdbus::ProxyInterfaces(std::move(destination), std::move(objectPath))
+        : ProxyInterfaces(std::move(destination), std::move(objectPath))
    {
        registerProxy();
    }

-    ~Concatenator()
+    ~ConcatenatorProxy()
    {
        unregisterProxy();
    }
@ -783,6 +850,8 @@ protected:
 };
 ```

+> **_Tip_:** By inheriting from `sdbus::ProxyInterfaces`, we get access to the protected `getProxy()` method. We can call this method inside our proxy implementation class to access the underlying `IProxy` object.
+
 In the above example, a proxy is created that creates and maintains its own system bus connection. However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used by all interfaces listed in the `ProxyInterfaces` template parameter list.

 Note however that there are multiple `ProxyInterfaces` constructor overloads, and they differ in how the proxy behaves towards the D-Bus connection. These overloads precisely map the `sdbus::createProxy` overloads, as they are actually implemented on top of them. See [Proxy and D-Bus connection](#Proxy-and-D-Bus-connection) for more info. We can even create a `IProxy` instance on our own, and inject it into our proxy class -- there is a constructor overload for it in `ProxyInterfaces`. This can help if we need to provide mocked implementations in our unit tests.
@ -802,11 +871,11 @@ int main(int argc, char *argv[])

    std::vector<int> numbers = {1, 2, 3};
    std::string separator = ":";
-    
+
    // Invoke concatenate with some numbers
    auto concatenatedString = concatenatorProxy.concatenate(numbers, separator);
    assert(concatenatedString == "1:2:3");
-    
+
    // Invoke concatenate again, this time with no numbers and we shall get an error
    try
    {
@ -817,14 +886,35 @@ int main(int argc, char *argv[])
    {
        std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
    }
-    
+
    // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
    sleep(1);
-    
+
    return 0;
 }
 ```

+### Accessing a corresponding D-Bus message
+
+Simply combine `getObject()`/`getProxy()` and `getCurrentlyProcessedMessage()` methods. Both were already discussed above. An example:
+
+```c++
+class Concatenator : public sdbus::AdaptorInterfaces</*...*/>
+{
+public:
+    /*...*/
+
+protected:
+    std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator) override
+    {
+        const auto* methodCallMsg = getObject().getCurrentlyProcessedMessage();
+        std::cout << "Sender of this method call: " << methodCallMsg.getSender() << std::endl;
+
+        /*...*/
+    }
+};
+```
+
 Asynchronous server-side methods
 --------------------------------

@ -840,11 +930,11 @@ void concatenate(sdbus::MethodCall call)
    // Deserialize the collection of numbers from the message
    std::vector<int> numbers;
    call >> numbers;
-    
+
    // Deserialize separator from the message
    std::string separator;
    call >> separator;
-    
+
    // Launch a thread for async execution...
    std::thread([numbers = std::move(numbers), separator = std::move(separator), call = std::move(call)]()
    {
@ -856,18 +946,18 @@ void concatenate(sdbus::MethodCall call)
            reply.send();
            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
        auto reply = call.createReply();
        reply << result;
        reply.send();
-        
+
        // Emit 'concatenated' signal (creating and emitting signals is thread-safe)
        const char* interfaceName = "org.sdbuscpp.Concatenator";
        auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
@ -905,16 +995,16 @@ void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbe
            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->emitConcatenated(result);
    }).detach();
@ -962,7 +1052,7 @@ Considering the Concatenator example based on lower-level API, if we wanted to c
 int main(int argc, char *argv[])
 {
    /* ...  */
-    
+
    auto callback = [](MethodReply& reply, const sdbus::Error* error)
    {
        if (error == nullptr) // No error
@ -984,7 +1074,7 @@ int main(int argc, char *argv[])
        concatenatorProxy->callMethod(method, callback);
        // When the reply comes, we shall get "Got concatenate result 1:2:3" on the standard output
    }
-    
+
    // Invoke concatenate again, this time with no numbers and we shall get an error
    {
        auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@ -1009,7 +1099,7 @@ On the convenience API level, the call statement starts with `callMethodAsync()`
 int main(int argc, char *argv[])
 {
    /* ...  */
-    
+
    auto callback = [](const sdbus::Error* error, const std::string& concatenatedString)
    {
        if (error == nullptr) // No error
@ -1036,7 +1126,7 @@ int main(int argc, char *argv[])
 }
 ```

-When the `Error` pointer is zero, it means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred during the call (and subsequent arguments are simply default-constructed). Error name and message can then be read out by the client from `Error` instance. 
+When the `Error` pointer is zero, it means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred during the call (and subsequent arguments are simply default-constructed). Error name and message can then be read out by the client from `Error` instance.

 ### Marking client-side async methods in the IDL

@ -1061,7 +1151,7 @@ sdbus-c++ stub generator can generate stub code for client-side async methods. W
 ```

 For each client-side async method, a corresponding `on<MethodName>Reply` pure virtual function, where <MethodName> is capitalized D-Bus method name, is generated in the generated proxy class. This function is the callback invoked when the D-Bus method reply arrives, and must be provided a body by overriding it in the implementation class.
-    
+
 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](/tests/stresstests).
@ -1156,12 +1246,14 @@ sdbus-c++ provides support for standard D-Bus interfaces. These are:

 The implementation of methods that these interfaces define is provided by the library. `Peer`, `Introspectable` and `Properties` are automatically part of interfaces of every D-Bus object. `ObjectManager` is not automatically present and has to be enabled by the client when using `IObject` API. When using generated `ObjectManager_adaptor`, `ObjectManager` is enabled automatically in its constructor.

-Pre-generated `*_proxy` and `*_adaptor` convenience classes for these standard interfaces are located in `sdbus-c++/StandardInterfaces.h`. We add them simply as additional parameters of `sdbus::ProxyInterfaces` or `sdbus::AdaptorInterfaces` class template, and our proxy or adaptor class inherits convenience functions from those interface classes.
+Pre-generated `*_proxy` and `*_adaptor` convenience classes for these standard interfaces are located in `sdbus-c++/StandardInterfaces.h`. To use them, we simply have to add them as additional parameters of `sdbus::ProxyInterfaces` or `sdbus::AdaptorInterfaces` class template, and our proxy or adaptor class inherits convenience functions from those interface classes.

-For example, to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface, we just issue `emitPropertiesChangedSignal` function of our adaptor object.
+For example, for our `Concatenator` example above in this tutorial, we may want to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface. First, we must augment our `Concatenator` class to also inherit from `org.freedesktop.DBus.Properties` interface: `class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator_adaptor, sdbus::Properties_adaptor> {...};`, and then we just issue `emitPropertiesChangedSignal` function of our adaptor object.

 Note that signals of afore-mentioned standard D-Bus interfaces are not emitted by the library automatically. It's clients who are supposed to emit them.

+Working examples of using standard D-Bus interfaces can be found in [sdbus-c++ integration tests](/tests/integrationtests/DBusStandardInterfacesTests.cpp).
+
 Conclusion
 ----------

--- a/include/sdbus-c++/AdaptorInterfaces.h
+++ b/include/sdbus-c++/AdaptorInterfaces.h
@ -141,6 +141,7 @@ namespace sdbus {

    protected:
        using base_type = AdaptorInterfaces;
+        ~AdaptorInterfaces() = default;
    };

 }
--- a/include/sdbus-c++/ConvenienceApiClasses.inl
+++ b/include/sdbus-c++/ConvenienceApiClasses.inl
@ -588,7 +588,20 @@ namespace sdbus {

            // Deserialize input arguments from the message into the tuple (if no error occurred).
            if (error == nullptr)
-                reply >> args;
+            {
+                try
+                {
+                    reply >> args;
+                }
+                catch (const Error& e)
+                {
+                    // Catch message unpack exceptions and pass them to the callback
+                    // in the expected manner to avoid propagating them up the call
+                    // stack to the event loop.
+                    sdbus::apply(callback, &e, args);
+                    return;
+                }
+            }

            // Invoke callback with input arguments from the tuple.
            sdbus::apply(callback, error, args);
@ -627,11 +640,34 @@ namespace sdbus {
            // as a storage for the argument values deserialized from the signal message.
            tuple_of_function_input_arg_types_t<_Function> signalArgs;

-            // Deserialize input arguments from the signal message into the tuple
-            signal >> signalArgs;
+            // The signal handler can take pure signal parameters only, or an additional `const Error*` as its first
+            // parameter. In the former case, if the deserialization fails (e.g. due to signature mismatch),
+            // the failure is ignored (and signal simply dropped). In the latter case, the deserialization failure
+            // will be communicated as a non-zero Error pointer to the client's signal handler.
+            if constexpr (has_error_param_v<_Function>)
+            {
+                // Deserialize input arguments from the signal message into the tuple
+                try
+                {
+                    signal >> signalArgs;
+                }
+                catch (const sdbus::Error& e)
+                {
+                    // Invoke callback with error argument and input arguments from the tuple.
+                    sdbus::apply(callback, &e, signalArgs);
+                }

-            // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, signalArgs);
+                // Invoke callback with no error and input arguments from the tuple.
+                sdbus::apply(callback, nullptr, signalArgs);
+            }
+            else
+            {
+                // Deserialize input arguments from the signal message into the tuple
+                signal >> signalArgs;
+
+                // Invoke callback with input arguments from the tuple.
+                sdbus::apply(callback, signalArgs);
+            }
        });
    }

--- a/include/sdbus-c++/IConnection.h
+++ b/include/sdbus-c++/IConnection.h
@ -265,6 +265,27 @@ namespace sdbus {
     */
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);

+    /*!
+     * @brief Creates/opens D-Bus user connection when in a user context,
+     * and a system connection, otherwise.
+     *
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection();
+
+    /*!
+     * @brief Creates/opens D-Bus user connection with a name when in a user
+     * context, and a system connection with a name, otherwise.
+     *
+     * @param[in] name Name to request on the connection after its opening
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name);
+
    /*!
     * @brief Creates/opens D-Bus system connection
     *
--- a/include/sdbus-c++/IObject.h
+++ b/include/sdbus-c++/IObject.h
@ -440,6 +440,22 @@ namespace sdbus {
         * @brief Returns object path of the underlying DBus object
         */
        virtual const std::string& getObjectPath() const = 0;
+
+        /*!
+         * @brief Provides currently processed D-Bus message
+         *
+         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * "Currently processed" means that the registered callback handler(s) for that message
+         * are being invoked. This method is meant to be called from within a callback handler
+         * (e.g. D-Bus method implementation handler). In such a case it is guaranteed to return
+         * a valid pointer to the D-Bus message for which the handler is called. If called from other
+         * contexts/threads, it may return a nonzero pointer or a nullptr, depending on whether a message
+         * was processed at the time of call or not, but the value is nondereferencable, since the pointed-to
+         * message may have gone in the meantime.
+         *
+         * @return A pointer to the currently processed D-Bus message
+         */
+        virtual const Message* getCurrentlyProcessedMessage() const = 0;
    };

    // Out-of-line member definitions
--- a/include/sdbus-c++/IProxy.h
+++ b/include/sdbus-c++/IProxy.h
@ -267,10 +267,33 @@ namespace sdbus {
         */
        [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);

+        /*!
+         * @brief Provides D-Bus connection used by the proxy
+         *
+         * @return Reference to the D-Bus connection
+         */
+        virtual sdbus::IConnection& getConnection() const = 0;
+
        /*!
         * @brief Returns object path of the underlying DBus object
         */
        virtual const std::string& getObjectPath() const = 0;
+
+        /*!
+         * @brief Provides currently processed D-Bus message
+         *
+         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * "Currently processed" means that the registered callback handler(s) for that message
+         * are being invoked. This method is meant to be called from within a callback handler
+         * (e.g. from a D-Bus signal handler, or async method reply handler, etc.). In such a case it is
+         * guaranteed to return a valid pointer to the D-Bus message for which the handler is called.
+         * If called from other contexts/threads, it may return a nonzero pointer or a nullptr, depending
+         * on whether a message was processed at the time of call or not, but the value is nondereferencable,
+         * since the pointed-to message may have gone in the meantime.
+         *
+         * @return A pointer to the currently processed D-Bus message
+         */
+        virtual const Message* getCurrentlyProcessedMessage() const = 0;
    };

    /********************************************//**
@ -286,6 +309,8 @@ namespace sdbus {
    class PendingAsyncCall
    {
    public:
+        PendingAsyncCall() = default;
+
        /*!
         * @brief Cancels the delivery of the pending asynchronous call result
         *
--- a/include/sdbus-c++/Message.h
+++ b/include/sdbus-c++/Message.h
@ -37,6 +37,7 @@
 #include <cstdint>
 #include <cassert>
 #include <functional>
+#include <sys/types.h>

 // Forward declarations
 namespace sdbus {
@ -44,7 +45,7 @@ namespace sdbus {
    class ObjectPath;
    class Signature;
    template <typename... _ValueTypes> class Struct;
-    struct UnixFd;
+    class UnixFd;
    class MethodReply;
    namespace internal {
        class ISdBus;
@ -130,6 +131,8 @@ namespace sdbus {
        std::string getInterfaceName() const;
        std::string getMemberName() const;
        std::string getSender() const;
+        std::string getPath() const;
+        std::string getDestination() const;
        void peekType(std::string& type, std::string& contents) const;
        bool isValid() const;
        bool isEmpty() const;
@ -138,6 +141,14 @@ namespace sdbus {
        void seal();
        void rewind(bool complete);

+        pid_t getCredsPid() const;
+        uid_t getCredsUid() const;
+        uid_t getCredsEuid() const;
+        gid_t getCredsGid() const;
+        gid_t getCredsEgid() const;
+        std::vector<gid_t> getCredsSupplementaryGids() const;
+        std::string getSELinuxContext() const;
+
        class Factory;

    protected:
@ -206,6 +217,7 @@ namespace sdbus {

    public:
        Signal() = default;
+        void setDestination(const std::string& destination);
        void send() const;
    };

--- a/include/sdbus-c++/ProxyInterfaces.h
+++ b/include/sdbus-c++/ProxyInterfaces.h
@ -175,6 +175,7 @@ namespace sdbus {

    protected:
        using base_type = ProxyInterfaces;
+        ~ProxyInterfaces() = default;
    };

 }
--- a/include/sdbus-c++/TypeTraits.h
+++ b/include/sdbus-c++/TypeTraits.h
@ -41,7 +41,7 @@ namespace sdbus {
    template <typename... _ValueTypes> class Struct;
    class ObjectPath;
    class Signature;
-    struct UnixFd;
+    class UnixFd;
    class MethodCall;
    class MethodReply;
    class Signal;
@ -378,12 +378,14 @@ namespace sdbus {
        : public function_traits_base<_ReturnType, _Args...>
    {
        static constexpr bool is_async = false;
+        static constexpr bool has_error_param = false;
    };

    template <typename... _Args>
    struct function_traits<void(const Error*, _Args...)>
        : public function_traits_base<void, _Args...>
    {
+        static constexpr bool has_error_param = true;
    };

    template <typename... _Args, typename... _Results>
@ -443,6 +445,9 @@ namespace sdbus {
    template <class _Function>
    constexpr auto is_async_method_v = function_traits<_Function>::is_async;

+    template <class _Function>
+    constexpr auto has_error_param_v = function_traits<_Function>::has_error_param;
+
    template <typename _FunctionType>
    using function_arguments_t = typename function_traits<_FunctionType>::arguments_type;

--- a/include/sdbus-c++/Types.h
+++ b/include/sdbus-c++/Types.h
@ -154,6 +154,8 @@ namespace sdbus {
    public:
        using std::string::string;
        ObjectPath() = default; // Fixes gcc 6.3 error (default c-tor is not imported in above using declaration)
+        ObjectPath(const ObjectPath&) = default; // Fixes gcc 8.3 error (deleted copy constructor)
+        ObjectPath& operator = (const ObjectPath&) = default; // Fixes gcc 8.3 error (deleted copy assignment)
        ObjectPath(std::string path)
            : std::string(std::move(path))
        {}
@ -171,6 +173,8 @@ namespace sdbus {
    public:
        using std::string::string;
        Signature() = default; // Fixes gcc 6.3 error (default c-tor is not imported in above using declaration)
+        Signature(const Signature&) = default; // Fixes gcc 8.3 error (deleted copy constructor)
+        Signature& operator = (const Signature&) = default; // Fixes gcc 8.3 error (deleted copy assignment)
        Signature(std::string path)
            : std::string(std::move(path))
        {}
--- a/src/Connection.cpp
+++ b/src/Connection.cpp
@ -44,6 +44,11 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& bu
    assert(iface_ != nullptr);
 }

+Connection::Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t)
+    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open(bus); })
+{
+}
+
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t)
    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open_system(bus); })
 {
@ -87,6 +92,7 @@ std::string Connection::getUniqueName() const
 void Connection::enterEventLoop()
 {
    loopThreadId_ = std::this_thread::get_id();
+    SCOPE_EXIT{ loopThreadId_ = std::thread::id{}; };

    std::lock_guard guard(loopMutex_);

@ -100,8 +106,6 @@ void Connection::enterEventLoop()
        if (!success)
            break; // Exit I/O event loop
    }
-
-    loopThreadId_ = std::thread::id{};
 }

 void Connection::enterEventLoopAsync()
@ -289,7 +293,8 @@ void Connection::emitInterfacesRemovedSignal( const std::string& objectPath
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesRemoved signal", -r);
 }

-SlotPtr Connection::registerSignalHandler( const std::string& objectPath
+SlotPtr Connection::registerSignalHandler( const std::string& sender
+                                         , const std::string& objectPath
                                         , const std::string& interfaceName
                                         , const std::string& signalName
                                         , sd_bus_message_handler_t callback
@ -297,7 +302,10 @@ SlotPtr Connection::registerSignalHandler( const std::string& objectPath
 {
    sd_bus_slot *slot{};

-    auto filter = composeSignalMatchFilter(objectPath, interfaceName, signalName);
+    // Alternatively to our own composeSignalMatchFilter() implementation, we could use sd_bus_match_signal() from
+    // https://www.freedesktop.org/software/systemd/man/sd_bus_add_match.html .
+    // But this would require libsystemd v237 or higher.
+    auto filter = composeSignalMatchFilter(sender, objectPath, interfaceName, signalName);
    auto r = iface_->sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to register signal handler", -r);
@ -393,9 +401,7 @@ bool Connection::processPendingRequest()

 bool Connection::waitForNextRequest()
 {
-    auto bus = bus_.get();
-
-    assert(bus != nullptr);
+    assert(bus_ != nullptr);
    assert(loopExitFd_.fd != 0);

    auto sdbusPollData = getEventLoopPollData();
@ -419,13 +425,15 @@ bool Connection::waitForNextRequest()
    return true;
 }

-std::string Connection::composeSignalMatchFilter( const std::string& objectPath
-                                                , const std::string& interfaceName
-                                                , const std::string& signalName )
+    std::string Connection::composeSignalMatchFilter(const std::string &sender,
+                                                     const std::string &objectPath,
+                                                     const std::string &interfaceName,
+                                                     const std::string &signalName)
 {
    std::string filter;

    filter += "type='signal',";
+    filter += "sender='" + sender + "',";
    filter += "interface='" + interfaceName + "',";
    filter += "member='" + signalName + "',";
    filter += "path='" + objectPath + "'";
@ -480,10 +488,23 @@ std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
    return createSystemBusConnection(name);
 }

+std::unique_ptr<sdbus::IConnection> createDefaultBusConnection()
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    constexpr sdbus::internal::Connection::default_bus_t default_bus;
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), default_bus);
+}
+
+std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name)
+{
+    auto conn = createDefaultBusConnection();
+    conn->requestName(name);
+    return conn;
+}
+
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    assert(interface != nullptr);
    constexpr sdbus::internal::Connection::system_bus_t system_bus;
    return std::make_unique<sdbus::internal::Connection>(std::move(interface), system_bus);
 }
@ -498,7 +519,6 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string&
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    assert(interface != nullptr);
    constexpr sdbus::internal::Connection::session_bus_t session_bus;
    return std::make_unique<sdbus::internal::Connection>(std::move(interface), session_bus);
 }
@ -513,7 +533,6 @@ std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string
 std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host)
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    assert(interface != nullptr);
    constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
    return std::make_unique<sdbus::internal::Connection>(std::move(interface), remote_system_bus, host);
 }
--- a/src/Connection.h
+++ b/src/Connection.h
@ -48,10 +48,12 @@ namespace sdbus::internal {
    {
    public:
        // Bus type tags
+        struct default_bus_t{};
        struct system_bus_t{};
        struct session_bus_t{};
        struct remote_system_bus_t{};

+        Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t);
        Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t);
        Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t);
        Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host);
@ -99,7 +101,8 @@ namespace sdbus::internal {
        void emitInterfacesRemovedSignal( const std::string& objectPath
                                        , const std::vector<std::string>& interfaces ) override;

-        SlotPtr registerSignalHandler( const std::string& objectPath
+        SlotPtr registerSignalHandler( const std::string& sender
+                                     , const std::string& objectPath
                                     , const std::string& interfaceName
                                     , const std::string& signalName
                                     , sd_bus_message_handler_t callback
@ -115,9 +118,9 @@ namespace sdbus::internal {
        BusPtr openBus(const std::function<int(sd_bus**)>& busFactory);
        void finishHandshake(sd_bus* bus);
        bool waitForNextRequest();
-        static std::string composeSignalMatchFilter( const std::string& objectPath
-                                                   , const std::string& interfaceName
-                                                   , const std::string& signalName );
+        static std::string composeSignalMatchFilter(const std::string &sender, const std::string &objectPath,
+                                                    const std::string &interfaceName,
+                                                    const std::string &signalName);
        void notifyEventLoopToExit();
        void clearExitNotification();
        void joinWithEventLoop();
--- a/src/IConnection.h
+++ b/src/IConnection.h
@ -82,7 +82,8 @@ namespace sdbus::internal {

        [[nodiscard]] virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;

-        [[nodiscard]] virtual SlotPtr registerSignalHandler( const std::string& objectPath
+        [[nodiscard]] virtual SlotPtr registerSignalHandler( const std::string& sender
+                                                           , const std::string& objectPath
                                                           , const std::string& interfaceName
                                                           , const std::string& signalName
                                                           , sd_bus_message_handler_t callback
--- a/src/ISdBus.h
+++ b/src/ISdBus.h
@ -66,6 +66,7 @@ namespace sdbus::internal {
        virtual int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) = 0;
        virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) = 0;

+        virtual int sd_bus_open(sd_bus **ret) = 0;
        virtual int sd_bus_open_user(sd_bus **ret) = 0;
        virtual int sd_bus_open_system(sd_bus **ret) = 0;
        virtual int sd_bus_open_system_remote(sd_bus **ret, const char* host) = 0;
@ -82,6 +83,19 @@ namespace sdbus::internal {

        virtual int sd_bus_flush(sd_bus *bus) = 0;
        virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
+
+        virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) = 0;
+
+        virtual int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c) = 0;
+        virtual sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c) = 0;
+
+        virtual int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) = 0;
+        virtual int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) = 0;
+        virtual int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *uid) = 0;
+        virtual int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) = 0;
+        virtual int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) = 0;
+        virtual int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) = 0;
+        virtual int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label) = 0;
    };

 }
--- a/src/Message.cpp
+++ b/src/Message.cpp
@ -583,12 +583,14 @@ void Message::rewind(bool complete)

 std::string Message::getInterfaceName() const
 {
-    return sd_bus_message_get_interface((sd_bus_message*)msg_);
+    auto interface = sd_bus_message_get_interface((sd_bus_message*)msg_);
+    return interface != nullptr ? interface : "";
 }

 std::string Message::getMemberName() const
 {
-    return sd_bus_message_get_member((sd_bus_message*)msg_);
+    auto member = sd_bus_message_get_member((sd_bus_message*)msg_);
+    return member != nullptr ? member : "";
 }

 std::string Message::getSender() const
@ -596,6 +598,18 @@ std::string Message::getSender() const
    return sd_bus_message_get_sender((sd_bus_message*)msg_);
 }

+std::string Message::getPath() const
+{
+    auto path = sd_bus_message_get_path((sd_bus_message*)msg_);
+    return path != nullptr ? path : "";
+}
+
+std::string Message::getDestination() const
+{
+    auto destination = sd_bus_message_get_destination((sd_bus_message*)msg_);
+    return destination != nullptr ? destination : "";
+}
+
 void Message::peekType(std::string& type, std::string& contents) const
 {
    char typeSig;
@ -603,7 +617,7 @@ void Message::peekType(std::string& type, std::string& contents) const
    auto r = sd_bus_message_peek_type((sd_bus_message*)msg_, &typeSig, &contentsSig);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to peek message type", -r);
    type = typeSig;
-    contents = contentsSig;
+    contents = contentsSig ? contentsSig : "";
 }

 bool Message::isValid() const
@ -616,6 +630,113 @@ bool Message::isEmpty() const
    return sd_bus_message_is_empty((sd_bus_message*)msg_) != 0;
 }

+pid_t Message::getCredsPid() const
+{
+    uint64_t mask = SD_BUS_CREDS_PID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    pid_t pid = 0;
+    r = sdbus_->sd_bus_creds_get_pid(creds, &pid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred pid", -r);
+    return pid;
+}
+
+uid_t Message::getCredsUid() const
+{
+    uint64_t mask = SD_BUS_CREDS_UID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    uid_t uid = (uid_t)-1;
+    r = sdbus_->sd_bus_creds_get_uid(creds, &uid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred uid", -r);
+    return uid;
+}
+
+uid_t Message::getCredsEuid() const
+{
+    uint64_t mask = SD_BUS_CREDS_EUID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    uid_t euid = (uid_t)-1;
+    r = sdbus_->sd_bus_creds_get_euid(creds, &euid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred euid", -r);
+    return euid;
+}
+
+gid_t Message::getCredsGid() const
+{
+    uint64_t mask = SD_BUS_CREDS_GID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    gid_t gid = (gid_t)-1;
+    r = sdbus_->sd_bus_creds_get_gid(creds, &gid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred gid", -r);
+    return gid;
+}
+
+gid_t Message::getCredsEgid() const
+{
+    uint64_t mask = SD_BUS_CREDS_EGID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    gid_t egid = (gid_t)-1;
+    r = sdbus_->sd_bus_creds_get_egid(creds, &egid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred egid", -r);
+    return egid;
+}
+
+std::vector<gid_t> Message::getCredsSupplementaryGids() const
+{
+    uint64_t mask = SD_BUS_CREDS_SUPPLEMENTARY_GIDS | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    const gid_t *cGids = nullptr;
+    r = sdbus_->sd_bus_creds_get_supplementary_gids(creds, &cGids);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred supplementary gids", -r);
+
+    std::vector<gid_t> gids{};
+    if (cGids != nullptr)
+    {
+        for (int i = 0; i < r; i++)
+            gids.push_back(cGids[i]);
+    }
+
+    return gids;
+}
+
+std::string Message::getSELinuxContext() const
+{
+    uint64_t mask = SD_BUS_CREDS_AUGMENT | SD_BUS_CREDS_SELINUX_CONTEXT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    const char *cLabel = nullptr;
+    r = sdbus_->sd_bus_creds_get_selinux_context(creds, &cLabel);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred selinux context", -r);
+    return cLabel;
+}
+
 void MethodCall::dontExpectReply()
 {
    auto r = sd_bus_message_set_expect_reply((sd_bus_message*)msg_, 0);
@ -711,10 +832,17 @@ void Signal::send() const
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit signal", -r);
 }

+void Signal::setDestination(const std::string& destination)
+{
+    auto r = sdbus_->sd_bus_message_set_destination((sd_bus_message*)msg_, destination.c_str());
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set signal destination", -r);
+}
+
 PlainMessage createPlainMessage()
 {
    static auto connection = internal::createConnection();
    return connection->createPlainMessage();
 }

+
 }
--- a/src/Object.cpp
+++ b/src/Object.cpp
@ -31,6 +31,7 @@
 #include <sdbus-c++/Error.h>
 #include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Flags.h>
+#include "ScopeGuard.h"
 #include "IConnection.h"
 #include "VTableUtils.h"
 #include <systemd/sd-bus.h>
@ -72,7 +73,7 @@ void Object::registerMethod( const std::string& interfaceName
 {
    SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);

-    auto& interface = interfaces_[interfaceName];
+    auto& interface = getInterface(interfaceName);
    InterfaceData::MethodData methodData{ std::move(inputSignature)
                                        , std::move(outputSignature)
                                        , paramNamesToString(inputNames) + paramNamesToString(outputNames)
@ -97,7 +98,7 @@ void Object::registerSignal( const std::string& interfaceName
                           , const std::vector<std::string>& paramNames
                           , Flags flags )
 {
-    auto& interface = interfaces_[interfaceName];
+    auto& interface = getInterface(interfaceName);

    InterfaceData::SignalData signalData{std::move(signature), paramNamesToString(paramNames), std::move(flags)};
    auto inserted = interface.signals.emplace(std::move(signalName), std::move(signalData)).second;
@ -128,12 +129,12 @@ void Object::registerProperty( const std::string& interfaceName
 {
    SDBUS_THROW_ERROR_IF(!getCallback && !setCallback, "Invalid property callbacks provided", EINVAL);

-    auto& interface = interfaces_[interfaceName];
+    auto& interface = getInterface(interfaceName);

    InterfaceData::PropertyData propertyData{ std::move(signature)
                                            , std::move(getCallback)
                                            , std::move(setCallback)
-                                            , std::move(flags)};
+                                            , std::move(flags) };
    auto inserted = interface.properties.emplace(std::move(propertyName), std::move(propertyData)).second;

    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register property: property already exists", EINVAL);
@ -141,7 +142,7 @@ void Object::registerProperty( const std::string& interfaceName

 void Object::setInterfaceFlags(const std::string& interfaceName, Flags flags)
 {
-    auto& interface = interfaces_[interfaceName];
+    auto& interface = getInterface(interfaceName);
    interface.flags = flags;
 }

@ -230,6 +231,16 @@ const std::string& Object::getObjectPath() const
    return objectPath_;
 }

+const Message* Object::getCurrentlyProcessedMessage() const
+{
+    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+}
+
+Object::InterfaceData& Object::getInterface(const std::string& interfaceName)
+{
+    return interfaces_.emplace(interfaceName, *this).first->second;
+}
+
 const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& interfaceData)
 {
    auto& vtable = interfaceData.vtable;
@ -256,7 +267,7 @@ void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::ve
                                               , methodData.outputArgs.c_str()
                                               , methodData.paramNames.c_str()
                                               , &Object::sdbus_method_callback
-                                               , methodData.flags_.toSdBusMethodFlags() ));
+                                               , methodData.flags.toSdBusMethodFlags() ));
    }
 }

@ -299,7 +310,7 @@ void Object::activateInterfaceVTable( const std::string& interfaceName
                                    , InterfaceData& interfaceData
                                    , const std::vector<sd_bus_vtable>& vtable )
 {
-    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], &interfaceData);
 }

 std::string Object::paramNamesToString(const std::vector<std::string>& paramNames)
@ -312,20 +323,26 @@ std::string Object::paramNamesToString(const std::vector<std::string>& paramName

 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;

-    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object->connection_.getSdBusInterface());
+    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object.connection_.getSdBusInterface());

-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[message.getInterfaceName()].methods[message.getMemberName()].callback;
+    object.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
+
+    auto& callback = interfaceData->methods[message.getMemberName()].callback;
    assert(callback);

    try
    {
-        callback(std::move(message));
+        callback(message);
    }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
    {
        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
    }
@ -335,17 +352,17 @@ int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData,

 int Object::sdbus_property_get_callback( sd_bus */*bus*/
                                       , const char */*objectPath*/
-                                       , const char *interface
+                                       , const char */*interface*/
                                       , const char *property
                                       , sd_bus_message *sdbusReply
                                       , void *userData
                                       , sd_bus_error *retError )
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;

-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties[property].getCallback;
+    auto& callback = interfaceData->properties[property].getCallback;
    // Getter can be empty - the case of "write-only" property
    if (!callback)
    {
@ -353,13 +370,13 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
        return 1;
    }

-    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object->connection_.getSdBusInterface());
+    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object.connection_.getSdBusInterface());

    try
    {
        callback(reply);
    }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
    {
        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
    }
@ -369,26 +386,32 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/

 int Object::sdbus_property_set_callback( sd_bus */*bus*/
                                       , const char */*objectPath*/
-                                       , const char *interface
+                                       , const char */*interface*/
                                       , const char *property
                                       , sd_bus_message *sdbusValue
                                       , void *userData
                                       , sd_bus_error *retError )
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;

-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties[property].setCallback;
+    auto& callback = interfaceData->properties[property].setCallback;
    assert(callback);

-    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object->connection_.getSdBusInterface());
+    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object.connection_.getSdBusInterface());
+
+    object.m_CurrentlyProcessedMessage.store(&value, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };

    try
    {
        callback(value);
    }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
    {
        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
    }
--- a/src/Object.h
+++ b/src/Object.h
@ -35,6 +35,7 @@
 #include <vector>
 #include <functional>
 #include <memory>
+#include <atomic>
 #include <cassert>

 namespace sdbus::internal {
@ -102,11 +103,14 @@ namespace sdbus::internal {

        sdbus::IConnection& getConnection() const override;
        const std::string& getObjectPath() const override;
+        const Message* getCurrentlyProcessedMessage() const override;

    private:
        using InterfaceName = std::string;
        struct InterfaceData
        {
+            InterfaceData(Object& object) : object(object) {}
+
            using MethodName = std::string;
            struct MethodData
            {
@ -114,7 +118,7 @@ namespace sdbus::internal {
                const std::string outputArgs;
                const std::string paramNames;
                method_callback callback;
-                Flags flags_;
+                Flags flags;
            };
            std::map<MethodName, MethodData> methods;
            using SignalName = std::string;
@ -136,10 +140,14 @@ namespace sdbus::internal {
            std::map<PropertyName, PropertyData> properties;
            std::vector<sd_bus_vtable> vtable;
            Flags flags;
+            Object& object;

+            // This is intentionally the last member, because it must be destructed first,
+            // releasing callbacks above before the callbacks themselves are destructed.
            SlotPtr slot;
        };

+        InterfaceData& getInterface(const std::string& interfaceName);
        static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);
        static void registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
        static void registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
@ -170,6 +178,7 @@ namespace sdbus::internal {
        std::string objectPath_;
        std::map<InterfaceName, InterfaceData> interfaces_;
        SlotPtr objectManagerSlot_;
+        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
    };

 }
--- a/src/Proxy.cpp
+++ b/src/Proxy.cpp
@ -34,7 +34,7 @@
 #include <systemd/sd-bus.h>
 #include <cassert>
 #include <chrono>
-#include <thread>
+#include <utility>

 namespace sdbus::internal {

@ -160,7 +160,7 @@ void Proxy::registerSignalHandler( const std::string& interfaceName

    auto& interface = interfaces_[interfaceName];

-    InterfaceData::SignalData signalData{std::move(signalHandler), nullptr};
+    auto signalData = std::make_unique<InterfaceData::SignalData>(*this, std::move(signalHandler), nullptr);
    auto insertionResult = interface.signals_.emplace(signalName, std::move(signalData));

    auto inserted = insertionResult.second;
@ -182,12 +182,13 @@ void Proxy::registerSignalHandlers(sdbus::internal::IConnection& connection)
        for (auto& signalItem : signalsOnInterface)
        {
            const auto& signalName = signalItem.first;
-            auto& slot = signalItem.second.slot_;
-            slot = connection.registerSignalHandler( objectPath_
-                                                   , interfaceName
-                                                   , signalName
-                                                   , &Proxy::sdbus_signal_handler
-                                                   , this );
+            auto* signalData = signalItem.second.get();
+            signalData->slot = connection.registerSignalHandler( destination_
+                                                               , objectPath_
+                                                               , interfaceName
+                                                               , signalName
+                                                               , &Proxy::sdbus_signal_handler
+                                                               , signalData);
        }
    }
 }
@ -198,11 +199,21 @@ void Proxy::unregister()
    interfaces_.clear();
 }

+sdbus::IConnection& Proxy::getConnection() const
+{
+    return dynamic_cast<sdbus::IConnection&>(*connection_);
+}
+
 const std::string& Proxy::getObjectPath() const
 {
    return objectPath_;
 }

+const Message* Proxy::getCurrentlyProcessedMessage() const
+{
+    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+}
+
 int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
 {
    auto* asyncCallData = static_cast<AsyncCalls::CallData*>(userData);
@ -223,15 +234,28 @@ int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userDat

    auto message = Message::Factory::create<MethodReply>(sdbusMessage, &proxy.connection_->getSdBusInterface());

-    const auto* error = sd_bus_message_get_error(sdbusMessage);
-    if (error == nullptr)
+    proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
    {
-        asyncCallData->callback(message, nullptr);
+        proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
+
+    try
+    {
+        const auto* error = sd_bus_message_get_error(sdbusMessage);
+        if (error == nullptr)
+        {
+            asyncCallData->callback(message, nullptr);
+        }
+        else
+        {
+            Error exception(error->name, error->message);
+            asyncCallData->callback(message, &exception);
+        }
    }
-    else
+    catch (const Error&)
    {
-        sdbus::Error exception(error->name, error->message);
-        asyncCallData->callback(message, &exception);
+        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
    }

    return 1;
@ -239,16 +263,26 @@ int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userDat

 int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
 {
-    auto* proxy = static_cast<Proxy*>(userData);
-    assert(proxy != nullptr);
+    auto* signalData = static_cast<InterfaceData::SignalData*>(userData);
+    assert(signalData != nullptr);
+    assert(signalData->callback);

-    auto message = Message::Factory::create<Signal>(sdbusMessage, &proxy->connection_->getSdBusInterface());
+    auto message = Message::Factory::create<Signal>(sdbusMessage, &signalData->proxy.connection_->getSdBusInterface());

-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = proxy->interfaces_[message.getInterfaceName()].signals_[message.getMemberName()].callback_;
-    assert(callback);
+    signalData->proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        signalData->proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };

-    callback(message);
+    try
+    {
+        signalData->callback(message);
+    }
+    catch (const Error&)
+    {
+        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
+    }

    return 0;
 }
--- a/src/Proxy.h
+++ b/src/Proxy.h
@ -35,6 +35,7 @@
 #include <map>
 #include <unordered_map>
 #include <mutex>
+#include <atomic>
 #include <condition_variable>

 namespace sdbus::internal {
@ -60,7 +61,9 @@ namespace sdbus::internal {
        void finishRegistration() override;
        void unregister() override;

+        sdbus::IConnection& getConnection() const override;
        const std::string& getObjectPath() const override;
+        const Message* getCurrentlyProcessedMessage() const override;

    private:
        class SyncCallReplyData
@ -97,10 +100,20 @@ namespace sdbus::internal {
            using SignalName = std::string;
            struct SignalData
            {
-                signal_handler callback_;
-                SlotPtr slot_;
+                SignalData(Proxy& proxy, signal_handler callback, SlotPtr slot)
+                    : proxy(proxy)
+                    , callback(std::move(callback))
+                    , slot(std::move(slot))
+                {}
+                Proxy& proxy;
+                signal_handler callback;
+                // slot_ must be listed after callback_ to ensure that slot_ is destructed first.
+                // Destructing the slot_ will sd_bus_slot_unref() the callback.
+                // Only after sd_bus_slot_unref(), we can safely delete the callback. The bus mutex (SdBus::sdbusMutex_)
+                // ensures that sd_bus_slot_unref() and the callback execute sequentially.
+                SlotPtr slot;
            };
-            std::map<SignalName, SignalData> signals_;
+            std::map<SignalName, std::unique_ptr<SignalData>> signals_;
        };
        std::map<InterfaceName, InterfaceData> interfaces_;

@ -149,6 +162,7 @@ namespace sdbus::internal {
            {
                std::unique_lock lock(mutex_);
                auto asyncCallSlots = std::move(calls_);
+                calls_ = {};
                lock.unlock();

                // Releasing call slot pointer acquires global sd-bus mutex. We have to perform the release
@ -158,9 +172,11 @@ namespace sdbus::internal {
            }

        private:
-            std::unordered_map<void*, std::shared_ptr<CallData>> calls_;
            std::mutex mutex_;
+            std::unordered_map<void*, std::shared_ptr<CallData>> calls_;
        } pendingAsyncCalls_;
+
+        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
    };

 }
--- a/src/SdBus.cpp
+++ b/src/SdBus.cpp
@ -161,6 +161,11 @@ int SdBus::sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, ch
    return ::sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
 }

+int SdBus::sd_bus_open(sd_bus **ret)
+{
+    return ::sd_bus_open(ret);
+}
+
 int SdBus::sd_bus_open_user(sd_bus **ret)
 {
    return ::sd_bus_open_user(ret);
@ -260,4 +265,74 @@ sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
    return ::sd_bus_flush_close_unref(bus);
 }

+int SdBus::sd_bus_message_set_destination(sd_bus_message *m, const char *destination)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_message_set_destination(m, destination);
+}
+
+int SdBus::sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_query_sender_creds(m, mask, c);
+}
+
+sd_bus_creds* SdBus::sd_bus_creds_unref(sd_bus_creds *c)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_unref(c);
+}
+
+int SdBus::sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_pid(c, pid);
+}
+
+int SdBus::sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_uid(c, uid);
+}
+
+int SdBus::sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_euid(c, euid);
+}
+
+int SdBus::sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_gid(c, gid);
+}
+
+int SdBus::sd_bus_creds_get_egid(sd_bus_creds *c, uid_t *egid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_egid(c, egid);
+}
+
+int SdBus::sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_supplementary_gids(c, gids);
+}
+
+int SdBus::sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_selinux_context(c, label);
+}
+
 }
--- a/src/SdBus.h
+++ b/src/SdBus.h
@ -58,6 +58,7 @@ public:
    virtual int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) override;
    virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) override;

+    virtual int sd_bus_open(sd_bus **ret) override;
    virtual int sd_bus_open_user(sd_bus **ret) override;
    virtual int sd_bus_open_system(sd_bus **ret) override;
    virtual int sd_bus_open_system_remote(sd_bus **ret, const char* hsot) override;
@ -75,6 +76,19 @@ public:
    virtual int sd_bus_flush(sd_bus *bus) override;
    virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;

+    virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) override;
+
+    virtual int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c) override;
+    virtual sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c) override;
+
+    virtual int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) override;
+    virtual int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) override;
+    virtual int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid) override;
+    virtual int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) override;
+    virtual int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) override;
+    virtual int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) override;
+    virtual int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label) override;
+
 private:
    std::recursive_mutex sdbusMutex_;
 };
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -2,26 +2,44 @@
 # DOWNLOAD AND BUILD OF GOOGLETEST
 #-------------------------------

-include(FetchContent)
+set(GOOGLETEST_VERSION 1.10.0 CACHE STRING "Version of gmock to use")
+set(GOOGLETEST_GIT_REPO "https://github.com/google/googletest.git" CACHE STRING "A git repo to clone and build googletest from if gmock is not found in the system")

-message("Fetching googletest...")
-FetchContent_Declare(googletest
-                     GIT_REPOSITORY https://github.com/google/googletest.git
-                     GIT_TAG        master
-                     GIT_SHALLOW    1
-                     UPDATE_COMMAND "")
+find_package(GTest ${GOOGLETEST_VERSION} CONFIG)
+if (NOT TARGET GTest::gmock)
+    # Try pkg-config if GTest was not found through CMake config
+    find_package(PkgConfig)
+    if (PkgConfig_FOUND)
+        pkg_check_modules(GMock IMPORTED_TARGET GLOBAL gmock>=${GOOGLETEST_VERSION})
+        if(TARGET PkgConfig::GMock)
+            add_library(GTest::gmock ALIAS PkgConfig::GMock)
+        endif()
+    endif()
+    # GTest was not found in the system, build it on our own
+    if (NOT TARGET GTest::gmock)
+        include(FetchContent)

-#FetchContent_MakeAvailable(googletest) # Not available in CMake 3.13 :-( Let's do it manually:
-FetchContent_GetProperties(googletest)
-if(NOT googletest_POPULATED)
-    FetchContent_Populate(googletest)
-    set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
-    set(BUILD_GMOCK ON CACHE INTERNAL "" FORCE)
-    set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
-    set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
-    set(BUILD_SHARED_LIBS OFF)
-    add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
-    set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
+        message("Fetching googletest...")
+        FetchContent_Declare(googletest
+                            GIT_REPOSITORY ${GOOGLETEST_GIT_REPO}
+                            GIT_TAG        release-${GOOGLETEST_VERSION}
+                            GIT_SHALLOW    1
+                            UPDATE_COMMAND "")
+
+        #FetchContent_MakeAvailable(googletest) # Not available in CMake 3.13 :-( Let's do it manually:
+        FetchContent_GetProperties(googletest)
+        if(NOT googletest_POPULATED)
+            FetchContent_Populate(googletest)
+            set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
+            set(BUILD_GMOCK ON CACHE INTERNAL "" FORCE)
+            set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
+            set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
+            set(BUILD_SHARED_LIBS OFF)
+            add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
+            set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
+            add_library(GTest::gmock ALIAS gmock)
+        endif()
+    endif()
 endif()

 #-------------------------------
@ -39,14 +57,23 @@ set(UNITTESTS_SRCS

 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}/sdbus-c++-integration-tests.cpp
-    ${INTEGRATIONTESTS_SOURCE_DIR}/adaptor-glue.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/defs.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/proxy-glue.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingAdaptor.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingProxy.h)
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusConnectionTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusGeneralTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusMethodsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusAsyncMethodsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusSignalsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusPropertiesTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusStandardInterfacesTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/Defs.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/integrationtests-adaptor.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/integrationtests-proxy.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestFixture.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestFixture.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestAdaptor.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestAdaptor.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestProxy.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestProxy.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/sdbus-c++-integration-tests.cpp)

 set(PERFTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/perftests)
 set(STRESSTESTS_CLIENT_SRCS
@ -78,11 +105,11 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})

 add_executable(sdbus-c++-unit-tests ${UNITTESTS_SRCS})
 target_compile_definitions(sdbus-c++-unit-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
-target_link_libraries(sdbus-c++-unit-tests sdbus-c++-objlib gmock gmock_main)
+target_link_libraries(sdbus-c++-unit-tests sdbus-c++-objlib GTest::gmock)

 add_executable(sdbus-c++-integration-tests ${INTEGRATIONTESTS_SRCS})
 target_compile_definitions(sdbus-c++-integration-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
-target_link_libraries(sdbus-c++-integration-tests sdbus-c++ gmock gmock_main)
+target_link_libraries(sdbus-c++-integration-tests sdbus-c++ GTest::gmock)

 # Manual performance and stress tests
 option(ENABLE_PERF_TESTS "Build and install manual performance tests (default OFF)" OFF)
@ -93,6 +120,7 @@ if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
    find_package(Threads REQUIRED)

    if(ENABLE_PERF_TESTS)
+        message(STATUS "Building with performance 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})
@ -100,6 +128,7 @@ if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
    endif()

    if(ENABLE_STRESS_TESTS)
+        message(STATUS "Building with stress tests")
        add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
        target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
    endif()
@ -111,19 +140,19 @@ endif()

 set(TESTS_INSTALL_PATH "/opt/test/bin" CACHE STRING "Specifies where the test binaries will be installed")

-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)
+install(TARGETS sdbus-c++-unit-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+install(TARGETS sdbus-c++-integration-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)

 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)
+    install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
 endif()

 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)
+    install(TARGETS sdbus-c++-stress-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
 endif()

 #----------------------------------
--- a/tests/integrationtests/AdaptorAndProxy_test.cpp
+++ b/tests/integrationtests/AdaptorAndProxy_test.cpp
@ -24,25 +24,19 @@
 * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
 */

-// Own
-#include "TestingAdaptor.h"
-#include "TestingProxy.h"
-
-// sdbus
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
 #include "sdbus-c++/sdbus-c++.h"

-// gmock
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
-
-// STL
 #include <string>
 #include <thread>
 #include <tuple>
 #include <chrono>
 #include <fstream>
 #include <future>
-
 #include <unistd.h>

 using ::testing::Eq;
@ -52,71 +46,9 @@ using ::testing::AnyOf;
 using ::testing::ElementsAre;
 using ::testing::SizeIs;
 using namespace std::chrono_literals;
+using namespace sdbus::test;

-namespace
-{
-
-class AdaptorAndProxyFixture : public ::testing::Test
-{
-public:
-    static void SetUpTestCase()
-    {
-        s_connection->requestName(INTERFACE_NAME);
-        s_connection->enterEventLoopAsync();
-    }
-
-    static void TearDownTestCase()
-    {
-        s_connection->leaveEventLoop();
-        s_connection->releaseName(INTERFACE_NAME);
-    }
-
-    template <typename _Fnc>
-    static bool waitUntil(_Fnc&& fnc, std::chrono::milliseconds timeout = 5s)
-    {
-        std::chrono::milliseconds elapsed{};
-        std::chrono::milliseconds step{5ms};
-        do {
-            std::this_thread::sleep_for(step);
-            elapsed += step;
-            if (elapsed > timeout)
-                return false;
-        } while (!fnc());
-
-        return true;
-    }
-
-    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = 5s)
-    {
-        return waitUntil([&flag]() -> bool { return flag; }, timeout);
-    }
-
-private:
-    void SetUp() override
-    {
-        m_adaptor = std::make_unique<TestingAdaptor>(*s_connection);
-        m_proxy = std::make_unique<TestingProxy>(INTERFACE_NAME, OBJECT_PATH);
-        std::this_thread::sleep_for(50ms); // Give time for the proxy to start listening to signals
-    }
-
-    void TearDown() override
-    {
-        m_proxy.reset();
-        m_adaptor.reset();
-    }
-
-public:
-    static std::unique_ptr<sdbus::IConnection> s_connection;
-
-    std::unique_ptr<TestingAdaptor> m_adaptor;
-    std::unique_ptr<TestingProxy> m_proxy;
-};
-
-std::unique_ptr<sdbus::IConnection> AdaptorAndProxyFixture::s_connection = sdbus::createSystemBusConnection();
-
-}
-
-using SdbusTestObject = AdaptorAndProxyFixture;
+using SdbusTestObject = TestFixture;

 /*-------------------------------------*/
 /* --          TEST CASES           -- */
@ -127,8 +59,8 @@ TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
    auto connection = sdbus::createConnection();
    connection->requestName(INTERFACE_NAME);

-    ASSERT_NO_THROW(TestingAdaptor adaptor(*connection));
-    ASSERT_NO_THROW(TestingProxy proxy(INTERFACE_NAME, OBJECT_PATH));
+    ASSERT_NO_THROW(TestAdaptor adaptor(*connection));
+    ASSERT_NO_THROW(TestProxy proxy(INTERFACE_NAME, OBJECT_PATH));

    connection->releaseName(INTERFACE_NAME);
 }
@ -279,7 +211,7 @@ TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
        });

        m_proxy->doOperationClientSideAsyncWith500msTimeout(1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
-        future.get(), Eq(100);
+        future.get();

        FAIL() << "Expected sdbus::Error exception";
    }
@ -328,7 +260,7 @@ TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
    std::atomic<int> startedCount{};
    auto call = [&](uint32_t param)
    {
-        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        TestProxy proxy{INTERFACE_NAME, OBJECT_PATH};
        ++startedCount;
        while (!invoke) ;
        auto result = proxy.doOperationAsync(param);
@ -351,7 +283,7 @@ TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
    std::atomic<int> startedCount{};
    auto call = [&]()
    {
-        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        TestProxy proxy{INTERFACE_NAME, OBJECT_PATH};
        ++startedCount;
        while (!invoke) ;

@ -465,17 +397,17 @@ TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)

 TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
 {
-    TestingProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
+    TestProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
    ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }

 TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
 {
-    TestingProxy proxy(INTERFACE_NAME, "/sdbuscpp/path/that/does/not/exist");
+    TestProxy proxy(INTERFACE_NAME, "/sdbuscpp/path/that/does/not/exist");
    ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }

-TEST_F(SdbusTestObject, ReceivesTwoSignalsWhileMakingMethodCall)
+TEST_F(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
 {
    m_proxy->emitTwoSimpleSignals();

@ -508,8 +440,8 @@ TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)

 TEST_F(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
 {
-    auto proxy1 = std::make_unique<TestingProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
-    auto proxy2 = std::make_unique<TestingProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
+    auto proxy1 = std::make_unique<TestProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);

    m_adaptor->emitSimpleSignal();

@ -553,7 +485,7 @@ TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)

 TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
 {
-    ASSERT_THROW(m_proxy->state("new_value"), sdbus::Error);
+    ASSERT_THROW(m_proxy->setStateProperty("new_value"), sdbus::Error);
 }

 TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
--- a/tests/integrationtests/DBusAsyncMethodsTests.cpp
+++ b/tests/integrationtests/DBusAsyncMethodsTests.cpp
@ -0,0 +1,235 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file DBusAsyncMethodsTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
+{
+    try
+    {
+        std::promise<uint32_t> promise;
+        auto future = promise.get_future();
+        m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+        {
+            if (err == nullptr)
+                promise.set_value(res);
+            else
+                promise.set_exception(std::make_exception_ptr(*err));
+        });
+
+        m_proxy->doOperationClientSideAsyncWith500msTimeout(1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
+        future.get();
+
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
+        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
+{
+    // Yeah, this is kinda timing-dependent test, but times should be safe...
+    std::mutex mtx;
+    std::vector<uint32_t> results;
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&](uint32_t param)
+    {
+        TestProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+        auto result = proxy.doOperationAsync(param);
+        std::lock_guard<std::mutex> guard(mtx);
+        results.push_back(result);
+    };
+
+    std::thread invocations[]{std::thread{call, 1500}, std::thread{call, 1000}, std::thread{call, 500}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(results, ElementsAre(500, 1000, 1500));
+}
+
+TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
+{
+    std::atomic<size_t> resultCount{};
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&]()
+    {
+        TestProxy proxy{INTERFACE_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+
+        size_t localResultCount{};
+        for (size_t i = 0; i < 500; ++i)
+        {
+            auto result = proxy.doOperationAsync(i % 2);
+            if (result == (i % 2)) // Correct return value?
+                localResultCount++;
+        }
+
+        resultCount += localResultCount;
+    };
+
+    std::thread invocations[]{std::thread{call}, std::thread{call}, std::thread{call}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(resultCount, Eq(1500));
+}
+
+TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    {
+        if (err == nullptr)
+            promise.set_value(res);
+        else
+            promise.set_exception(std::make_exception_ptr(*err));
+    });
+
+    m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_THAT(future.get(), Eq(100));
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
+{
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){});
+
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_TRUE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, CancelsPendingAsyncCallOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    call.cancel();
+
+    ASSERT_THAT(future.wait_for(300ms), Eq(std::future_status::timeout));
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCancelled)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    call.cancel();
+
+    ASSERT_FALSE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCompleted)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+
+    auto call = m_proxy->doOperationClientSideAsync(0);
+    (void) future.get(); // Wait for the call to finish
+
+    ASSERT_TRUE(waitUntil([&call](){ return !call.isPending(); }));
+}
+
+TEST_F(SdbusTestObject, AnswersThatDefaultConstructedAsyncCallIsNotPending)
+{
+    sdbus::PendingAsyncCall call;
+
+    ASSERT_FALSE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, SupportsAsyncCallCopyAssignment)
+{
+    sdbus::PendingAsyncCall call;
+
+    call = m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_TRUE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, InvokesErroneousMethodAsynchronouslyOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    {
+        if (err == nullptr)
+            promise.set_value(res);
+        else
+            promise.set_exception(std::make_exception_ptr(*err));
+    });
+
+    m_proxy->doErroneousOperationClientSideAsync();
+
+    ASSERT_THROW(future.get(), sdbus::Error);
+}
--- a/tests/integrationtests/DBusConnectionTests.cpp
+++ b/tests/integrationtests/DBusConnectionTests.cpp
@ -1,8 +1,8 @@
 /**
 * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
 *
- * @file Connection_test.cpp
+ * @file DBusConnectionTests.cpp
 *
 * Created on: Jan 2, 2017
 * Project: sdbus-c++
@ -25,7 +25,7 @@
 */

 // Own
-#include "defs.h"
+#include "Defs.h"

 // sdbus
 #include <sdbus-c++/Error.h>
@ -39,7 +39,7 @@
 #include <thread>

 using ::testing::Eq;
-
+using namespace sdbus::test;

 /*-------------------------------------*/
 /* --          TEST CASES           -- */
@ -54,8 +54,8 @@ TEST(Connection, CanRequestRegisteredDbusName)
 {
    auto connection = sdbus::createConnection();

-    ASSERT_NO_THROW(connection->requestName(INTERFACE_NAME));
-    connection->releaseName(INTERFACE_NAME);
+    ASSERT_NO_THROW(connection->requestName(INTERFACE_NAME))
+        << "Perhaps you've forgotten to copy `org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory before running the tests?";
 }

 TEST(Connection, CannotRequestNonregisteredDbusName)
@ -87,6 +87,4 @@ TEST(Connection, CanEnterAndLeaveEventLoop)
    connection->leaveEventLoop();

    t.join();
-
-    connection->releaseName(INTERFACE_NAME);
 }
--- a/tests/integrationtests/DBusGeneralTests.cpp
+++ b/tests/integrationtests/DBusGeneralTests.cpp
@ -0,0 +1,54 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file DBusGeneralTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using namespace sdbus::test;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
+{
+    auto connection = sdbus::createConnection();
+    connection->requestName(INTERFACE_NAME);
+
+    ASSERT_NO_THROW(TestAdaptor adaptor(*connection));
+    ASSERT_NO_THROW(TestProxy proxy(INTERFACE_NAME, OBJECT_PATH));
+}
--- a/tests/integrationtests/DBusMethodsTests.cpp
+++ b/tests/integrationtests/DBusMethodsTests.cpp
@ -0,0 +1,270 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file DBusMethodsTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, CallsEmptyMethodSuccesfully)
+{
+    ASSERT_NO_THROW(m_proxy->noArgNoReturn());
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithBaseTypesSuccesfully)
+{
+    auto resInt = m_proxy->getInt();
+    ASSERT_THAT(resInt, Eq(INT32_VALUE));
+
+    auto multiplyRes = m_proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
+    ASSERT_THAT(multiplyRes, Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithTuplesSuccesfully)
+{
+    auto resTuple = m_proxy->getTuple();
+    ASSERT_THAT(std::get<0>(resTuple), Eq(UINT32_VALUE));
+    ASSERT_THAT(std::get<1>(resTuple), Eq(STRING_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithStructSuccesfully)
+{
+    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> a{};
+    auto vectorRes = m_proxy->getInts16FromStruct(a);
+    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{0})); // because second item is by default initialized to 0
+
+
+    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> b{
+        UINT8_VALUE, INT16_VALUE, DOUBLE_VALUE, STRING_VALUE, {INT16_VALUE, -INT16_VALUE}
+    };
+    vectorRes = m_proxy->getInts16FromStruct(b);
+    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{INT16_VALUE, INT16_VALUE, -INT16_VALUE}));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithVariantSuccesfully)
+{
+    sdbus::Variant v{DOUBLE_VALUE};
+    auto variantRes = m_proxy->processVariant(v);
+    ASSERT_THAT(variantRes.get<int32_t>(), Eq(static_cast<int32_t>(DOUBLE_VALUE)));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccesfully)
+{
+    std::vector<int32_t> x{-2, 0, 2};
+    sdbus::Struct<sdbus::Variant, sdbus::Variant> y{false, true};
+    auto mapOfVariants = m_proxy->getMapOfVariants(x, y);
+    decltype(mapOfVariants) res{{-2, false}, {0, false}, {2, true}};
+
+    ASSERT_THAT(mapOfVariants[-2].get<bool>(), Eq(res[-2].get<bool>()));
+    ASSERT_THAT(mapOfVariants[0].get<bool>(), Eq(res[0].get<bool>()));
+    ASSERT_THAT(mapOfVariants[2].get<bool>(), Eq(res[2].get<bool>()));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithStructInStructSuccesfully)
+{
+    auto val = m_proxy->getStructInStruct();
+    ASSERT_THAT(val.get<0>(), Eq(STRING_VALUE));
+    ASSERT_THAT(std::get<0>(std::get<1>(val))[INT32_VALUE], Eq(INT32_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithTwoStructsSuccesfully)
+{
+    auto val = m_proxy->sumStructItems({1, 2}, {3, 4});
+    ASSERT_THAT(val, Eq(1 + 2 + 3 + 4));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithTwoVectorsSuccesfully)
+{
+    auto val = m_proxy->sumVectorItems({1, 7}, {2, 3});
+    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithSignatureSuccesfully)
+{
+    auto resSignature = m_proxy->getSignature();
+    ASSERT_THAT(resSignature, Eq(SIGNATURE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
+{
+    auto resObjectPath = m_proxy->getObjPath();
+    ASSERT_THAT(resObjectPath, Eq(OBJECT_PATH_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
+{
+    auto resUnixFd = m_proxy->getUnixFd();
+    ASSERT_THAT(resUnixFd.get(), Gt(UNIX_FD_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
+{
+    auto resComplex = m_proxy->getComplex();
+    ASSERT_THAT(resComplex.count(0), Eq(1));
+}
+
+TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
+{
+    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
+
+    ASSERT_TRUE(waitUntil(m_adaptor->m_wasMultiplyCalled));
+    ASSERT_THAT(m_adaptor->m_multiplyResult, Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
+{
+    auto res = m_proxy->doOperationWith500msTimeout(20); // The operation will take 20ms, but the timeout is 500ms, so we are fine
+    ASSERT_THAT(res, Eq(20));
+}
+
+TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
+{
+    try
+    {
+        m_proxy->doOperationWith500msTimeout(1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
+        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+TEST_F(SdbusTestObject, CallsMethodThatThrowsError)
+{
+    try
+    {
+        m_proxy->throwError();
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), Eq("org.freedesktop.DBus.Error.AccessDenied"));
+        ASSERT_THAT(e.getMessage(), Eq("A test error occurred (Operation not permitted)"));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+TEST_F(SdbusTestObject, CallsErrorThrowingMethodWithDontExpectReplySet)
+{
+    ASSERT_NO_THROW(m_proxy->throwErrorWithNoReply());
+
+    ASSERT_TRUE(waitUntil(m_adaptor->m_wasThrowErrorCalled));
+}
+
+TEST_F(SdbusTestObject, FailsCallingNonexistentMethod)
+{
+    ASSERT_THROW(m_proxy->callNonexistentMethod(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
+{
+    ASSERT_THROW(m_proxy->callMethodOnNonexistentInterface(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
+{
+    TestProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
+    ASSERT_THROW(proxy.getInt(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
+{
+    TestProxy proxy(INTERFACE_NAME, "/sdbuscpp/path/that/does/not/exist");
+    ASSERT_THROW(proxy.getInt(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
+{
+    m_proxy->emitTwoSimpleSignals();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHandler)
+{
+    m_proxy->doOperation(10); // This will save pointer to method call message on server side
+
+    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperation"));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCallHandler)
+{
+    m_proxy->doOperationAsync(10); // This will save pointer to method call message on server side
+
+    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperationAsync"));
+}
+
+#if LIBSYSTEMD_VERSION>=240
+TEST_F(SdbusTestObject, CanSetGeneralMethodTimeoutWithLibsystemdVersionGreaterThan239)
+{
+    s_connection->setMethodCallTimeout(5000000);
+    ASSERT_THAT(s_connection->getMethodCallTimeout(), Eq(5000000));
+}
+#else
+TEST_F(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLessThan240)
+{
+    ASSERT_THROW(s_connection->setMethodCallTimeout(5000000), sdbus::Error);
+    ASSERT_THROW(s_connection->getMethodCallTimeout(), sdbus::Error);
+}
+#endif
--- a/tests/integrationtests/DBusPropertiesTests.cpp
+++ b/tests/integrationtests/DBusPropertiesTests.cpp
@ -0,0 +1,85 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file DBusPropertiesTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using ::testing::Not;
+using ::testing::IsEmpty;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
+{
+    ASSERT_THAT(m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
+{
+    ASSERT_THROW(m_proxy->setStateProperty("new_value"), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
+{
+    uint32_t newActionValue = 5678;
+
+    m_proxy->action(newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedPropertySetMessageInPropertySetHandler)
+{
+    m_proxy->blocking(true); // This will save pointer to property get message on server side
+
+    ASSERT_THAT(m_adaptor->m_propertySetMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_propertySetSender, Not(IsEmpty()));
+}
--- a/tests/integrationtests/DBusSignalsTests.cpp
+++ b/tests/integrationtests/DBusSignalsTests.cpp
@ -0,0 +1,116 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file AdaptorAndProxy_test.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)
+{
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+}
+
+TEST_F(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
+{
+    auto proxy1 = std::make_unique<TestProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(proxy1->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(proxy2->m_gotSimpleSignal));
+}
+
+TEST_F(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
+{
+    auto otherBusName = INTERFACE_NAME + "2";
+    auto connection2 = sdbus::createConnection(otherBusName);
+    auto adaptor2 = std::make_unique<TestAdaptor>(*connection2);
+
+    adaptor2->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, std::chrono::seconds(1)));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithMapSuccesfully)
+{
+    m_adaptor->emitSignalWithMap({{0, "zero"}, {1, "one"}});
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
+    ASSERT_THAT(m_proxy->m_mapFromSignal[0], Eq("zero"));
+    ASSERT_THAT(m_proxy->m_mapFromSignal[1], Eq("one"));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
+{
+    double d = 3.14;
+    m_adaptor->emitSignalWithVariant(d);
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithVariant));
+    ASSERT_THAT(m_proxy->m_variantFromSignal, DoubleEq(d));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
+{
+    m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithSignature));
+    ASSERT_THAT(m_proxy->m_signatureFromSignal["platform"], Eq("av"));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
+{
+    m_adaptor->emitSimpleSignal();
+
+    waitUntil(m_proxy->m_gotSimpleSignal);
+
+    ASSERT_THAT(m_proxy->m_signalMsg, NotNull());
+    ASSERT_THAT(m_proxy->m_signalMemberName, Eq("simpleSignal"));
+}
--- a/tests/integrationtests/DBusStandardInterfacesTests.cpp
+++ b/tests/integrationtests/DBusStandardInterfacesTests.cpp
@ -0,0 +1,259 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file DBusStandardInterfacesTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, PingsViaPeerInterface)
+{
+    ASSERT_NO_THROW(m_proxy->Ping());
+}
+
+TEST_F(SdbusTestObject, AnswersMachineUuidViaPeerInterface)
+{
+    // If /etc/machine-id does not exist in your system (which is very likely because you have
+    // a non-systemd Linux), org.freedesktop.DBus.Peer.GetMachineId() will not work. To solve
+    // this, you can create /etc/machine-id yourself as symlink to /var/lib/dbus/machine-id,
+    // and then org.freedesktop.DBus.Peer.GetMachineId() will start to work.
+    if (::access("/etc/machine-id", F_OK) == -1)
+        GTEST_SKIP() << "/etc/machine-id file does not exist, GetMachineId() will not work";
+
+    ASSERT_NO_THROW(m_proxy->GetMachineId());
+}
+
+// TODO: Adjust expected xml and uncomment this test
+//TEST_F(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
+//{
+//    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
+//}
+
+TEST_F(SdbusTestObject, GetsPropertyViaPropertiesInterface)
+{
+    ASSERT_THAT(m_proxy->Get(INTERFACE_NAME, "state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
+{
+    uint32_t newActionValue = 2345;
+
+    m_proxy->Set(INTERFACE_NAME, "action", newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+}
+
+TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+{
+    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
+
+    ASSERT_THAT(properties, SizeIs(3));
+    EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+}
+
+TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
+                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
+                                                             , const std::vector<std::string>& /*invalidatedProperties*/ )
+    {
+        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
+        EXPECT_THAT(changedProperties, SizeIs(1));
+        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(!DEFAULT_BLOCKING_VALUE));
+        signalReceived = true;
+    };
+
+    m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
+    m_proxy->action(DEFAULT_ACTION_VALUE*2);
+    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
+                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
+                                                             , const std::vector<std::string>& invalidatedProperties )
+    {
+        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
+        EXPECT_THAT(changedProperties, SizeIs(1));
+        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+        ASSERT_THAT(invalidatedProperties, SizeIs(1));
+        EXPECT_THAT(invalidatedProperties[0], Eq("action"));
+        signalReceived = true;
+    };
+
+    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME);
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
+{
+    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(0));
+}
+
+TEST_F(SdbusTestObject, GetsManagedObjectsSuccessfully)
+{
+    auto subObject1 = sdbus::createObject(*s_connection, "/sub/path1");
+    subObject1->registerProperty("aProperty1").onInterface("org.sdbuscpp.integrationtests.iface1").withGetter([]{return uint8_t{123};});
+    subObject1->finishRegistration();
+    auto subObject2 = sdbus::createObject(*s_connection, "/sub/path2");
+    subObject2->registerProperty("aProperty2").onInterface("org.sdbuscpp.integrationtests.iface2").withGetter([]{return "hi";});
+    subObject2->finishRegistration();
+
+    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
+    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path1").at("org.sdbuscpp.integrationtests.iface1").at("aProperty1").get<uint8_t>(), Eq(123));
+    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path2").at("org.sdbuscpp.integrationtests.iface2").at("aProperty2").get<std::string>(), Eq("hi"));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                           , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        EXPECT_THAT(interfacesAndProperties, SizeIs(1));
+        EXPECT_THAT(interfacesAndProperties.count(INTERFACE_NAME), Eq(1));
+#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"));
+#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"));
+#endif
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesAddedSignal({INTERFACE_NAME});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                           , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        EXPECT_THAT(interfacesAndProperties, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+#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"));
+#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"));
+#endif
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesAddedSignal();
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                             , const std::vector<std::string>& interfaces )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        ASSERT_THAT(interfaces, SizeIs(1));
+        EXPECT_THAT(interfaces[0], Eq(INTERFACE_NAME));
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesRemovedSignal({INTERFACE_NAME});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                             , const std::vector<std::string>& interfaces )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        ASSERT_THAT(interfaces, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesRemovedSignal();
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
--- a/tests/integrationtests/Defs.h
+++ b/tests/integrationtests/Defs.h
@ -2,7 +2,7 @@
 * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
 * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
 *
- * @file defs.h
+ * @file Defs.h
 *
 * Created on: Jan 2, 2017
 * Project: sdbus-c++
@ -29,6 +29,8 @@

 #include "sdbus-c++/Types.h"

+namespace sdbus { namespace test {
+
 const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 const std::string OBJECT_PATH{"/"};

@ -49,4 +51,6 @@ const bool DEFAULT_BLOCKING_VALUE{true};

 constexpr const double DOUBLE_VALUE{3.24L};

+}}
+
 #endif /* SDBUS_CPP_INTEGRATIONTESTS_DEFS_H_ */
--- a/tests/integrationtests/TestAdaptor.cpp
+++ b/tests/integrationtests/TestAdaptor.cpp
@ -0,0 +1,426 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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/>.
+ */
+
+#include "TestAdaptor.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+namespace sdbus { namespace test {
+    
+TestAdaptor::TestAdaptor(sdbus::IConnection& connection) :
+    AdaptorInterfaces(connection, OBJECT_PATH)
+{
+    registerAdaptor();
+}
+
+TestAdaptor::~TestAdaptor()
+{
+    unregisterAdaptor();
+}
+
+void TestAdaptor::noArgNoReturn()
+{
+}
+
+int32_t TestAdaptor::getInt()
+{
+    return INT32_VALUE;
+}
+
+std::tuple<uint32_t, std::string> TestAdaptor::getTuple()
+{
+    return std::make_tuple(UINT32_VALUE, STRING_VALUE);
+}
+
+double TestAdaptor::multiply(const int64_t& a, const double& b)
+{
+    return a * b;
+}
+
+void TestAdaptor::multiplyWithNoReply(const int64_t& a, const double& b)
+{
+    m_multiplyResult = a * b;
+    m_wasMultiplyCalled = true;
+}
+
+std::vector<int16_t> TestAdaptor::getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x)
+{
+    std::vector<int16_t> res{x.get<1>()};
+    auto y = std::get<std::vector<int16_t>>(x);
+    res.insert(res.end(), y.begin(), y.end());
+    return res;
+}
+
+sdbus::Variant TestAdaptor::processVariant(const sdbus::Variant& v)
+{
+    sdbus::Variant res = static_cast<int32_t>(v.get<double>());
+    return res;
+}
+
+std::map<int32_t, sdbus::Variant> TestAdaptor::getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
+{
+    std::map<int32_t, sdbus::Variant> res;
+    for (auto item : x)
+    {
+        res[item] = (item <= 0) ? std::get<0>(y) : std::get<1>(y);
+    }
+    return res;
+}
+
+sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> TestAdaptor::getStructInStruct()
+{
+    return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
+}
+
+int32_t TestAdaptor::sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
+{
+    int32_t res{0};
+    res += std::get<0>(a) + std::get<1>(a);
+    res += std::get<0>(b) + std::get<1>(b);
+    return res;
+}
+
+uint32_t TestAdaptor::sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
+{
+    uint32_t res{0};
+    for (auto x : a)
+    {
+        res += x;
+    }
+    for (auto x : b)
+    {
+        res += x;
+    }
+    return res;
+}
+
+uint32_t TestAdaptor::doOperation(const uint32_t& param)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(param));
+
+    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+
+    return param;
+}
+
+void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t param)
+{
+    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+
+    if (param == 0)
+    {
+        // Don't sleep and return the result from this thread
+        result.returnResults(param);
+    }
+    else
+    {
+        // Process asynchronously in another thread and return the result from there
+        std::thread([param, result = std::move(result)]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(param));
+            result.returnResults(param);
+        }).detach();
+    }
+}
+
+sdbus::Signature TestAdaptor::getSignature()
+{
+    return SIGNATURE_VALUE;
+}
+sdbus::ObjectPath TestAdaptor::getObjPath()
+{
+    return OBJECT_PATH_VALUE;
+}
+sdbus::UnixFd TestAdaptor::getUnixFd()
+{
+    return sdbus::UnixFd{UNIX_FD_VALUE};
+}
+
+std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> TestAdaptor::getComplex()
+{
+    return { // map
+        {
+            0,  // uint_64_t
+            {   // struct
+                {   // map
+                    {
+                        23,  // uint8_t
+                        {   // vector
+                            {   // struct
+                                    "/object/path", // object path
+                                    false,
+                                    Variant{3.14},
+                                    {   // map
+                                        {0, "zero"}
+                                    }
+                            }
+                        }
+                    }
+                },
+                "a{t(a{ya(obva{is})}gs)}", // signature
+                std::string{}
+            }
+        }
+    };
+}
+
+void TestAdaptor::throwError()
+{
+    m_wasThrowErrorCalled = true;
+    throw sdbus::createError(1, "A test error occurred");
+}
+
+void TestAdaptor::throwErrorWithNoReply()
+{
+    TestAdaptor::throwError();
+}
+
+void TestAdaptor::doPrivilegedStuff()
+{
+    // Intentionally left blank
+}
+
+void TestAdaptor::emitTwoSimpleSignals()
+{
+    emitSimpleSignal();
+    emitSignalWithMap({});
+}
+
+std::string TestAdaptor::state()
+{
+    return m_state;
+}
+
+uint32_t TestAdaptor::action()
+{
+    return m_action;
+}
+
+void TestAdaptor::action(const uint32_t& value)
+{
+    m_action = value;
+}
+
+bool TestAdaptor::blocking()
+{
+    return m_blocking;
+}
+
+void TestAdaptor::blocking(const bool& value)
+{
+    m_propertySetMsg = getObject().getCurrentlyProcessedMessage();
+    m_propertySetSender = m_propertySetMsg->getSender();
+
+    m_blocking = value;
+}
+
+void TestAdaptor::emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
+{
+    getObject().emitSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).withArguments(s);
+}
+
+std::string TestAdaptor::getExpectedXmlApiDescription() const
+{
+    return
+R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+<interface name="org.freedesktop.DBus.Peer">
+<method name="Ping"/>
+<method name="GetMachineId">
+<arg type="s" name="machine_uuid" direction="out"/>
+</method>
+</interface>
+<interface name="org.freedesktop.DBus.Introspectable">
+<method name="Introspect">
+<arg name="data" type="s" direction="out"/>
+</method>
+</interface>
+<interface name="org.freedesktop.DBus.Properties">
+<method name="Get">
+<arg name="interface" direction="in" type="s"/>
+<arg name="property" direction="in" type="s"/>
+<arg name="value" direction="out" type="v"/>
+</method>
+<method name="GetAll">
+<arg name="interface" direction="in" type="s"/>
+<arg name="properties" direction="out" type="a{sv}"/>
+</method>
+<method name="Set">
+<arg name="interface" direction="in" type="s"/>
+<arg name="property" direction="in" type="s"/>
+<arg name="value" direction="in" type="v"/>
+</method>
+<signal name="PropertiesChanged">
+<arg type="s" name="interface"/>
+<arg type="a{sv}" name="changed_properties"/>
+<arg type="as" name="invalidated_properties"/>
+</signal>
+</interface>
+<interface name="org.freedesktop.DBus.ObjectManager">
+<method name="GetManagedObjects">
+<arg type="a{oa{sa{sv}}}" name="object_paths_interfaces_and_properties" direction="out"/>
+</method>
+<signal name="InterfacesAdded">
+<arg type="o" name="object_path"/>
+<arg type="a{sa{sv}}" name="interfaces_and_properties"/>
+</signal>
+<signal name="InterfacesRemoved">
+<arg type="o" name="object_path"/>
+<arg type="as" name="interfaces"/>
+</signal>
+</interface>
+<interface name="org.sdbuscpp.integrationtests">
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+<method name="doOperation">
+<arg type="u" direction="in"/>
+<arg type="u" direction="out"/>
+</method>
+<method name="doOperationAsync">
+<arg type="u" direction="in"/>
+<arg type="u" direction="out"/>
+</method>
+<method name="doPrivilegedStuff">
+<annotation name="org.freedesktop.systemd1.Privileged" value="true"/>
+</method>
+<method name="emitTwoSimpleSignals">
+</method>
+<method name="getComplex">
+<arg type="a{t(a{ya(obva{is})}gs)}" direction="out"/>
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+</method>
+<method name="getInt">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="i" name="anInt" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="i" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</method>
+<method name="getInts16FromStruct">
+<arg type="(yndsan)" direction="in"/>
+<arg type="an" direction="out"/>
+</method>
+<method name="getMapOfVariants">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="ai" name="x" direction="in"/>
+<arg type="(vv)" name="y" direction="in"/>
+<arg type="a{iv}" name="aMapOfVariants" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="ai" direction="in"/>
+<arg type="(vv)" direction="in"/>
+<arg type="a{iv}" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</method>
+<method name="getObjPath">
+<arg type="o" direction="out"/>
+</method>
+<method name="getSignature">
+<arg type="g" direction="out"/>
+</method>
+<method name="getStructInStruct">
+<arg type="(s(a{ii}))" direction="out"/>
+</method>
+<method name="getTuple">
+<arg type="u" direction="out"/>
+<arg type="s" direction="out"/>
+</method>
+<method name="getUnixFd">
+<arg type="h" direction="out"/>
+</method>
+<method name="multiply">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="x" name="a" direction="in"/>
+<arg type="d" name="b" direction="in"/>
+<arg type="d" name="result" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="x" direction="in"/>
+<arg type="d" direction="in"/>
+<arg type="d" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</method>
+<method name="multiplyWithNoReply">
+<arg type="x" direction="in"/>
+<arg type="d" direction="in"/>
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+<annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
+</method>
+<method name="noArgNoReturn">
+</method>
+<method name="processVariant">
+<arg type="v" direction="in"/>
+<arg type="v" direction="out"/>
+</method>
+<method name="sumStructItems">
+<arg type="(yq)" direction="in"/>
+<arg type="(ix)" direction="in"/>
+<arg type="i" direction="out"/>
+</method>
+<method name="sumVectorItems">
+<arg type="aq" direction="in"/>
+<arg type="at" direction="in"/>
+<arg type="u" direction="out"/>
+</method>
+<method name="throwError">
+</method>
+<method name="throwErrorWithNoReply">
+<annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
+</method>
+<signal name="signalWithMap">
+<arg type="a{is}"/>
+</signal>
+<signal name="signalWithVariant">
+<arg type="v"/>
+</signal>
+<signal name="simpleSignal">
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+</signal>
+<property name="action" type="u" access="readwrite">
+<annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
+</property>
+<property name="blocking" type="b" access="readwrite">
+</property>
+<property name="state" type="s" access="read">
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+<annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="const"/>
+</property>
+</interface>
+</node>
+)delimiter";
+}
+
+}}
--- a/tests/integrationtests/TestAdaptor.h
+++ b/tests/integrationtests/TestAdaptor.h
@ -0,0 +1,98 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestAdaptor.h
+ *
+ * Created on: Jan 2, 2017
+ * 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_CPP_INTEGRATIONTESTS_TESTADAPTOR_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTADAPTOR_H_
+
+#include "integrationtests-adaptor.h"
+#include "Defs.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+namespace sdbus { namespace test {
+
+class TestAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::integrationtests_adaptor
+                                                         , sdbus::Properties_adaptor
+                                                         , sdbus::ObjectManager_adaptor >
+{
+public:
+    TestAdaptor(sdbus::IConnection& connection);
+    ~TestAdaptor();
+
+protected:
+    void noArgNoReturn() override;
+    int32_t getInt() override;
+    std::tuple<uint32_t, std::string> getTuple() override;
+    double multiply(const int64_t& a, const double& b) override;
+    void multiplyWithNoReply(const int64_t& a, const double& b) override;
+    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0) override;
+    sdbus::Variant processVariant(const sdbus::Variant& variant) override;
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) override;
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() override;
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) override;
+    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) override;
+    uint32_t doOperation(const uint32_t& arg0) override;
+    void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) override;
+    sdbus::Signature getSignature() override;
+    sdbus::ObjectPath getObjPath() override;
+    sdbus::UnixFd getUnixFd() override;
+    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() override;
+    void throwError() override;
+    void throwErrorWithNoReply() override;
+    void doPrivilegedStuff() override;
+    void emitTwoSimpleSignals() override;
+
+    uint32_t action() override;
+    void action(const uint32_t& value) override;
+    bool blocking() override;
+    void blocking(const bool& value) override;
+    std::string state() override;
+
+public:
+    void emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s);
+    std::string getExpectedXmlApiDescription() const;
+
+private:
+    const std::string m_state{DEFAULT_STATE_VALUE};
+    uint32_t m_action{DEFAULT_ACTION_VALUE};
+    bool m_blocking{DEFAULT_BLOCKING_VALUE};
+
+public: // for tests
+    // For dont-expect-reply method call verifications
+    mutable std::atomic<bool> m_wasMultiplyCalled{false};
+    mutable double m_multiplyResult{};
+    mutable std::atomic<bool> m_wasThrowErrorCalled{false};
+
+    const Message* m_methodCallMsg{};
+    std::string m_methodCallMemberName;
+    const Message* m_propertySetMsg{};
+    std::string m_propertySetSender;
+};
+
+}}
+
+#endif /* INTEGRATIONTESTS_TESTADAPTOR_H_ */
--- a/tests/integrationtests/TestFixture.cpp
+++ b/tests/integrationtests/TestFixture.cpp
@ -0,0 +1,33 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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/>.
+ */
+
+#include "TestFixture.h"
+
+namespace sdbus { namespace test {
+    
+std::unique_ptr<sdbus::IConnection> TestFixture::s_connection = sdbus::createSystemBusConnection();
+
+}}
--- a/tests/integrationtests/TestFixture.h
+++ b/tests/integrationtests/TestFixture.h
@ -0,0 +1,104 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestAdaptor.h
+ *
+ * Created on: Jan 2, 2017
+ * 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_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_
+
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "Defs.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <thread>
+#include <chrono>
+#include <atomic>
+#include <chrono>
+
+namespace sdbus { namespace test {
+
+class TestFixture : public ::testing::Test
+{
+public:
+    static void SetUpTestCase()
+    {
+        s_connection->requestName(INTERFACE_NAME);
+        s_connection->enterEventLoopAsync();
+    }
+
+    static void TearDownTestCase()
+    {
+        s_connection->leaveEventLoop();
+        s_connection->releaseName(INTERFACE_NAME);
+    }
+
+    template <typename _Fnc>
+    static bool waitUntil(_Fnc&& fnc, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+    {
+        using namespace std::chrono_literals;
+
+        std::chrono::milliseconds elapsed{};
+        std::chrono::milliseconds step{5ms};
+        do {
+            std::this_thread::sleep_for(step);
+            elapsed += step;
+            if (elapsed > timeout)
+                return false;
+        } while (!fnc());
+
+        return true;
+    }
+
+    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+    {
+        return waitUntil([&flag]() -> bool { return flag; }, timeout);
+    }
+
+private:
+    void SetUp() override
+    {
+        m_adaptor = std::make_unique<TestAdaptor>(*s_connection);
+        m_proxy = std::make_unique<TestProxy>(INTERFACE_NAME, OBJECT_PATH);
+        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Give time for the proxy to start listening to signals
+    }
+
+    void TearDown() override
+    {
+        m_proxy.reset();
+        m_adaptor.reset();
+    }
+
+public:
+    static std::unique_ptr<sdbus::IConnection> s_connection;
+
+    std::unique_ptr<TestAdaptor> m_adaptor;
+    std::unique_ptr<TestProxy> m_proxy;
+};
+
+}}
+
+#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_ */
--- a/tests/integrationtests/TestProxy.cpp
+++ b/tests/integrationtests/TestProxy.cpp
@ -0,0 +1,173 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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/>.
+ */
+
+#include "TestProxy.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+namespace sdbus { namespace test {
+    
+TestProxy::TestProxy(std::string destination, std::string 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); });
+
+    registerProxy();
+}
+
+TestProxy::TestProxy(sdbus::IConnection& connection, std::string destination, std::string 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); });
+
+    registerProxy();
+}
+
+TestProxy::~TestProxy()
+{
+    unregisterProxy();
+}
+
+void TestProxy::onSimpleSignal()
+{
+    m_signalMsg = getProxy().getCurrentlyProcessedMessage();
+    m_signalMemberName = m_signalMsg->getMemberName();
+
+    m_gotSimpleSignal = true;
+}
+
+void TestProxy::onSignalWithMap(const std::map<int32_t, std::string>& aMap)
+{
+    m_mapFromSignal = aMap;
+    m_gotSignalWithMap = true;
+}
+
+void TestProxy::onSignalWithVariant(const sdbus::Variant& aVariant)
+{
+    m_variantFromSignal = aVariant.get<double>();
+    m_gotSignalWithVariant = true;
+}
+
+void TestProxy::onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
+{
+    m_signatureFromSignal[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
+    m_gotSignalWithSignature = true;
+}
+
+void TestProxy::onDoOperationReply(uint32_t returnValue, const sdbus::Error* error)
+{
+    if (m_DoOperationClientSideAsyncReplyHandler)
+        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 )
+{
+    if (m_onPropertiesChangedHandler)
+        m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
+}
+
+void TestProxy::onInterfacesAdded(const sdbus::ObjectPath& objectPath, const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties)
+{
+    if (m_onInterfacesAddedHandler)
+        m_onInterfacesAddedHandler(objectPath, interfacesAndProperties);
+}
+
+void TestProxy::onInterfacesRemoved(const sdbus::ObjectPath& objectPath, const std::vector<std::string>& interfaces)
+{
+    if (m_onInterfacesRemovedHandler)
+        m_onInterfacesRemovedHandler(objectPath, interfaces);
+}
+
+void TestProxy::installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
+{
+    m_DoOperationClientSideAsyncReplyHandler = std::move(handler);
+}
+
+uint32_t TestProxy::doOperationWith500msTimeout(uint32_t param)
+{
+    using namespace std::chrono_literals;
+    uint32_t result;
+    getProxy().callMethod("doOperation").onInterface(sdbus::test::INTERFACE_NAME).withTimeout(500000us).withArguments(param).storeResultsTo(result);
+    return result;
+}
+
+sdbus::PendingAsyncCall TestProxy::doOperationClientSideAsync(uint32_t param)
+{
+    return getProxy().callMethodAsync("doOperation")
+                     .onInterface(sdbus::test::INTERFACE_NAME)
+                     .withArguments(param)
+                     .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                                      {
+                                          this->onDoOperationReply(returnValue, error);
+                                      });
+}
+
+void TestProxy::doErroneousOperationClientSideAsync()
+{
+    getProxy().callMethodAsync("throwError")
+              .onInterface(sdbus::test::INTERFACE_NAME)
+              .uponReplyInvoke([this](const sdbus::Error* error)
+                               {
+                                   this->onDoOperationReply(0, error);
+                               });
+}
+
+void TestProxy::doOperationClientSideAsyncWith500msTimeout(uint32_t param)
+{
+    using namespace std::chrono_literals;
+    getProxy().callMethodAsync("doOperation")
+              .onInterface(sdbus::test::INTERFACE_NAME)
+              .withTimeout(500000us)
+              .withArguments(param)
+              .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                               {
+                                   this->onDoOperationReply(returnValue, error);
+                               });
+}
+
+int32_t TestProxy::callNonexistentMethod()
+{
+    int32_t result;
+    getProxy().callMethod("callNonexistentMethod").onInterface(sdbus::test::INTERFACE_NAME).storeResultsTo(result);
+    return result;
+}
+
+int32_t TestProxy::callMethodOnNonexistentInterface()
+{
+    int32_t result;
+    getProxy().callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
+    return result;
+}
+
+void TestProxy::setStateProperty(const std::string& value)
+{
+    getProxy().setProperty("state").onInterface(sdbus::test::INTERFACE_NAME).toValue(value);
+}
+
+}}
--- a/tests/integrationtests/TestingProxy.h
+++ b/tests/integrationtests/TestingProxy.h
@ -2,7 +2,7 @@
 * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
 * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
 *
- * @file TestingProxy.h
+ * @file TestAdaptor.h
 *
 * Created on: Jan 2, 2017
 * Project: sdbus-c++
@ -24,93 +24,53 @@
 * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
 */

-#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
+#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_

-#include "proxy-glue.h"
+#include "integrationtests-proxy.h"
+#include "Defs.h"
+#include <thread>
+#include <chrono>
 #include <atomic>

-class TestingProxy : public sdbus::ProxyInterfaces< ::testing_proxy
-                                                  , sdbus::Peer_proxy
-                                                  , sdbus::Introspectable_proxy
-                                                  , sdbus::Properties_proxy
-                                                  , sdbus::ObjectManager_proxy >
+namespace sdbus { namespace test {
+
+class TestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integrationtests_proxy
+                                                     , sdbus::Peer_proxy
+                                                     , sdbus::Introspectable_proxy
+                                                     , sdbus::Properties_proxy
+                                                     , sdbus::ObjectManager_proxy >
 {
 public:
-    TestingProxy(std::string destination, std::string objectPath)
-        : ProxyInterfaces(std::move(destination), std::move(objectPath))
-    {
-        registerProxy();
-    }
-
-    TestingProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
-        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
-    {
-        registerProxy();
-    }
-
-    ~TestingProxy()
-    {
-        unregisterProxy();
-    }
-
-    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
-    {
-        m_DoOperationClientSideAsyncReplyHandler = handler;
-    }
+    TestProxy(std::string destination, std::string objectPath);
+    TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath);
+    ~TestProxy();

 protected:
-    void onSimpleSignal() override
-    {
-        m_gotSimpleSignal = true;
-    }
+    void onSimpleSignal() override;
+    void onSignalWithMap(const std::map<int32_t, std::string>& aMap) override;
+    void onSignalWithVariant(const sdbus::Variant& aVariant) override;

-    void onSignalWithMap(const std::map<int32_t, std::string>& m) override
-    {
-        m_mapFromSignal = m;
-        m_gotSignalWithMap = true;
-    }
-
-    void onSignalWithVariant(const sdbus::Variant& v) override
-    {
-        m_variantFromSignal = v.get<double>();
-        m_gotSignalWithVariant = true;
-    }
-
-    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s) override
-    {
-        m_signatureFromSignal[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
-        m_gotSignalWithSignature = true;
-    }
-
-    void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error) override
-    {
-        if (m_DoOperationClientSideAsyncReplyHandler)
-            m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
-    }
+    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s);
+    void onDoOperationReply(uint32_t returnValue, const 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
-    {
-        if (m_onPropertiesChangedHandler)
-            m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
-    }
-
+                            , const std::vector<std::string>& invalidatedProperties ) override;
    void onInterfacesAdded( const sdbus::ObjectPath& objectPath
-                          , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override
-    {
-        if (m_onInterfacesAddedHandler)
-            m_onInterfacesAddedHandler(objectPath, interfacesAndProperties);
-    }
-    void onInterfacesRemoved( const sdbus::ObjectPath& objectPath
-                            , const std::vector<std::string>& interfaces) override
-    {
-        if (m_onInterfacesRemovedHandler)
-            m_onInterfacesRemovedHandler(objectPath, interfaces);
-    }
+                          , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override;
+    void onInterfacesRemoved( const sdbus::ObjectPath& objectPath, const std::vector<std::string>& interfaces) override;
+
+public:
+    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler);
+    uint32_t doOperationWith500msTimeout(uint32_t param);
+    sdbus::PendingAsyncCall doOperationClientSideAsync(uint32_t param);
+    void doErroneousOperationClientSideAsync();
+    void doOperationClientSideAsyncWith500msTimeout(uint32_t param);
+    int32_t callNonexistentMethod();
+    int32_t callMethodOnNonexistentInterface();
+    void setStateProperty(const std::string& value);

 //private:
 public: // for tests
@ -127,6 +87,11 @@ public: // for tests
    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::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;
+
+    const Message* m_signalMsg{};
+    std::string m_signalMemberName;
 };

-#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_ */
+}}
+
+#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_ */
--- a/tests/integrationtests/TestingAdaptor.h
+++ b/tests/integrationtests/TestingAdaptor.h
@ -1,246 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file TestingAdaptor.h
- *
- * Created on: Jan 2, 2017
- * 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_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
-
-#include "adaptor-glue.h"
-#include <thread>
-#include <chrono>
-#include <atomic>
-
-class TestingAdaptor : public sdbus::AdaptorInterfaces< testing_adaptor
-                                                      , sdbus::Properties_adaptor
-                                                      , sdbus::ObjectManager_adaptor >
-{
-public:
-    TestingAdaptor(sdbus::IConnection& connection) :
-        AdaptorInterfaces(connection, OBJECT_PATH)
-    {
-        registerAdaptor();
-    }
-
-    ~TestingAdaptor()
-    {
-        unregisterAdaptor();
-    }
-
-protected:
-
-    void noArgNoReturn() const override
-    {
-    }
-
-    int32_t getInt() const override
-    {
-        return INT32_VALUE;
-    }
-
-    std::tuple<uint32_t, std::string> getTuple() const override
-    {
-        return std::make_tuple(UINT32_VALUE, STRING_VALUE);
-    }
-
-    double multiply(const int64_t& a, const double& b) const override
-    {
-        return a * b;
-    }
-
-    void multiplyWithNoReply(const int64_t& a, const double& b) const override
-    {
-        m_multiplyResult = a * b;
-        m_wasMultiplyCalled = true;
-    }
-
-    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const override
-    {
-        std::vector<int16_t> res{x.get<1>()};
-        auto y = std::get<std::vector<int16_t>>(x);
-        res.insert(res.end(), y.begin(), y.end());
-        return res;
-    }
-
-    sdbus::Variant processVariant(sdbus::Variant& v) override
-    {
-        sdbus::Variant res = static_cast<int32_t>(v.get<double>());
-        return res;
-    }
-
-    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const override
-    {
-        std::map<int32_t, sdbus::Variant> res;
-        for (auto item : x)
-        {
-            res[item] = (item <= 0) ? std::get<0>(y) : std::get<1>(y);
-        }
-        return res;
-    }
-
-    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const override
-    {
-        return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
-    }
-
-    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b) override
-    {
-        int32_t res{0};
-        res += std::get<0>(a) + std::get<1>(a);
-        res += std::get<0>(b) + std::get<1>(b);
-        return res;
-    }
-
-    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b) override
-    {
-        uint32_t res{0};
-        for (auto x : a)
-        {
-            res += x;
-        }
-        for (auto x : b)
-        {
-            res += x;
-        }
-        return res;
-    }
-
-    uint32_t doOperation(uint32_t param) override
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(param));
-        return param;
-    }
-
-    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) override
-    {
-        if (param == 0)
-        {
-            // Don't sleep and return the result from this thread
-            result.returnResults(param);
-        }
-        else
-        {
-            // Process asynchronously in another thread and return the result from there
-            std::thread([param, result = std::move(result)]()
-            {
-                std::this_thread::sleep_for(std::chrono::milliseconds(param));
-                result.returnResults(param);
-            }).detach();
-        }
-    }
-
-    sdbus::Signature getSignature() const override
-    {
-        return SIGNATURE_VALUE;
-    }
-    sdbus::ObjectPath getObjPath() const override
-    {
-        return OBJECT_PATH_VALUE;
-    }
-    sdbus::UnixFd getUnixFd() const override
-    {
-        return sdbus::UnixFd{UNIX_FD_VALUE};
-    }
-
-    ComplexType getComplex() const override
-    {
-        return { // map
-            {
-                0,  // uint_64_t
-                {   // struct
-                    {   // map
-                        {
-                            'a',  // uint8_t
-                            {   // vector
-                                {   // struct
-                                        "/object/path", // object path
-                                        false,
-                                        3.14,
-                                        {   // map
-                                            {0, "zero"}
-                                        }
-                                }
-                            }
-                        }
-                    },
-                    "a{t(a{ya(obva{is})}gs)}", // signature
-                    ""
-                }
-            }
-        };
-    }
-
-    void throwError() const override
-    {
-        m_wasThrowErrorCalled = true;
-        throw sdbus::createError(1, "A test error occurred");
-    }
-
-
-    void emitTwoSimpleSignals() override
-    {
-        emitSimpleSignal();
-        emitSignalWithMap({});
-    }
-
-    std::string state() override
-    {
-        return m_state;
-    }
-
-    uint32_t action() override
-    {
-        return m_action;
-    }
-
-    void action(const uint32_t& value) override
-    {
-        m_action = value;
-    }
-
-    bool blocking() override
-    {
-        return m_blocking;
-    }
-
-    void blocking(const bool& value) override
-    {
-        m_blocking = value;
-    }
-
-private:
-    const std::string m_state{DEFAULT_STATE_VALUE};
-    uint32_t m_action{DEFAULT_ACTION_VALUE};
-    bool m_blocking{DEFAULT_BLOCKING_VALUE};
-
-public: // for tests
-    // For dont-expect-reply method call verifications
-    mutable std::atomic<bool> m_wasMultiplyCalled{false};
-    mutable double m_multiplyResult{};
-    mutable std::atomic<bool> m_wasThrowErrorCalled{false};
-};
-
-
-
-#endif /* INTEGRATIONTESTS_TESTINGADAPTOR_H_ */
--- a/tests/integrationtests/adaptor-glue.h
+++ b/tests/integrationtests/adaptor-glue.h
@ -1,366 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file adaptor-glue.h
- *
- * Created on: Jan 2, 2017
- * 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_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_
-
-#include "defs.h"
-
-// sdbus
-#include "sdbus-c++/sdbus-c++.h"
-
-using ComplexType = std::map<
-                        uint64_t,
-                        sdbus::Struct<
-                            std::map<
-                                uint8_t,
-                                std::vector<
-                                    sdbus::Struct<
-                                        sdbus::ObjectPath,
-                                        bool,
-                                        sdbus::Variant,
-                                        std::map<int, std::string>
-                                    >
-                                >
-                            >,
-                            sdbus::Signature,
-                            std::string // char* leads to type and memory issues, std::string is best choice
-                        >
-                    >;
-
-class testing_adaptor
-{
-protected:
-    testing_adaptor(sdbus::IObject& object) :
-        object_(object)
-    {
-        object_.setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-
-        object_.registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
-        object_.registerMethod("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
-        object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getTuple(); });
-
-        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
-        object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](const int64_t& a, const double& b){ this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
-        object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).implementedAs([this](
-                const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x){ return this->getInts16FromStruct(x); });
-
-        object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Variant& v){ return this->processVariant(v); });
-
-        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME)
-                .withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](
-                const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x ,y); });
-
-        object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getStructInStruct(); });
-
-        object_.registerMethod("sumStructItems").onInterface(INTERFACE_NAME).implementedAs([this](
-                const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b){
-            return this->sumStructItems(a, b);
-        });
-
-        object_.registerMethod("sumVectorItems").onInterface(INTERFACE_NAME).implementedAs([this](
-                const std::vector<uint16_t>& a, const std::vector<uint64_t>& b){
-            return this->sumVectorItems(a, b);
-        });
-
-        object_.registerMethod("doOperation").onInterface(INTERFACE_NAME).implementedAs([this](uint32_t param)
-        {
-            return this->doOperation(param);
-        });
-
-        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<uint32_t> result, uint32_t param)
-        {
-            this->doOperationAsync(param, std::move(result));
-        });
-
-        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
-        object_.registerMethod("getObjPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjPath(); });
-        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getUnixFd(); });
-
-        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
-
-        object_.registerMethod("throwError").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwError(); });
-        object_.registerMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](){ this->throwError(); }).withNoReply();
-
-        object_.registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([](){}).markAsPrivileged();
-
-        object_.registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ this->emitTwoSimpleSignals(); });
-
-        // registration of signals is optional, it is useful because of introspection
-        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
-        // Note: sd-bus of libsystemd up to (including) v244 has a bug where it doesn't generate signal parameter names in introspection XML. Signal param names commented temporarily.
-        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>(/*"aMap"*/);
-        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>(/*"aVariant"*/);
-
-        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
-        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
-        //object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
-        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
-    }
-
-    ~testing_adaptor() = default;
-
-public:
-    void emitSimpleSignal()
-    {
-        object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
-    }
-
-    void emitSignalWithMap(const std::map<int32_t, std::string>& map)
-    {
-        object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(map);
-    }
-
-    void emitSignalWithVariant(const sdbus::Variant& v)
-    {
-        object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(v);
-    }
-
-    void emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
-    {
-        object_.emitSignal("signalWithoutRegistration").onInterface(INTERFACE_NAME).withArguments(s);
-    }
-
-    void emitSignalOnNonexistentInterface()
-    {
-        object_.emitSignal("simpleSignal").onInterface("sdbuscpp.interface.that.does.not.exist");
-    }
-
-private:
-    sdbus::IObject& object_;
-
-protected:
-
-    virtual void noArgNoReturn() const  = 0;
-    virtual int32_t getInt() const = 0;
-    virtual std::tuple<uint32_t, std::string> getTuple() const = 0;
-    virtual double multiply(const int64_t& a, const double& b) const = 0;
-    virtual void multiplyWithNoReply(const int64_t& a, const double& b) const = 0;
-    virtual std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const = 0;
-    virtual sdbus::Variant processVariant(sdbus::Variant& v) = 0;
-    virtual std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const = 0;
-    virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const = 0;
-    virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b) = 0;
-    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b) = 0;
-    virtual uint32_t doOperation(uint32_t param) = 0;
-    virtual void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) = 0;
-    virtual sdbus::Signature getSignature() const  = 0;
-    virtual sdbus::ObjectPath getObjPath() const = 0;
-    virtual sdbus::UnixFd getUnixFd() const  = 0;
-    virtual ComplexType getComplex() const = 0;
-    virtual void throwError() const = 0;
-    virtual void emitTwoSimpleSignals() = 0;
-
-    virtual std::string state() = 0;
-    virtual uint32_t action() = 0;
-    virtual void action(const uint32_t& value) = 0;
-    virtual bool blocking() = 0;
-    virtual void blocking(const bool& value) = 0;
-
-public: // For testing purposes
-    std::string getExpectedXmlApiDescription()
-    {
-        return
-R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
-"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
-<node>
- <interface name="org.freedesktop.DBus.Peer">
-  <method name="Ping"/>
-  <method name="GetMachineId">
-   <arg type="s" name="machine_uuid" direction="out"/>
-  </method>
- </interface>
- <interface name="org.freedesktop.DBus.Introspectable">
-  <method name="Introspect">
-   <arg name="data" type="s" direction="out"/>
-  </method>
- </interface>
- <interface name="org.freedesktop.DBus.Properties">
-  <method name="Get">
-   <arg name="interface" direction="in" type="s"/>
-   <arg name="property" direction="in" type="s"/>
-   <arg name="value" direction="out" type="v"/>
-  </method>
-  <method name="GetAll">
-   <arg name="interface" direction="in" type="s"/>
-   <arg name="properties" direction="out" type="a{sv}"/>
-  </method>
-  <method name="Set">
-   <arg name="interface" direction="in" type="s"/>
-   <arg name="property" direction="in" type="s"/>
-   <arg name="value" direction="in" type="v"/>
-  </method>
-  <signal name="PropertiesChanged">
-   <arg type="s" name="interface"/>
-   <arg type="a{sv}" name="changed_properties"/>
-   <arg type="as" name="invalidated_properties"/>
-  </signal>
- </interface>
- <interface name="org.freedesktop.DBus.ObjectManager">
-  <method name="GetManagedObjects">
-   <arg type="a{oa{sa{sv}}}" name="object_paths_interfaces_and_properties" direction="out"/>
-  </method>
-  <signal name="InterfacesAdded">
-   <arg type="o" name="object_path"/>
-   <arg type="a{sa{sv}}" name="interfaces_and_properties"/>
-  </signal>
-  <signal name="InterfacesRemoved">
-   <arg type="o" name="object_path"/>
-   <arg type="as" name="interfaces"/>
-  </signal>
- </interface>
- <interface name="org.sdbuscpp.integrationtests">
-  <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-  <method name="doOperation">
-   <arg type="u" direction="in"/>
-   <arg type="u" direction="out"/>
-  </method>
-  <method name="doOperationAsync">
-   <arg type="u" direction="in"/>
-   <arg type="u" direction="out"/>
-  </method>
-  <method name="doPrivilegedStuff">
-   <annotation name="org.freedesktop.systemd1.Privileged" value="true"/>
-  </method>
-  <method name="emitTwoSimpleSignals">
-  </method>
-  <method name="getComplex">
-   <arg type="a{t(a{ya(obva{is})}gs)}" direction="out"/>
-   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-  </method>
-  <method name="getInt">)delimiter"
-#if LIBSYSTEMD_VERSION>=242
-R"delimiter(
-   <arg type="i" name="anInt" direction="out"/>)delimiter"
-#else
-R"delimiter(
-   <arg type="i" direction="out"/>)delimiter"
-#endif
-R"delimiter(
-  </method>
-  <method name="getInts16FromStruct">
-   <arg type="(yndsan)" direction="in"/>
-   <arg type="an" direction="out"/>
-  </method>
-  <method name="getMapOfVariants">)delimiter"
-#if LIBSYSTEMD_VERSION>=242
-R"delimiter(
-   <arg type="ai" name="x" direction="in"/>
-   <arg type="(vv)" name="y" direction="in"/>
-   <arg type="a{iv}" name="aMapOfVariants" direction="out"/>)delimiter"
-#else
-R"delimiter(
-   <arg type="ai" direction="in"/>
-   <arg type="(vv)" direction="in"/>
-   <arg type="a{iv}" direction="out"/>)delimiter"
-#endif
-R"delimiter(
-  </method>
-  <method name="getObjPath">
-   <arg type="o" direction="out"/>
-  </method>
-  <method name="getSignature">
-   <arg type="g" direction="out"/>
-  </method>
-  <method name="getStructInStruct">
-   <arg type="(s(a{ii}))" direction="out"/>
-  </method>
-  <method name="getTuple">
-   <arg type="u" direction="out"/>
-   <arg type="s" direction="out"/>
-  </method>
-  <method name="getUnixFd">
-   <arg type="h" direction="out"/>
-  </method>
-  <method name="multiply">)delimiter"
-#if LIBSYSTEMD_VERSION>=242
-R"delimiter(
-   <arg type="x" name="a" direction="in"/>
-   <arg type="d" name="b" direction="in"/>
-   <arg type="d" name="result" direction="out"/>)delimiter"
-#else
-R"delimiter(
-   <arg type="x" direction="in"/>
-   <arg type="d" direction="in"/>
-   <arg type="d" direction="out"/>)delimiter"
-#endif
-R"delimiter(
-  </method>
-  <method name="multiplyWithNoReply">
-   <arg type="x" direction="in"/>
-   <arg type="d" direction="in"/>
-   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-   <annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
-  </method>
-  <method name="noArgNoReturn">
-  </method>
-  <method name="processVariant">
-   <arg type="v" direction="in"/>
-   <arg type="v" direction="out"/>
-  </method>
-  <method name="sumStructItems">
-   <arg type="(yq)" direction="in"/>
-   <arg type="(ix)" direction="in"/>
-   <arg type="i" direction="out"/>
-  </method>
-  <method name="sumVectorItems">
-   <arg type="aq" direction="in"/>
-   <arg type="at" direction="in"/>
-   <arg type="u" direction="out"/>
-  </method>
-  <method name="throwError">
-  </method>
-  <method name="throwErrorWithNoReply">
-   <annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
-  </method>
-  <signal name="signalWithMap">
-   <arg type="a{is}"/>
-  </signal>
-  <signal name="signalWithVariant">
-   <arg type="v"/>
-  </signal>
-  <signal name="simpleSignal">
-   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-  </signal>
-  <property name="action" type="u" access="readwrite">
-   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
-  </property>
-  <property name="blocking" type="b" access="readwrite">
-  </property>
-  <property name="state" type="s" access="read">
-   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="const"/>
-  </property>
- </interface>
-</node>
-)delimiter";
-    }
-
-};
-
-
-
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_ */
--- a/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf
+++ b/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf
@ -11,6 +11,9 @@
    <allow own="org.sdbuscpp.integrationtests"/>
    <allow send_destination="org.sdbuscpp.integrationtests"/>
    <allow send_interface="org.sdbuscpp.integrationtests"/>
+
+    <allow own="org.sdbuscpp.integrationtests2"/>
+    <allow send_destination="org.sdbuscpp.integrationtests2"/>
  </policy>

 </busconfig>
--- a/tests/integrationtests/integrationtests-adaptor.h
+++ b/tests/integrationtests/integrationtests-adaptor.h
@ -0,0 +1,109 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__integrationtests_adaptor_h__adaptor__H__
+#define __sdbuscpp__integrationtests_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class integrationtests_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+
+protected:
+    integrationtests_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        object_.setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
+        object_.registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
+        object_.registerMethod("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
+        object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).withOutputParamNames("arg0", "arg1").implementedAs([this](){ return this->getTuple(); });
+        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
+        object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").implementedAs([this](const int64_t& a, const double& b){ return this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
+        object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0){ return this->getInts16FromStruct(arg0); });
+        object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).withInputParamNames("variant").withOutputParamNames("result").implementedAs([this](const sdbus::Variant& variant){ return this->processVariant(variant); });
+        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x, y); });
+        object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).withOutputParamNames("aMapOfVariants").implementedAs([this](){ return this->getStructInStruct(); });
+        object_.registerMethod("sumStructItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1){ return this->sumStructItems(arg0, arg1); });
+        object_.registerMethod("sumVectorItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1){ return this->sumVectorItems(arg0, arg1); });
+        object_.registerMethod("doOperation").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const uint32_t& arg0){ return this->doOperation(arg0); });
+        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](sdbus::Result<uint32_t>&& result, uint32_t arg0){ this->doOperationAsync(std::move(result), std::move(arg0)); });
+        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getSignature(); });
+        object_.registerMethod("getObjPath").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getObjPath(); });
+        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getUnixFd(); });
+        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
+        object_.registerMethod("throwError").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwError(); });
+        object_.registerMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwErrorWithNoReply(); }).withNoReply();
+        object_.registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->doPrivilegedStuff(); }).markAsPrivileged();
+        object_.registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->emitTwoSimpleSignals(); });
+        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
+        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>("aMap");
+        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>("aVariant");
+        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
+        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
+        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
+    }
+
+    ~integrationtests_adaptor() = default;
+
+public:
+    void emitSimpleSignal()
+    {
+        object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
+    }
+
+    void emitSignalWithMap(const std::map<int32_t, std::string>& aMap)
+    {
+        object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(aMap);
+    }
+
+    void emitSignalWithVariant(const sdbus::Variant& aVariant)
+    {
+        object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(aVariant);
+    }
+
+private:
+    virtual void noArgNoReturn() = 0;
+    virtual int32_t getInt() = 0;
+    virtual std::tuple<uint32_t, std::string> getTuple() = 0;
+    virtual double multiply(const int64_t& a, const double& b) = 0;
+    virtual void multiplyWithNoReply(const int64_t& a, const double& b) = 0;
+    virtual std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0) = 0;
+    virtual sdbus::Variant processVariant(const sdbus::Variant& variant) = 0;
+    virtual std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) = 0;
+    virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() = 0;
+    virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) = 0;
+    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) = 0;
+    virtual uint32_t doOperation(const uint32_t& arg0) = 0;
+    virtual void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) = 0;
+    virtual sdbus::Signature getSignature() = 0;
+    virtual sdbus::ObjectPath getObjPath() = 0;
+    virtual sdbus::UnixFd getUnixFd() = 0;
+    virtual std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() = 0;
+    virtual void throwError() = 0;
+    virtual void throwErrorWithNoReply() = 0;
+    virtual void doPrivilegedStuff() = 0;
+    virtual void emitTwoSimpleSignals() = 0;
+
+private:
+    virtual uint32_t action() = 0;
+    virtual void action(const uint32_t& value) = 0;
+    virtual bool blocking() = 0;
+    virtual void blocking(const bool& value) = 0;
+    virtual std::string state() = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}} // namespaces
+
+#endif
--- a/tests/integrationtests/integrationtests-proxy.h
+++ b/tests/integrationtests/integrationtests-proxy.h
@ -0,0 +1,204 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__integrationtests_proxy_h__proxy__H__
+#define __sdbuscpp__integrationtests_proxy_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class integrationtests_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+
+protected:
+    integrationtests_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
+        proxy_.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
+        proxy_.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
+    }
+
+    ~integrationtests_proxy() = default;
+
+    virtual void onSimpleSignal() = 0;
+    virtual void onSignalWithMap(const std::map<int32_t, std::string>& aMap) = 0;
+    virtual void onSignalWithVariant(const sdbus::Variant& aVariant) = 0;
+
+public:
+    void noArgNoReturn()
+    {
+        proxy_.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t getInt()
+    {
+        int32_t result;
+        proxy_.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<uint32_t, std::string> getTuple()
+    {
+        std::tuple<uint32_t, std::string> result;
+        proxy_.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    double multiply(const int64_t& a, const double& b)
+    {
+        double result;
+        proxy_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
+        return result;
+    }
+
+    void multiplyWithNoReply(const int64_t& a, const double& b)
+    {
+        proxy_.callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
+    }
+
+    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0)
+    {
+        std::vector<int16_t> result;
+        proxy_.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Variant processVariant(const sdbus::Variant& variant)
+    {
+        sdbus::Variant result;
+        proxy_.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
+    {
+        std::map<int32_t, sdbus::Variant> result;
+        proxy_.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
+    {
+        sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
+        proxy_.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1)
+    {
+        int32_t result;
+        proxy_.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1)
+    {
+        uint32_t result;
+        proxy_.callMethod("sumVectorItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t doOperation(const uint32_t& arg0)
+    {
+        uint32_t result;
+        proxy_.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t doOperationAsync(const uint32_t& arg0)
+    {
+        uint32_t result;
+        proxy_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Signature getSignature()
+    {
+        sdbus::Signature result;
+        proxy_.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath getObjPath()
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::UnixFd getUnixFd()
+    {
+        sdbus::UnixFd result;
+        proxy_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex()
+    {
+        std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> result;
+        proxy_.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void throwError()
+    {
+        proxy_.callMethod("throwError").onInterface(INTERFACE_NAME);
+    }
+
+    void throwErrorWithNoReply()
+    {
+        proxy_.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
+    }
+
+    void doPrivilegedStuff()
+    {
+        proxy_.callMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME);
+    }
+
+    void emitTwoSimpleSignals()
+    {
+        proxy_.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
+    }
+
+public:
+    uint32_t action()
+    {
+        return proxy_.getProperty("action").onInterface(INTERFACE_NAME);
+    }
+
+    void action(const uint32_t& value)
+    {
+        proxy_.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool blocking()
+    {
+        return proxy_.getProperty("blocking").onInterface(INTERFACE_NAME);
+    }
+
+    void blocking(const bool& value)
+    {
+        proxy_.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    std::string state()
+    {
+        return proxy_.getProperty("state").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}} // namespaces
+
+#endif
--- a/tests/integrationtests/org.sdbuscpp.integrationtests.xml
+++ b/tests/integrationtests/org.sdbuscpp.integrationtests.xml
@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<node name="/org/sdbuscpp/integrationtest">
+    <interface name="org.sdbuscpp.integrationtests">
+        <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false" />
+        <method name="noArgNoReturn">
+        </method>
+        <method name="getInt">
+            <arg type="i" name="anInt" direction="out" />
+        </method>
+        <method name="getTuple">
+            <arg type="u" direction="out" />
+            <arg type="s" direction="out" />
+        </method>
+        <method name="multiply">
+            <arg type="x" name="a" direction="in" />
+            <arg type="d" name="b" direction="in" />
+            <arg type="d" name="result" direction="out" />
+        </method>
+        <method name="multiplyWithNoReply">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+            <annotation name="org.freedesktop.DBus.Method.NoReply" value="true" />
+            <arg type="x" name="a" direction="in" />
+            <arg type="d" name="b" direction="in" />
+        </method>
+        <method name="getInts16FromStruct">
+            <arg type="(yndsan)" direction="in" />
+            <arg type="an" direction="out" />
+        </method>
+        <method name="processVariant">
+            <arg type="v" name="variant" direction="in" />
+            <arg type="v" name="result" direction="out" />
+        </method>
+        <method name="getMapOfVariants">
+            <arg type="ai" name="x" direction="in" />
+            <arg type="(vv)" name="y" direction="in" />
+            <arg type="a{iv}" name="aMapOfVariants" direction="out" />
+        </method>
+        <method name="getStructInStruct">
+            <arg type="(s(a{ii}))" name="aMapOfVariants" direction="out" />
+        </method>
+        <method name="sumStructItems">
+            <arg type="(yq)" direction="in" />
+            <arg type="(ix)" direction="in" />
+            <arg type="i" direction="out" />
+        </method>
+        <method name="sumVectorItems">
+            <arg type="aq" direction="in" />
+            <arg type="at" direction="in" />
+            <arg type="u" direction="out" />
+        </method>
+        <method name="doOperation">
+            <arg type="u" direction="in" />
+            <arg type="u" direction="out" />
+        </method>
+        <method name="doOperationAsync">
+            <annotation name="org.freedesktop.DBus.Method.Async" value="server" />
+            <arg type="u" direction="in" />
+            <arg type="u" direction="out" />
+        </method>
+        <method name="getSignature">
+            <arg type="g" direction="out" />
+        </method>
+        <method name="getObjPath">
+            <arg type="o" direction="out" />
+        </method>
+        <method name="getUnixFd">
+            <arg type="h" direction="out" />
+        </method>
+        <method name="getComplex">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+            <arg type="a{t(a{ya(obva{is})}gs)}" direction="out" />
+        </method>
+        <method name="throwError">
+        </method>
+        <method name="throwErrorWithNoReply">
+            <annotation name="org.freedesktop.DBus.Method.NoReply" value="true" />
+        </method>
+        <method name="doPrivilegedStuff">
+            <annotation name="org.freedesktop.systemd1.Privileged" value="true" />
+        </method>
+        <method name="emitTwoSimpleSignals">
+        </method>
+        
+        <signal name="simpleSignal">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+        </signal>
+        <signal name="signalWithMap">
+            <arg type="a{is}" name="aMap" />
+        </signal>
+        <signal name="signalWithVariant">
+            <arg type="v" name="aVariant" />
+        </signal>
+        <property name="action" type="u" access="readwrite">
+            <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
+        </property>
+        <property name="blocking" type="b" access="readwrite">
+        </property>
+        <property name="state" type="s" access="read">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+            <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="const"/>
+        </property>
+    </interface>
+</node>        
--- a/tests/integrationtests/proxy-glue.h
+++ b/tests/integrationtests/proxy-glue.h
@ -1,282 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file proxy-glue.h
- *
- * Created on: Jan 2, 2017
- * 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_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_
-
-#include "defs.h"
-
-// sdbus
-#include "sdbus-c++/sdbus-c++.h"
-
-class testing_proxy
-{
-protected:
-    testing_proxy(sdbus::IProxy& object) :
-        object_(object)
-    {
-        object_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
-        object_.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& map){ this->onSignalWithMap(map); });
-        object_.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& v){ this->onSignalWithVariant(v); });
-
-        object_.uponSignal("signalWithoutRegistration").onInterface(INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
-                { this->onSignalWithoutRegistration(s); });
-    }
-
-    ~testing_proxy() = default;
-
-    virtual void onSimpleSignal() = 0;
-    virtual void onSignalWithMap(const std::map<int32_t, std::string>& map) = 0;
-    virtual void onSignalWithVariant(const sdbus::Variant& v) = 0;
-    virtual void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s) = 0;
-
-    virtual void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error) = 0;
-
-public:
-    void emitTwoSimpleSignals()
-    {
-        object_.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
-    }
-
-    void noArgNoReturn()
-    {
-        object_.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
-    }
-
-    int32_t getInt()
-    {
-        int32_t result;
-        object_.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    std::tuple<uint32_t, std::string> getTuple()
-    {
-        std::tuple<uint32_t, std::string> result;
-        object_.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    double multiply(const int64_t& a, const double& b)
-    {
-        double result;
-        object_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        return result;
-    }
-
-    void multiplyWithNoReply(const int64_t& a, const double& b)
-    {
-        object_.callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
-    }
-
-    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x)
-    {
-        std::vector<int16_t> result;
-        object_.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(x).storeResultsTo(result);
-        return result;
-     }
-
-    sdbus::Variant processVariant(const sdbus::Variant& v)
-    {
-        sdbus::Variant result;
-        object_.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(v).storeResultsTo(result);
-        return result;
-    }
-
-    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
-    {
-        std::map<int32_t, sdbus::Variant> result;
-        object_.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
-    {
-        sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
-        object_.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).withArguments().storeResultsTo(result);
-        return result;
-    }
-
-    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
-    {
-        int32_t result;
-        object_.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
-    {
-        uint32_t result;
-        object_.callMethod("sumVectorItems").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperation(uint32_t param)
-    {
-        uint32_t result;
-        object_.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperationWith500msTimeout(uint32_t param)
-    {
-        using namespace std::chrono_literals;
-        uint32_t result;
-        object_.callMethod("doOperation").onInterface(INTERFACE_NAME).withTimeout(500000us).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperationAsync(uint32_t param)
-    {
-        uint32_t result;
-        object_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::PendingAsyncCall doOperationClientSideAsync(uint32_t param)
-    {
-        return object_.callMethodAsync("doOperation")
-                      .onInterface(INTERFACE_NAME)
-                      .withArguments(param)
-                      .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
-                                       {
-                                           this->onDoOperationReply(returnValue, error);
-                                       });
-    }
-
-    void doErroneousOperationClientSideAsync()
-    {
-        object_.callMethodAsync("throwError")
-               .onInterface(INTERFACE_NAME)
-               .uponReplyInvoke([this](const sdbus::Error* error)
-                                {
-                                    this->onDoOperationReply(0, error);
-                                });
-    }
-
-    void doOperationClientSideAsyncWith500msTimeout(uint32_t param)
-    {
-        using namespace std::chrono_literals;
-        object_.callMethodAsync("doOperation")
-               .onInterface(INTERFACE_NAME)
-               .withTimeout(500000us)
-               .withArguments(param)
-               .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
-                                {
-                                    this->onDoOperationReply(returnValue, error);
-                                });
-    }
-
-    sdbus::Signature getSignature()
-    {
-        sdbus::Signature result;
-        object_.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::ObjectPath getObjPath()
-    {
-        sdbus::ObjectPath result;
-        object_.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::UnixFd getUnixFd()
-    {
-        sdbus::UnixFd result;
-        object_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    ComplexType getComplex()
-    {
-        ComplexType result;
-        object_.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    void throwError()
-    {
-        object_.callMethod("throwError").onInterface(INTERFACE_NAME);
-    }
-
-    void throwErrorWithNoReply()
-    {
-        object_.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
-    }
-
-    int32_t callNonexistentMethod()
-    {
-        int32_t result;
-        object_.callMethod("callNonexistentMethod").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    int32_t callMethodOnNonexistentInterface()
-    {
-        int32_t result;
-        object_.callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
-        return result;
-    }
-
-    std::string state()
-    {
-        return object_.getProperty("state").onInterface(INTERFACE_NAME);
-    }
-
-    void state(const std::string& value)
-    {
-        object_.setProperty("state").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-    uint32_t action()
-    {
-        return object_.getProperty("action").onInterface(INTERFACE_NAME);
-    }
-
-    void action(const uint32_t& value)
-    {
-        object_.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-    bool blocking()
-    {
-        return object_.getProperty("blocking").onInterface(INTERFACE_NAME);
-    }
-
-    void blocking(const bool& value)
-    {
-        object_.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-
-private:
-    sdbus::IProxy& object_;
-
-};
-
-
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_ */
--- a/tests/perftests/client.cpp
+++ b/tests/perftests/client.cpp
@ -39,7 +39,7 @@ using namespace std::chrono_literals;

 uint64_t totalDuration = 0;

-class PerftestProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::perftests_proxy>
+class PerftestProxy final : public sdbus::ProxyInterfaces<org::sdbuscpp::perftests_proxy>
 {
 public:
    PerftestProxy(std::string destination, std::string objectPath)
@ -54,7 +54,7 @@ public:
    }

 protected:
-    virtual void onDataSignal(const std::string& data) override
+    virtual void onDataSignal([[maybe_unused]] const std::string& data) override
    {
        static unsigned int counter = 0;
        static std::chrono::time_point<std::chrono::steady_clock> startTime;
--- a/tests/perftests/server.cpp
+++ b/tests/perftests/server.cpp
@ -36,7 +36,7 @@ using namespace std::chrono_literals;

 std::string createRandomString(size_t length);

-class PerftestAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::perftests_adaptor>
+class PerftestAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::perftests_adaptor>
 {
 public:
    PerftestAdaptor(sdbus::IConnection& connection, std::string objectPath)
--- a/tests/stresstests/sdbus-c++-stress-tests.cpp
+++ b/tests/stresstests/sdbus-c++-stress-tests.cpp
@ -53,7 +53,7 @@ using namespace std::string_literals;
 #define FAHRENHEIT_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstests/fahrenheit/thermometer"s
 #define CONCATENATOR_OBJECT_PATH "/org/sdbuscpp/stresstests/concatenator"s

-class CelsiusThermometerAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::celsius::thermometer_adaptor>
+class CelsiusThermometerAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::celsius::thermometer_adaptor>
 {
 public:
    CelsiusThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath)
@ -92,8 +92,8 @@ public:
    }
 };

-class FahrenheitThermometerAdaptor : public sdbus::AdaptorInterfaces< org::sdbuscpp::stresstests::fahrenheit::thermometer_adaptor
-                                                                    , org::sdbuscpp::stresstests::fahrenheit::thermometer::factory_adaptor >
+class FahrenheitThermometerAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::stresstests::fahrenheit::thermometer_adaptor
+                                                                          , org::sdbuscpp::stresstests::fahrenheit::thermometer::factory_adaptor >
 {
 public:
    FahrenheitThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath, bool isDelegate)
@ -222,7 +222,7 @@ public:
    }
 };

-class ConcatenatorAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::concatenator_adaptor>
+class ConcatenatorAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::concatenator_adaptor>
 {
 public:
    ConcatenatorAdaptor(sdbus::IConnection& connection, std::string objectPath)
@ -294,7 +294,7 @@ private:
    std::atomic<bool> exit_{};
 };

-class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::concatenator_proxy>
+class ConcatenatorProxy final : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::concatenator_proxy>
 {
 public:
    ConcatenatorProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
@ -309,7 +309,7 @@ public:
    }

 private:
-    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) override
+    virtual void onConcatenateReply(const std::string& result, [[maybe_unused]] const sdbus::Error* error) override
    {
        assert(error == nullptr);

@ -457,7 +457,7 @@ int main(int argc, char *argv[])

                FahrenheitThermometerProxy thermometer(con, SERVICE_1_BUS_NAME, FAHRENHEIT_THERMOMETER_OBJECT_PATH);
                uint32_t localCounter{};
-                uint32_t previousTemperature{};
+                [[maybe_unused]] uint32_t previousTemperature{};

                while (!stopClients)
                {
--- a/tests/unittests/Connection_test.cpp
+++ b/tests/unittests/Connection_test.cpp
@ -36,6 +36,7 @@ using ::testing::SetArgPointee;
 using ::testing::Return;
 using ::testing::NiceMock;
 using sdbus::internal::Connection;
+constexpr sdbus::internal::Connection::default_bus_t default_bus;
 constexpr sdbus::internal::Connection::system_bus_t system_bus;
 constexpr sdbus::internal::Connection::session_bus_t session_bus;
 constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
@ -49,9 +50,17 @@ protected:
    sd_bus* fakeBusPtr_ = reinterpret_cast<sd_bus*>(1);
 };

+using ADefaultBusConnection = ConnectionCreationTest;
 using ASystemBusConnection = ConnectionCreationTest;
 using ASessionBusConnection = ConnectionCreationTest;

+TEST_F(ADefaultBusConnection, OpensAndFlushesBusWhenCreated)
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
+    Connection(std::move(sdBusIntfMock_), default_bus);
+}
+
 TEST_F(ASystemBusConnection, OpensAndFlushesBusWhenCreated)
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
@ -66,11 +75,18 @@ TEST_F(ASessionBusConnection, OpensAndFlushesBusWhenCreated)
    Connection(std::move(sdBusIntfMock_), session_bus);
 }

+TEST_F(ADefaultBusConnection, ClosesAndUnrefsBusWhenDestructed)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
+    Connection(std::move(sdBusIntfMock_), default_bus);
+}
+
 TEST_F(ASystemBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
-    ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), system_bus);
 }

 TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
@ -80,6 +96,12 @@ TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
    Connection(std::move(sdBusIntfMock_), session_bus);
 }

+TEST_F(ADefaultBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), default_bus), sdbus::Error);
+}
+
 TEST_F(ASystemBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
@ -92,6 +114,13 @@ TEST_F(ASessionBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstructio
    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), session_bus), sdbus::Error);
 }

+TEST_F(ADefaultBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), default_bus), sdbus::Error);
+}
+
 TEST_F(ASystemBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
@ -128,6 +157,10 @@ protected:
    std::unique_ptr<Connection> con_;
 };

+template<> void AConnectionNameRequest<Connection::default_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+}
 template<> void AConnectionNameRequest<Connection::system_bus_t>::setUpBusOpenExpectation()
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
@ -150,7 +183,8 @@ template<> std::unique_ptr<Connection> AConnectionNameRequest<Connection::remote
    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), remote_system_bus, "some host");
 }

-typedef ::testing::Types< Connection::system_bus_t
+typedef ::testing::Types< Connection::default_bus_t
+                        , Connection::system_bus_t
                        , Connection::session_bus_t
                        , Connection::remote_system_bus_t
                        > BusTypeTags;
--- a/tests/unittests/Message_test.cpp
+++ b/tests/unittests/Message_test.cpp
@ -238,3 +238,29 @@ TEST(AMessage, CanCarryAComplexType)

    ASSERT_THAT(dataRead, Eq(dataWritten));
 }
+
+TEST(AMessage, CanPeekASimpleType)
+{
+    auto msg = sdbus::createPlainMessage();
+    msg << 123;
+    msg.seal();
+
+    std::string type;
+    std::string contents;
+    msg.peekType(type, contents);
+    ASSERT_THAT(type, "i");
+    ASSERT_THAT(contents, "");
+}
+
+TEST(AMessage, CanPeekContainerContents)
+{
+    auto msg = sdbus::createPlainMessage();
+    msg << std::map<int, std::string>{{1, "one"}, {2, "two"}};
+    msg.seal();
+
+    std::string type;
+    std::string contents;
+    msg.peekType(type, contents);
+    ASSERT_THAT(type, "a");
+    ASSERT_THAT(contents, "{is}");
+}
--- a/tests/unittests/mocks/SdBusMock.h
+++ b/tests/unittests/mocks/SdBusMock.h
@ -57,6 +57,7 @@ public:
    MOCK_METHOD3(sd_bus_emit_interfaces_added_strv, int(sd_bus *bus, const char *path, char **interfaces));
    MOCK_METHOD3(sd_bus_emit_interfaces_removed_strv, int(sd_bus *bus, const char *path, char **interfaces));

+    MOCK_METHOD1(sd_bus_open, int(sd_bus **ret));
    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
    MOCK_METHOD1(sd_bus_open_system, int(sd_bus **ret));
    MOCK_METHOD2(sd_bus_open_system_remote, int(sd_bus **ret, const char *host));
@ -73,6 +74,19 @@ public:

    MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
    MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
+
+    MOCK_METHOD2(sd_bus_message_set_destination, int(sd_bus_message *m, const char *destination));
+
+    MOCK_METHOD3(sd_bus_query_sender_creds, int(sd_bus_message *, uint64_t, sd_bus_creds **));
+    MOCK_METHOD1(sd_bus_creds_unref, sd_bus_creds*(sd_bus_creds *));
+
+    MOCK_METHOD2(sd_bus_creds_get_pid, int(sd_bus_creds *, pid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_uid, int(sd_bus_creds *, uid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_euid, int(sd_bus_creds *, uid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_gid, int(sd_bus_creds *, gid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_egid, int(sd_bus_creds *, gid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_supplementary_gids, int(sd_bus_creds *, const gid_t **));
+    MOCK_METHOD2(sd_bus_creds_get_selinux_context, int(sd_bus_creds *, const char **));
 };

 #endif //SDBUS_CXX_SDBUS_MOCK_H
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@ -4,7 +4,7 @@

 cmake_minimum_required(VERSION 3.5)

-project(sdbus-c++-tools)
+project(sdbus-c++-tools VERSION 0.8.3)

 include(GNUInstallDirs)

@ -43,9 +43,33 @@ set(CMAKE_CXX_STANDARD 14)

 add_executable(sdbus-c++-xml2cpp ${SDBUSCPP_XML2CPP_SRCS})
 target_link_libraries (sdbus-c++-xml2cpp ${EXPAT_LIBRARIES})
+target_include_directories(sdbus-c++-xml2cpp PRIVATE ${EXPAT_INCLUDE_DIRS})

 #----------------------------------
 # INSTALLATION
 #----------------------------------

-install(TARGETS sdbus-c++-xml2cpp EXPORT sdbus-c++-xml2cpp DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS sdbus-c++-xml2cpp EXPORT sdbus-c++-tools-targets DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT dev)
+
+#----------------------------------
+# CMAKE CONFIG & PACKAGE CONFIG
+#----------------------------------
+
+include(CMakePackageConfigHelpers)
+
+install(EXPORT sdbus-c++-tools-targets
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++-tools
+        NAMESPACE SDBusCpp::
+        COMPONENT dev)
+
+configure_package_config_file(cmake/sdbus-c++-tools-config.cmake.in cmake/sdbus-c++-tools-config.cmake
+                              INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
+write_basic_package_version_file(cmake/sdbus-c++-tools-config-version.cmake COMPATIBILITY SameMajorVersion)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-tools-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-tools-config-version.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++-tools
+        COMPONENT dev)
+
+configure_file(pkgconfig/sdbus-c++-tools.pc.in pkgconfig/sdbus-c++-tools.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++-tools.pc
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
--- a/tools/cmake/sdbus-c++-tools-config.cmake.in
+++ b/tools/cmake/sdbus-c++-tools-config.cmake.in
@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
+check_required_components("sdbus-c++-xml2cpp")
--- a/tools/pkgconfig/sdbus-c++-tools.pc.in
+++ b/tools/pkgconfig/sdbus-c++-tools.pc.in
@ -0,0 +1,8 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: @PROJECT_NAME@
+Description: Stub generator tool for sdbus-c++ library
+Version: @SDBUSCPP_VERSION@
Author	SHA1	Message	Date
Stanislav Angelovič	1d930f324e	update changelog: v0.9.0	2021-10-15 15:20:46 +02:00
Rolf Lussi	a341754533	add dependency to libsytemd-dev to sdbus-c++-dev package	2021-09-23 20:18:14 +02:00
Rolf Lussi	9cb8b89a01	add cpack to build debian packages, split the packages by components	2021-09-23 20:18:14 +02:00
Stanislav Angelovic	c422de641a	Support Error parameter in signal handlers	2021-09-17 19:25:39 +02:00
Stanislav Angelovic	d77bb6b869	Fix potential race condition in Object destruction	2021-09-17 19:03:15 +02:00
Stanislav Angelovič	8320429ef7	chore: add gperf dependency for libsystemd build	2021-09-17 18:31:04 +02:00
Stanislav Angelovič	a72e17b932	doc: add gperf dependency for libsystemd	2021-09-17 18:28:41 +02:00
Stanislav Angelovic	b4f5c0f46c	Catch sdbus-c++ exceptions flying from Proxy callbacks to libsystemd	2021-07-29 12:37:15 +02:00
Stanislav Angelovic	6433b38ed1	Add specific sections for tips and notes in the tutorial	2021-07-22 16:01:42 +02:00
Stanislav Angelovic	a95fcf5693	Make resetting loop thread ID exception-safe	2021-07-22 13:48:43 +02:00
David Leeds	022831b8c3	Avoid propagating msg unpack exceptions to event loop This change addresses conditions where an exception is thrown by the library upon receipt of a malformed message from an external source, and propagated up to the event loop with no chance of interception by the application. This issue is only experienced by proxy convenience APIs, as low-level APIs allow the application to unpack the message. Strategy: 1. For malformed signals received by proxies: ignore the signal. 2. For malformed async method responses, translate the unpack exception into an sdbus::Error, and pass it to the caller as expected.	2021-07-20 18:39:36 +02:00
Stanislav Angelovic	e16ffb1288	Provide access to D-Bus message in high-level API	2021-06-22 11:31:08 +02:00
David Leeds	75ea127374	connection: add createDefaultBusConnection() This internally calls sd_bus_open(), which automatically selects the system or session bus connection based on the presence and content of a DBUS_STARTER_BUS_TYPE environment variable and whether the calling process has root privileges. This option is very helpful when creating services and clients that will use the system bus in production, but connect to a session for testing. Additional changes: * Removed assertions null-checking make_unique() return values. make_unique() calls new, and new is expected to throw or abort on failure, making the assertions unhelpful. * Corrected a typo in the ClosesAndUnrefsBusWhenDestructed unit test for the system bus (tested the wrong function).	2021-06-21 15:55:23 +02:00
Sergey Bobrenok	d74365c535	docs: Add information about conan recipe	2021-06-15 15:27:29 +02:00
Benjamin Kaufmann	a5e94f07bf	Fix issue #135 : Segfault in Message::peekType() * Add missing nullptr check in Message::peekType(). * According to its specification, sd_bus_message_peek_type() sets a given contents parameter to NULL if the next element in a message is not a container. Since assigning a nullptr to a std::string has undefined behaviour (typically resulting in an invalid memory access), Message::peekType() must not assign contentsSig unconditionally.	2021-06-15 15:26:10 +02:00
Urs Ritzmann	fa9569fdd9	Issue 133 race in proxy destruct (#177 ) * fix construct/destruct order of mutex/data in AsnycCalls Destroying a mutex which might still be owned leads to undefined behaviour. It wasn't the case here but using the right order is more resistant to future bugs. * proxy AsnycCalls: don't leave map in unspecified state * fix 133: use thread-safe container for proxy interfaces list * proxy callback payload uses concrete signalData * proxy: revert adding the wrapper class InterfaceContainer It's no longer required and simplifies the locking logic. * Proxy: avoid additional lambda wrapper around signal callbacks As proposed in https://github.com/Kistler-Group/sdbus-cpp/pull/177#issuecomment-834439707 option 3. Still TODO: Avoid relying on std::map's non-invalidatable by adding just std::unique_ptr<Proxy::InterfaceData::SignalData> to the container. * proxy: add missing underscore prefix * proxy: put InterfaceData::SignalData into a unique_ptr This ways, we avoid relying on std::map's non-invalidatable references. * proxy: code style: get raw pointer directly * style: fix code style Co-authored-by: Stanislav Angelovic <stanislav.angelovic@siemens.com>	2021-06-03 18:53:38 +02:00
Marek Blaha	118faa58f6	Add API to get message path and message destination (#167 ) * Add API to get message path * Add API to get message destination * Handle NULL message fields interface and member Functions sd_bus_message_get_interface() and sd_bus_message_get_member() can return null in case the message does not use those fields or does not have them set.	2021-05-07 15:24:21 +02:00
David Leeds	d65744b1fc	Enable default construction of PendingAsyncCall (#180 ) This is helpful in use cases where a user defined class wants to store a PendingAsyncCall as a member variable, or in a STL container.	2021-05-07 15:22:07 +02:00
David Leeds	6df67469ad	proxy: add IProxy::getConnection() (#179 ) This provides access to the proxy's bus connection so code using the proxy does not need to store an external reference to it. A matching function is already available in IObject.	2021-05-06 16:52:02 +02:00
Stanislav Angelovic	b0a72cbe92	Make Message's setDestination() thread safe	2021-04-29 15:30:56 +00:00
Marek Blaha	5ee4c61a1b	Add API to set signal destination (#168 ) With this patch it is possible to create unicast signals.	2021-04-29 17:18:04 +02:00
craig-spannring	d46cbba23c	Add README and sdbus-c++ tutorial as additional pages in doxydocs (#153 ) Co-authored-by: Craig Spannring <craig.spannring@milnxpd001.mti.local> Co-authored-by: Stanislav Angelovič <angelovic.s@gmail.com>	2021-04-29 16:46:36 +02:00
Stanislav Angelovič	70778bfae0	Add note on BUILD_SHARED_LIBS CMake flag to README	2021-04-29 16:07:47 +02:00
Stanislav Angelovič	5f271abc0c	Add note on system bus security policy file to the tutorial	2021-04-29 15:52:06 +02:00
Stanislav Angelovič	bbffcbf49e	fix: minor documentation and test improvements (#166 ) * fix: minor documentation and test improvements * doc: add link to tests in standard interfaces tutorial secion * Update README.md Co-authored-by: Urs Ritzmann <urs.ritzmann@kistler.com> * Update docs/using-sdbus-c++.md Co-authored-by: Urs Ritzmann <urs.ritzmann@kistler.com> * Use cmake instead of make in build instructions Co-authored-by: Stanislav Angelovic <stanislav.angelovic@siemens.com> Co-authored-by: Urs Ritzmann <urs.ritzmann@kistler.com>	2021-04-28 12:05:14 +02:00
Michal Hučko	dc6d55a282	Provide CMake config and PkgConfig files for tools (#172 )	2021-04-28 11:15:47 +02:00
riuriuriu	3f54b5e762	comment sd_bus_match_signal() requires libsystemd v237	2021-04-13 15:59:35 +02:00
riuriuriu	fe8cdce107	update changelog: v0.8.4	2021-04-13 15:59:35 +02:00
riuriuriu	d47e9d1834	fix issue 145, signals are not filtered by sender	2021-04-13 15:59:35 +02:00
Urs Ritzmann	b9723850b8	add integrationtest for issue 145	2021-04-13 15:59:35 +02:00
riuriuriu	e1008dd8cf	reformat CMake linking	2021-04-13 11:02:20 +02:00
Luca Boccassi	fc9f770512	Find and link against pthread Building on SUSE fails, as std::thread usage requires linking against pthread: /usr/bin/c++ -fPIC -O2 -Wall -D_FORTIFY_SOURCE=2 -fstack-protector-strong -funwind-tables -fasynchronous-unwind-tables -fstack-clash-protection -Werror=return-type -flto=auto -DNDEBUG -O3 -DNDEBUG -flto=auto -Wl,--as-needed -Wl,--no-undefined -Wl,-z,now -shared -Wl,-soname,libsdbus-c++.so.0 -o libsdbus-c++.so.0.8.3 CMakeFiles/sdbus-c++-objlib.dir/src/Connection.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Error.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Message.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Object.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Proxy.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Types.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/Flags.cpp.o CMakeFiles/sdbus-c++-objlib.dir/src/VTableUtils.c.o CMakeFiles/sdbus-c++-objlib.dir/src/SdBus.cpp.o /usr/lib64/libsystemd.so /usr/lib64/gcc/x86_64-suse-linux/10/../../../../x86_64-suse-linux/bin/ld: /tmp/libsdbus-c++.so.0.8.3.uWoUml.ltrans0.ltrans.o: in function `sdbus::internal::Connection::enterEventLoopAsync()': <artificial>:(.text+0x2bb): undefined reference to `pthread_create' /usr/lib64/gcc/x86_64-suse-linux/10/../../../../x86_64-suse-linux/bin/ld: /tmp/libsdbus-c++.so.0.8.3.uWoUml.ltrans0.ltrans.o: in function `non-virtual thunk to sdbus::internal::Connection::enterEventLoopAsync()': <artificial>:(.text+0x37a): undefined reference to `pthread_create' collect2: error: ld returned 1 exit status	2021-04-13 10:56:43 +02:00
alivenets	5e03e78451	feat: add API to get message credentials (#151 ) * sdbus-cpp: Add API to get message credentials Signed-off-by: Alexander Livenets <a.livenets@gmail.com> * fix: add <sys/types.h> include for gid_t and other types Co-authored-by: Stanislav Angelovič <angelovic.s@gmail.com>	2021-03-12 14:14:23 +01:00
Knut Tidemann	3f74512f8e	cmake: fix building with BUILD_LIBSYSTEMD and ninja generator (#138 ) The ninja generator requires the BUILD_BYPRODUCTS specifier to work out the dependencies.	2021-03-12 14:07:10 +01:00
Michael Davis	0090ca97ee	fix: missing copy assignment operator (#120 ) Explicitly list default copy assignment operator otherwise it is deleted in gcc 8.3.	2021-03-12 14:03:25 +01:00
Stanislav Angelovic	a649a0225e	style: fix indentation in CMakeLists.txt	2021-03-12 14:01:02 +01:00
Yonggang Luo	cfb9956de6	Fixes for floating point systemd version such as 243.4 (#128 ) ``` ~/package $ pkg-config --modversion libsystemd 243.4 ~/package $ ``` Split it to the list and use the first one	2021-03-12 13:26:21 +01:00
bobrofon	fb008445b1	xml2cpp: Add missing EXPAT include dirs (#136 ) This patch is required if EXPAT library is installed in non-standard location. Without 'target_include_directories' cmake will find EXPAT library: ... -- Found EXPAT: .../lib/libexpat.a (found version "2.2.10") ... But 'xml.cpp' compilation will fail with error: ... tools/xml2cpp-codegen/xml.cpp:7:10: fatal error: expat.h: No such file or directory 7 \| #include <expat.h> ...	2021-03-12 13:17:55 +01:00
Cameron Nemo	1e2a09cccf	docs: note expat dependency (#131 ) * docs: note expat dependency * Add description for expat dependency Co-authored-by: Stanislav Angelovič <angelovic.s@gmail.com>	2021-03-12 13:15:07 +01:00
Stanislav Angelovič	a9f2043daa	Fix examples in the tutorial Remove sdbus:: namespace in injected-class-name of the template base class in c-tor initialization list	2021-03-10 09:49:25 +01:00
Stanislav Angelovič	96b2dfff69	Update using-sdbus-c++.md Fix name of class in destructor	2021-03-09 17:04:43 +01:00
Stanislav Angelovič	d6fdacafbe	Try to first find googletest in the system before downloading it (#125 )	2020-11-16 17:05:36 +01:00
Stanislav Angelovic	b190646aa5	Make a note in README about an exception for LGPL license	2020-10-11 14:27:14 +02:00
Stanislav Angelovic	1c56f069dd	Add license exception for template code in header files	2020-10-11 14:25:14 +02:00
Stanislav Angelovic	6e8e5aadb6	Bump up to v0.8.3	2020-09-11 22:29:15 +02:00
Stanislav Angelovič	3b735bf1aa	Introduce CI workflow based on GitHub Actions (#114 ) This introduces GitHub CI which runs builds and tests in a matrix configuration. It also changes the systemd repo to stable one. And puts the CI badge (plus a few more badges) to the README page. Fixes #44	2020-07-22 16:35:42 +02:00
Stanislav Angelovic	2f7b35c5a8	Fix unused variable warnings for release builds	2020-07-21 15:44:16 +02:00
Stanislav Angelovic	d5867e1197	Fix unused variable warning for release builds	2020-07-21 15:32:31 +02:00
Stanislav Angelovic	250aa2bbe3	Add additional messages to CMake build for optional parts	2020-07-21 12:12:14 +02:00
Stanislav Angelovic	e63357b222	Remove non-virtual-dtor warnings by making classes final	2020-07-21 11:12:57 +02:00
Stanislav Angelovič	2c6be0307f	Update CMake configuration flag names	2020-07-19 18:23:19 +02:00
sangelovic	138a437b22	Fix #112 : Address a few inconsistencies and make code more idiomatic	2020-07-18 20:47:05 +02:00
sangelovic	cc8d88cc64	Fix GetObjectPath() in integration tests	2020-07-18 20:30:51 +02:00
sangelovic	bded067496	Fix #43 : Clean up integration tests	2020-07-18 20:21:47 +02:00
Tomas Pecka	c1c4512f9f	Fix build with gcc8.3 sdbus::ObjectPath and sdbus::Signature copy constructors are implicitly declared as deleted when compiling with Linaro's ARM toolchain [1] gcc8.3. Explicitly listing the copy constructors for affected classes fixes the problem. [1] https://www.linaro.org/	2020-07-16 18:53:18 +02:00