diff --git a/CMakeLists.txt b/CMakeLists.txt
index cf91436af..b7bdc86f7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,360 +1,359 @@
 cmake_minimum_required(VERSION 3.5)
 
 set(PIM_VERSION "5.13.41")
 project(Akonadi VERSION ${PIM_VERSION})
 
 if (MSVC)
     # On Windows our target compiler is MSVC 14.14, which supports C++17, so
     # we can enable it. MSVC does not ship experimental/optional and similar
     # and disallows use of C++17 classes in C++14 mode.
     set(CMAKE_CXX_STANDARD 17)
 else()
     # On Linux, MacOS and BSD we need to support older compilers that only
     # offer C++14.
     set(CMAKE_CXX_STANDARD 14)
     set(WITH_3RDPARTY_OPTIONAL TRUE)
 endif()
 
 
 # ECM setup
 set(KF5_MIN_VERSION "5.67.0")
 
 find_package(ECM ${KF5_MIN_VERSION} CONFIG REQUIRED)
 
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 include(ECMGeneratePriFile)
 
 include(ECMSetupVersion)
 include(FeatureSummary)
 include(CheckIncludeFiles)
 include(ECMQtDeclareLoggingCategory)
 include(CheckSymbolExists)
 
 include(KDEPackageAppTemplates)
 include(ECMMarkNonGuiExecutable)
 include(ECMAddTests)
 
 include(AkonadiMacros)
 
 set(QT_REQUIRED_VERSION "5.12.0")
 set(RELEASE_SERVICE_VERSION "20.03.70")
 set(AKONADI_FULL_VERSION "${PIM_VERSION} (${RELEASE_SERVICE_VERSION})")
 
 configure_file(akonadifull-version.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/akonadifull-version.h @ONLY)
 
 
 ecm_setup_version(PROJECT
     VARIABLE_PREFIX AKONADI
     VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/akonadi_version.h"
     PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5AkonadiConfigVersion.cmake"
     SOVERSION 5)
 
 # Find packages
 find_package(Qt5Core ${QT_REQUIRED_VERSION} REQUIRED COMPONENTS Private)
 find_package(Qt5Sql ${QT_REQUIRED_VERSION} REQUIRED COMPONENTS Private)
 find_package(Qt5DBus ${QT_REQUIRED_VERSION} REQUIRED)
 find_package(Qt5Network ${QT_REQUIRED_VERSION} REQUIRED)
 find_package(Qt5Test ${QT_REQUIRED_VERSION} REQUIRED)
 find_package(Qt5Widgets ${QT_REQUIRED_VERSION} REQUIRED)
 find_package(Qt5Xml ${QT_REQUIRED_VERSION} REQUIRED)
 
 find_package(KF5Config ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
-find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemViews ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5KIO ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5WidgetsAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5Crash ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(Qt5Designer NO_MODULE)
 set_package_properties(Qt5Designer PROPERTIES
    PURPOSE "Required to build the Qt Designer plugins"
    TYPE OPTIONAL
 )
 
 option(BUILD_DESIGNERPLUGIN "Build plugin for Qt Designer" ON)
 add_feature_info(DESIGNERPLUGIN ${BUILD_DESIGNERPLUGIN} "Build plugin for Qt Designer")
 
 set(Boost_MINIMUM_VERSION "1.34.0")
 find_package(Boost ${Boost_MINIMUM_VERSION})
 set_package_properties(Boost PROPERTIES
     DESCRIPTION "Boost C++ Libraries"
     URL "https://www.boost.org"
     TYPE REQUIRED
 )
 
 set(AccountsQt5_MINIMUM_VERSION "1.15")
 find_package(AccountsQt5 ${AccountsQt5_MINIMUM_VERSION})
 set_package_properties(AccountsQt5 PROPERTIES
     DESCRIPTION "Qt bindings for the Accounts framework"
     URL "https://gitlab.com/accounts-sso/libaccounts-qt"
     TYPE OPTIONAL
 )
 set(KAccounts_MINIMUM_VERSION "19.08.0")
 find_package(KAccounts ${KAccounts_MINIMUM_VERSION})
 set_package_properties(KAccounts PROPERTIES
     DESCRIPTION "KDE library for Accounts framework integration"
     URL "https://cgit.kde.org/kaccounts-integration.git"
     TYPE OPTIONAL
 )
 if (${AccountsQt5_FOUND} AND ${KAccounts_FOUND})
     set(WITH_ACCOUNTS TRUE)
 endif()
 
 
 if(BUILD_TESTING)
     set(AKONADI_TESTS_EXPORT AKONADICORE_EXPORT)
     set(AKONADIWIDGET_TESTS_EXPORT AKONADIWIDGETS_EXPORT)
     add_definitions(-DBUILD_TESTING)
 endif()
 configure_file(akonaditests_export.h.in "${CMAKE_CURRENT_BINARY_DIR}/akonaditests_export.h")
 configure_file(akonadiwidgetstests_export.h.in "${CMAKE_CURRENT_BINARY_DIR}/akonadiwidgetstests_export.h")
 
 # Make sure the KF5Akonadi_DATA_DIR is absolute before passing it to KF5AkonadiConfig.cmake.in
 # otherwise build fails either on OSX CI, or for normal users
 if (IS_ABSOLUTE "${KDE_INSTALL_DATADIR_KF5}")
     set(KF5Akonadi_DATA_DIR "${KDE_INSTALL_DATADIR_KF5}/akonadi")
 else()
     set(KF5Akonadi_DATA_DIR "${CMAKE_INSTALL_PREFIX}/${KDE_INSTALL_DATADIR_KF5}/akonadi")
 endif()
 
 check_symbol_exists(malloc_trim "malloc.h" HAVE_MALLOC_TRIM)
 
 ############### Build Options ###############
 option(AKONADI_BUILD_QSQLITE "Build the Sqlite backend." TRUE)
 option(BUILD_TOOLS "Build and install tools for development and testing purposes." TRUE)
 option(NO_REGENERATE_MIME "Don't regenerate mime file (developer-only option)" FALSE )
 option(INSTALL_APPARMOR "Install AppArmor profiles" TRUE)
 
 if(BUILD_TESTING)
    set(BUILD_TOOLS TRUE)
 endif()
 
 set(SMI_MIN_VERSION "1.3")
 find_package(SharedMimeInfo ${SMI_MIN_VERSION} REQUIRED)
 
 find_program(XSLTPROC_EXECUTABLE xsltproc)
 if(NOT XSLTPROC_EXECUTABLE)
     message(FATAL_ERROR "\nThe command line XSLT processor program 'xsltproc'  could not be found.\nPlease install xsltproc.\n")
 endif()
 
 find_program(MYSQLD_EXECUTABLE NAMES mysqld
     PATHS /usr/sbin /usr/local/sbin /usr/libexec /usr/local/libexec /opt/mysql/libexec /usr/mysql/bin /opt/mysql/sbin
     DOC "The mysqld executable path. ONLY needed at runtime"
 )
 
 if(MYSQLD_EXECUTABLE)
     message(STATUS "MySQL Server found: ${MYSQLD_EXECUTABLE}")
 else()
     message(STATUS "MySQL Server wasn't found. it is required to use the MySQL backend.")
 endif()
 
 find_path(POSTGRES_PATH NAMES pg_ctl
     HINTS /usr/lib${LIB_SUFFIX}/postgresql/8.4/bin
           /usr/lib${LIB_SUFFIX}/postgresql/9.0/bin
           /usr/lib${LIB_SUFFIX}/postgresql/9.1/bin
           DOC "The pg_ctl executable path. ONLY needed at runtime by the PostgreSQL backend"
 )
 
 if(POSTGRES_PATH)
     message(STATUS "PostgreSQL Server found.")
 else()
     message(STATUS "PostgreSQL wasn't found. it is required to use the Postgres backend.")
 endif()
 
 
 if("${DATABASE_BACKEND}" STREQUAL "SQLITE")
     set(SQLITE_TYPE "REQUIRED")
 else()
     set(SQLITE_TYPE "OPTIONAL")
 endif()
 
 if(AKONADI_BUILD_QSQLITE)
     set(SQLITE_MIN_VERSION 3.6.23)
     find_package(Sqlite ${SQLITE_MIN_VERSION})
     set_package_properties(Sqlite PROPERTIES
         URL "https://www.sqlite.org"
         DESCRIPTION "The Sqlite database library"
         TYPE ${SQLITE_TYPE}
         PURPOSE "Required by the Sqlite backend"
     )
 endif()
 
 find_program(XMLLINT_EXECUTABLE xmllint)
 if(NOT XMLLINT_EXECUTABLE)
     message(STATUS "xmllint not found, skipping akonadidb.xml schema validation")
 endif()
 
 check_include_files(unistd.h HAVE_UNISTD_H)
 if(HAVE_UNISTD_H)
     add_definitions(-DHAVE_UNISTD_H)
 endif()
 
 if (IS_ABSOLUTE "${DBUS_INTERFACES_INSTALL_DIR}")
     set(AKONADI_DBUS_INTERFACES_INSTALL_DIR "${DBUS_INTERFACES_INSTALL_DIR}")
 else()
     set(AKONADI_DBUS_INTERFACES_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${DBUS_INTERFACES_INSTALL_DIR}")
 endif()
 
 if (IS_ABSOLUTE "${KDE_INSTALL_INCLUDEDIR_KF5}")
     set(AKONADI_INCLUDE_DIR "${KDE_INSTALL_INCLUDEDIR_KF5}")
 else()
     set(AKONADI_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/${KDE_INSTALL_INCLUDEDIR_KF5}")
 endif()
 
 ############### Build Options ###############
 
 include(CTest)  # Calls enable_testing().
 include(CTestConfig.cmake)
 
 if(NOT DEFINED DATABASE_BACKEND)
     set(DATABASE_BACKEND "MYSQL" CACHE STRING "The default database backend to use for Akonadi. Can be either MYSQL, POSTGRES or SQLITE")
 endif()
 
 ############### CTest options ###############
 # Set a timeout value of 1 minute per test
 set(DART_TESTING_TIMEOUT 60)
 
 # CTestCustom.cmake has to be in the CTEST_BINARY_DIR.
 # in the KDE build system, this is the same as CMAKE_BINARY_DIR.
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CTestCustom.cmake ${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake COPYONLY)
 
 ############### Macros ###############
 
 macro(SET_DEFAULT_DB_BACKEND)
     set(_backend ${ARGV0})
     if("${_backend}" STREQUAL "SQLITE")
         set(AKONADI_DATABASE_BACKEND QSQLITE3)
         set(AKONADI_BUILD_QSQLITE TRUE)
     else()
         if("${_backend}" STREQUAL "POSTGRES")
           set(AKONADI_DATABASE_BACKEND QPSQL)
         else()
           set(AKONADI_DATABASE_BACKEND QMYSQL)
         endif()
     endif()
 
     message(STATUS "Using default db backend ${AKONADI_DATABASE_BACKEND}")
     add_definitions(-DAKONADI_DATABASE_BACKEND="${AKONADI_DATABASE_BACKEND}")
 endmacro()
 
 #### DB BACKEND DEFAULT ####
 set_default_db_backend(${DATABASE_BACKEND})
 
 ############### Compilers flags ###############
 
 if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_C_COMPILER MATCHES "icc" OR (CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
     set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -Wno-long-long -std=iso9899:1990 -Wundef -Wcast-align -Werror-implicit-function-declaration -Wchar-subscripts -Wall -Wextra -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -fno-common")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wnon-virtual-dtor -Wundef -Wcast-align -Wchar-subscripts -Wall -Wextra -Wpointer-arith -Wformat-security -fno-common -pedantic")
 
     set(CMAKE_CXX_FLAGS_DEBUGFULL "-g3 -fno-inline" CACHE STRING "Flags used by the C++ compiler during debugfull builds." FORCE)
     set(CMAKE_C_FLAGS_DEBUGFULL   "-g3 -fno-inline" CACHE STRING "Flags used by the C compiler during debugfull builds." FORCE)
     mark_as_advanced(CMAKE_CXX_FLAGS_DEBUGFULL CMAKE_C_FLAGS_DEBUGFULL)
 elseif (MSVC)
     # This sets the __cplusplus macro to a real value based on the version of C++ specified by
     # the /std switch. Without it MSVC keeps reporting C++98, so feature detection doesn't work.
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus")
 endif()
 
 
 if(MSVC)
     set(_ENABLE_EXCEPTIONS -EHsc)
 else()
     set(_ENABLE_EXCEPTIONS -fexceptions)
 endif()
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${_ENABLE_EXCEPTIONS}")
 
 ############### Configure files #############
 
 configure_file(akonadi-prefix.h.cmake ${Akonadi_BINARY_DIR}/akonadi-prefix.h)
 configure_file(config-akonadi.h.cmake ${Akonadi_BINARY_DIR}/config-akonadi.h)
 
 ############### build targets ###############
 
 add_definitions(-DTRANSLATION_DOMAIN=\"libakonadi5\")
 
 include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     src
 )
 
 #add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x060000)
 
 add_subdirectory(src)
 add_subdirectory(icons)
 
 add_subdirectory(templates)
 
 if(BUILD_TOOLS)
     # add testrunner (application for managing a self-contained
     # test environment)
     add_subdirectory(autotests/libs/testrunner)
     add_subdirectory(autotests/libs/testresource)
     add_subdirectory(autotests/libs/testsearchplugin)
 endif()
 
 if(BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests)
 endif()
 
 if(INSTALL_APPARMOR)
    add_subdirectory(apparmor)
 endif()
 
 ############### install stuff ###############
 
 install(FILES akonadi-mime.xml DESTINATION ${XDG_MIME_INSTALL_DIR})
 if (NOT NO_REGENERATE_MIME)
    update_xdg_mimetypes(${XDG_MIME_INSTALL_DIR})
 endif()   
 
 ############### CMake Config Files ###############
 
 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5Akonadi")
 
 configure_package_config_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/KF5AkonadiConfig.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/KF5AkonadiConfig.cmake"
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR}
     PATH_VARS AKONADI_DBUS_INTERFACES_INSTALL_DIR
               AKONADI_INCLUDE_DIR
               KF5Akonadi_DATA_DIR
 )
 
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/KF5AkonadiConfig.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/KF5AkonadiConfigVersion.cmake"
     "${CMAKE_CURRENT_SOURCE_DIR}/KF5AkonadiMacros.cmake"
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     COMPONENT Devel
 )
 
 install(EXPORT
     KF5AkonadiTargets
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     FILE KF5AkonadiTargets.cmake
     NAMESPACE KF5::)
 
 install(FILES akonadi.categories akonadi.renamecategories  DESTINATION  ${KDE_INSTALL_LOGGINGCATEGORIESDIR})
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/akonadi_version.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5} COMPONENT Devel
 )
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/KF5AkonadiConfig.cmake.in b/KF5AkonadiConfig.cmake.in
index fe84bf936..421e1df9e 100644
--- a/KF5AkonadiConfig.cmake.in
+++ b/KF5AkonadiConfig.cmake.in
@@ -1,47 +1,46 @@
 @PACKAGE_INIT@
 
 # set the directories
 if(NOT AKONADI_INSTALL_DIR)
    set(AKONADI_INSTALL_DIR "@CMAKE_INSTALL_PREFIX@")
 endif(NOT AKONADI_INSTALL_DIR)
 include(CMakeFindDependencyMacro)
 find_dependency(KF5Config "@KF5_MIN_VERSION@")
 find_dependency(KF5ConfigWidgets "@KF5_MIN_VERSION@")
 find_dependency(KF5CoreAddons "@KF5_MIN_VERSION@")
 find_dependency(KF5ItemModels "@KF5_MIN_VERSION@")
 find_dependency(KF5XmlGui "@KF5_MIN_VERSION@")
 
 find_dependency(Qt5Core "@QT_REQUIRED_VERSION@")
 find_dependency(Qt5DBus "@QT_REQUIRED_VERSION@")
 find_dependency(Qt5Gui "@QT_REQUIRED_VERSION@")
 find_dependency(Qt5Network "@QT_REQUIRED_VERSION@")
 find_dependency(Qt5Widgets "@QT_REQUIRED_VERSION@")
 find_dependency(Qt5Xml "@QT_REQUIRED_VERSION@")
 
 if(BUILD_TESTING)
     # Link targets required by KF5AkonadiMacros.cmake
-    find_dependency(KF5DBusAddons "@KF5_MIN_VERSION@")
     find_dependency(KF5KIO "@KF5_MIN_VERSION@")
     find_dependency(Qt5Test "@QT_REQUIRED_VERSION@")
 endif()
 
 set_and_check(AKONADI_DBUS_INTERFACES_DIR  "@PACKAGE_AKONADI_DBUS_INTERFACES_INSTALL_DIR@")
 set_and_check(AKONADI_INCLUDE_DIR          "@PACKAGE_AKONADI_INCLUDE_DIR@")
 
 find_dependency(Boost "@Boost_MINIMUM_VERSION@")
 
 include(${CMAKE_CURRENT_LIST_DIR}/KF5AkonadiTargets.cmake)
 include(${CMAKE_CURRENT_LIST_DIR}/KF5AkonadiMacros.cmake)
 
 # The directory where akonadi-xml.xsd and kcfg2dbus.xsl are installed
 set(KF5Akonadi_DATA_DIR "@PACKAGE_KF5Akonadi_DATA_DIR@")
 
 ####################################################################################
 # CMAKE_AUTOMOC
 
 if(NOT CMAKE_VERSION VERSION_LESS "3.10.0")
     # CMake 3.9+ warns about automoc on files without Q_OBJECT, and doesn't know about other macros.
     # 3.10+ lets us provide more macro names that require automoc.
     list(APPEND CMAKE_AUTOMOC_MACRO_NAMES AKONADI_AGENTCONFIG_FACTORY)
 endif()
 
diff --git a/KF5AkonadiMacros.cmake b/KF5AkonadiMacros.cmake
index 0cd5850f2..14f519fa4 100644
--- a/KF5AkonadiMacros.cmake
+++ b/KF5AkonadiMacros.cmake
@@ -1,138 +1,138 @@
 #
 # Convenience macros to add akonadi testrunner unit-tests
 #
 # Set AKONADI_RUN_MYSQL_ISOLATED_TESTS to false to prevent run the tests against MySQL
 # Set AKONADI_RUN_PGSQL_ISOLATED_TESTS to false to prevent run the tests against PostgreSQL
 # Set AKONADI_RUN_SQLITE_ISOLATED_TESTS to false to prevent run the tests against SQLite
 # Set AKONADI_TESTS_XML to true if you want qtestlib to generate (per backend) XML files with the test results
 #
 # You still need to provide the test environment, see akonadi/autotests/libs/unittestenv
 # copy the unittestenv directory to your unit test directory and update the files
 # as necessary
 
 function(add_akonadi_isolated_test)
 
     function(add_akonadi_isolated_test_impl)
         set(options)
         set(oneValueArgs SOURCE)
         set(multiValueArgs BACKENDS ADDITIONAL_SOURCES LINK_LIBRARIES)
         cmake_parse_arguments(CONFIG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
         set(_test ${CONFIG_SOURCE})
         get_filename_component(_name ${CONFIG_SOURCE} NAME_WE)
         add_executable(${_name} ${_test} ${CONFIG_ADDITIONAL_SOURCES})
         ecm_mark_as_test(${_name})
         target_link_libraries(${_name}
                               Qt5::Test Qt5::Gui Qt5::Widgets Qt5::Network KF5::KIOCore
-                              KF5::AkonadiCore KF5::AkonadiPrivate KF5::DBusAddons
+                              KF5::AkonadiCore KF5::AkonadiPrivate Qt5::DBus
                               ${CONFIG_LINK_LIBRARIES}
         )
 
         if (NOT DEFINED _testrunner)
             if (${PROJECT_NAME} STREQUAL Akonadi AND TARGET akonaditest)
                 # If this macro is used in Akonadi itself, just use the target name;
                 # CMake will replace it with the path to the executable in the build
                 # directory. This will ensure it works even on a clean build,
                 # where the executable doesn't exist yet at cmake time.
                 set(_testrunner akonaditest)
             else()
                 find_program(_testrunner NAMES akonaditest akonaditest.exe)
                 if (NOT _testrunner)
                     message(WARNING "Could not locate akonaditest executable, isolated Akonadi tests will fail!")
                 endif()
             endif()
         endif()
 
         # based on kde4_add_unit_test
         set(_executable $<TARGET_FILE:${_name}>)
         if (APPLE)
             set(_executable ${_executable}.app/Contents/MacOS/${_name})
         endif()
 
         function(_defineTest name backend)
             set(backends ${ARGN})
             if (NOT DEFINED AKONADI_RUN_${backend}_ISOLATED_TESTS OR AKONADI_RUN_${backend}_ISOLATED_TESTS)
                 LIST(LENGTH "${backends}" backendsLen)
                 string(TOLOWER ${backend} lcbackend)
                 LIST(FIND "${backends}" ${lcbackend} enableBackend)
                 if (${backendsLen} EQUAL 0 OR ${enableBackend} GREATER -1)
                     set(configFile ${CMAKE_CURRENT_SOURCE_DIR}/unittestenv/config.xml)
                     if (AKONADI_TESTS_XML)
                         set(extraOptions -xml -o "${TEST_RESULT_OUTPUT_PATH}/${lcbackend}-${name}.xml")
                     endif()
                     set(_test_name akonadi-${lcbackend}-${name})
                     add_test(NAME ${_test_name}
                              COMMAND ${_testrunner} -c "${configFile}" -b ${lcbackend}
                                      ${_executable} ${extraOptions}
                     )
                     # Taken from ECMAddTests.cmake
                     if (CMAKE_LIBRARY_OUTPUT_DIRECTORY)
                         if(CMAKE_HOST_SYSTEM MATCHES "Windows")
                           set(PATHSEP ";")
                         else() # e.g. Linux
                           set(PATHSEP ":")
                         endif()
                         set(_plugin_path $ENV{QT_PLUGIN_PATH})
                         set_property(TEST ${_testname} PROPERTY ENVIRONMENT QT_PLUGIN_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}${PATHSEP}${_plugin_path})
                       endif()
                 endif()
             endif()
         endfunction()
 
         find_program(MYSQLD_EXECUTABLE mysqld /usr/sbin /usr/local/sbin /usr/libexec /usr/local/libexec /opt/mysql/libexec /usr/mysql/bin)
         if (MYSQLD_EXECUTABLE AND NOT WIN32)
             _defineTest(${_name} "MYSQL" ${CONFIG_BACKENDS})
         endif()
 
         find_program(POSTGRES_EXECUTABLE postgres)
         if (POSTGRES_EXECUTABLE AND NOT WIN32)
             _defineTest(${_name} "PGSQL" ${CONFIG_BACKENDS})
         endif()
 
         _defineTest(${_name} "SQLITE" ${CONFIG_BACKENDS})
     endfunction()
 
     LIST(LENGTH "${ARGN}" argc)
     if (${argc} EQUAL 0)
         add_akonadi_isolated_test_impl(SOURCE ${ARGN})
     else()
         add_akonadi_isolated_test_impl(${ARGN})
     endif()
 endfunction()
 
 function(add_akonadi_isolated_test_advanced source additional_sources link_libraries)
     add_akonadi_isolated_test(SOURCE ${source}
                               ADDITIONAL_SOURCES "${additional_sources}"
                               LINK_LIBRARIES "${link_libraries}"
     )
 endfunction()
 
 function(kcfg_generate_dbus_interface _kcfg _name)
     if (NOT XSLTPROC_EXECUTABLE)
         message(FATAL_ERROR "xsltproc executable not found but needed by KCFG_GENERATE_DBUS_INTERFACE()")
     endif()
 
     # When using this macro inside Akonadi, we need to refer to the file in the
     # repo
     if (Akonadi_SOURCE_DIR)
         set(xsl_path ${Akonadi_SOURCE_DIR}/src/core/kcfg2dbus.xsl)
     else()
         set(xsl_path ${KF5Akonadi_DATA_DIR}/kcfg2dbus.xsl)
     endif()
     file(RELATIVE_PATH xsl_relpath ${CMAKE_CURRENT_BINARY_DIR} ${xsl_path})
     if (IS_ABSOLUTE ${_kcfg})
         file(RELATIVE_PATH kcfg_relpath ${CMAKE_CURRENT_BINARY_DIR} ${_kcfg})
     else()
         file(RELATIVE_PATH kcfg_relpath ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/${_kcfg})
     endif()
     add_custom_command(
         OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_name}.xml
         COMMAND ${XSLTPROC_EXECUTABLE}
             --output ${_name}.xml
             --stringparam interfaceName ${_name}
             ${xsl_relpath}
             ${kcfg_relpath}
         DEPENDS
             ${xsl_path}
             ${_kcfg}
     )
 endfunction()