diff --git a/cmake/modules/TpQtMacros.cmake b/cmake/modules/TpQtMacros.cmake
index 225cf84..4f182c1 100644
--- a/cmake/modules/TpQtMacros.cmake
+++ b/cmake/modules/TpQtMacros.cmake
@@ -1,499 +1,499 @@
# - Common macros for Tp-Qt
# Copyright (c) 2010, Collabora Ltd.
#
# Redistribution and use is allowed according to the terms of the BSD license.
#
# These macros/functions are not exported - they are meant for internal usage into Telepathy-Qt's build system.
#
# Preamble: How dynamic generators are handled with the CMake build system.
# Telepathy-Qt strongly relies upon lots of files generated at build time through some python programs, found
# in tools/. To avoid developers the struggle of handling those manually, a set of convenience macros have been
# created to handle them with the correct dependencies. Each of those macros takes a target name as a first argument
# and creates a target with that exact name. In a similar fashion, in the last argument you can specify a list
# of targets the generated target will depend on. This way, you can handle transparently dependencies between
# generated files, while the dirty stuff is done for you in the background.
#
# macro TPQT_EXTRACT_DEPENDS (tpqt_other tpqt_depends)
# Internal macro used to extract arguments from ARGN
#
# function TPQT_CREATE_MOC_COMMAND_TARGET_DEPS(inputfile outputfile moc_flags moc_options target_dependencies ...)
# This function behaves exactly like qt_create_moc_command, but creates a custom target for the
# moc file generation, allowing to specify a list of targets the generated moc target will depend on.
# Just like qt_create_moc_command, it is an internal macro and it's not meant to be used explicitely.
#
# function TPQT_GENERATE_MOC_I(inputfile outputfile)
# This function behaves exactly like qt_generate_moc, but it generates moc files with the -i option,
# which disables the generation of an #include directive. This macro has to be used always when building
# Tp-Qt internals due to the internal header files restrictions.
#
# function TPQT_GENERATE_MOC_I_TARGET_DEPS(inputfile outputfile target_dependencies ...)
# This function acts as an overload to QT_GENERATE_MOC_I: it does exactly the same thing, but creates a
# custom target for the moc file generation, and adds target_dependencies to it as dependencies.
#
# function TPQT_GENERATE_MOCS(sourcefile ...)
# Generates mocs from a list of header files. You usually want to use this function when building tests
# or examples. Please remember the list of the header files passed to this function MUST be added to the
# target's sources.
#
# function TPQT_CLIENT_GENERATOR(spec group pretty_include namespace [arguments] [DEPENDS dependencies ...])
# This function takes care of invoking qt-client-gen.py with the correct arguments, which generates
# headers out of specs. spec is the name of the spec headers will be generated from, group represents
# the spec's group, pretty_include is the name of the capitalized header (for example ClientGenerator),
# namespace is the C++ namespace the generated header will belong to. This function also accepts
# as an optional last argument a list of additional command line arguments which will be passed to
# qt-client-gen.py upon execution. After issuing DEPENDS in the last argument you can pass a list of targets
# the generated target will depend on.
#
# function TPQT_FUTURE_CLIENT_GENERATOR(spec namespace [arguments] [DEPENDS dependencies ...])
# Same as tpqt_client_generator, but for future interfaces
#
# function TPQT_SERVICE_GENERATOR(spec group pretty_include namespace [arguments] [DEPENDS dependencies ...])
# This function takes care of invoking qt-svc-gen.py with the correct arguments, which generates
# headers out of specs. spec is the name of the spec headers will be generated from, group represents
# the spec's group, pretty_include is the name of the capitalized header (for example ServiceGenerator),
# namespace is the C++ namespace the generated header will belong to. This function also accepts
# as an optional last argument a list of additional command line arguments which will be passed to
# qt-svc-gen.py upon execution. After issuing DEPENDS in the last argument you can pass a list of targets
# the generated target will depend on.
#
# function TPQT_GENERATE_MANAGER_FILE(MANAGER_FILE OUTPUT_FILENAME DEPEND_FILENAME)
# This function takes care of invoking manager-file.py with the correct arguments. The first argument is the
# path to the manager-file.py file which should be used, the second is the output filename of the manager,
# and the third is the path to the file which depends on the generated manager file.
#
# function TPQT_XINCLUDATOR (TARGET_NAME INPUT_FILE OUTPUT_FILE [additional_arguments ...] [DEPENDS dependencies ...])
# This function takes care of invoking xincludator.py with the correct arguments. TARGET_NAME is the name of
# the generated target (see preamble), INPUT_FILE is the input spec file, OUTPUT_FILE is the filename
# the generated file will be saved to. This function also accepts as an optional last argument a list of
# additional command line arguments which will be passed to xincludator upon execution.
# After issuing DEPENDS in the last argument you can pass a list of targets the generated target will depend on.
#
# function TPQT_CONSTANTS_GEN (TARGET_NAME SPEC_XML OUTPUT_FILE [additional_arguments ...] [DEPENDS dependencies ...])
# This function takes care of invoking qt-constants-gen.py with the correct arguments. TARGET_NAME is the name of
# the generated target (see preamble), SPEC_XML is the spec input file, OUTPUT_FILE is the filename
# the generated file will be saved to. This function also accepts as an optional last argument a list of
# additional command line arguments which will be passed to qt-constants-gen.py upon execution.
# After issuing DEPENDS in the last argument you can pass a list of targets the generated target will depend on.
#
# function TPQT_TYPES_GEN (TARGET_NAME SPEC_XML OUTFILE_DECL OUTFILE_IMPL NAMESPACE
# REAL_INCLUDE PRETTY_INCLUDE [additional_arguments ...] [DEPENDS dependencies ...])
# This function takes care of invoking qt-types-gen.py with the correct arguments. TARGET_NAME is the name of
# the generated target (see preamble), SPEC_XML is the input spec file, OUTFILE_DECL is the filename
# the header of the generated file will be saved to, OUTFILE_IMPL is the filename the implementation of the
# generated file will be saved to, NAMESPACE is the C++ namespace the generated header will belong to,
# REAL_INCLUDE is the real include file you want to use, PRETTY_INCLUDE is the name of the capitalized header
# (for example ClientGenerator).
# This function also accepts as an optional last argument a list of additional command line arguments
# which will be passed to qt-constants-gen.py upon execution.
# After issuing DEPENDS in the last argument you can pass a list of targets the generated target will depend on.
#
# macro TPQT_ADD_GENERIC_UNIT_TEST (fancyName name [libraries ...])
# This macro takes care of building and adding a generic unit test to the automatic CTest suite. The requirement
# for using this macro is to have the unit test contained in a single source file named ${name}.cpp. fancyName will
# be used as the test and target's name, and you can specify as a third and optional argument a set of additional
# libraries the target will link to.
#
# macro TPQT_ADD_DBUS_UNIT_TEST (fancyName name [libraries ...])
# This macro takes care of building and adding an unit test requiring DBus emulation to the automatic
# CTest suite. The requirement for using this macro is to have the unit test contained in a single
# source file named ${name}.cpp. fancyName will be used as the test and target's name, and you can specify as a third
# and optional argument a set of additional libraries the target will link to. Please remember that you need to
# set up the DBus environment by calling TPQT_SETUP_DBUS_TEST_ENVIRONMENT BEFORE you call this macro.
#
# macro _TPQT_ADD_CHECK_TARGETS (fancyName name command [args])
# This is an internal macro which is meant to be used by TPQT_ADD_DBUS_UNIT_TEST and TPQT_ADD_GENERIC_UNIT_TEST.
# It takes care of generating a check target for each test method available (currently normal execution, valgrind and
# callgrind). This macro accepts the same arguments as the add test macros, but accepts a command and a list of
# arguments for running the test instead of the link libraries. However, you are not meant to call this macro from
# your CMakeLists.txt files.
#
# function TPQT_SETUP_DBUS_TEST_ENVIRONMENT ()
# This function MUST be called before calling TPQT_ADD_DBUS_UNIT_TEST. It takes care of preparing the test
# environment for DBus tests and generating the needed files.
#
# macro MAKE_INSTALL_PATH_ABSOLUTE (out in)
# This macro makes the path given in the "in" variable absolute (or leaves it unchanged
# if it's absolute already) by prefixing it with TELEPATHY_QT_INSTALL_DIR,
# and returns the absolute path in the "out" variable. This macro is mainly used for
# generating *Config.cmake files.
#
#
MACRO (TPQT_EXTRACT_DEPENDS _tpqt_other _tpqt_depends)
SET(${_tpqt_other})
SET(${_tpqt_depends})
SET(_TPQT_DOING_DEPENDS FALSE)
FOREACH(_currentArg ${ARGN})
IF ("${_currentArg}" STREQUAL "DEPENDS")
SET(_TPQT_DOING_DEPENDS TRUE)
- ELSE ("${_currentArg}" STREQUAL "DEPENDS")
+ ELSE ()
IF(_TPQT_DOING_DEPENDS)
LIST(APPEND ${_tpqt_depends} "${_currentArg}")
- ELSE(_TPQT_DOING_DEPENDS)
+ ELSE()
LIST(APPEND ${_tpqt_other} "${_currentArg}")
- ENDIF(_TPQT_DOING_DEPENDS)
- ENDIF ("${_currentArg}" STREQUAL "DEPENDS")
- ENDFOREACH(_currentArg)
-ENDMACRO (TPQT_EXTRACT_DEPENDS)
+ ENDIF()
+ ENDIF ()
+ ENDFOREACH()
+ENDMACRO ()
# helper function to set up a moc rule
FUNCTION (TPQT_CREATE_MOC_COMMAND_TARGET_DEPS infile outfile moc_flags moc_options)
# For Windows, create a parameters file to work around command line length limit
GET_FILENAME_COMPONENT(_moc_outfile_name "${outfile}" NAME)
IF (WIN32)
# Pass the parameters in a file. Set the working directory to
# be that containing the parameters file and reference it by
# just the file name. This is necessary because the moc tool on
# MinGW builds does not seem to handle spaces in the path to the
# file given with the @ syntax.
GET_FILENAME_COMPONENT(_moc_outfile_dir "${outfile}" PATH)
IF(_moc_outfile_dir)
SET(_moc_working_dir WORKING_DIRECTORY ${_moc_outfile_dir})
- ENDIF(_moc_outfile_dir)
+ ENDIF()
SET (_moc_parameters_file ${outfile}_parameters)
SET (_moc_parameters ${moc_flags} ${moc_options} -o "${outfile}" "${infile}")
FILE (REMOVE ${_moc_parameters_file})
FOREACH(arg ${_moc_parameters})
FILE (APPEND ${_moc_parameters_file} "${arg}\n")
- ENDFOREACH(arg)
+ ENDFOREACH()
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
COMMAND ${QT_MOC_EXECUTABLE} @${_moc_outfile_name}_parameters
DEPENDS ${infile}
${_moc_working_dir}
VERBATIM)
- ELSE (WIN32)
+ ELSE ()
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
COMMAND ${QT_MOC_EXECUTABLE}
ARGS ${moc_flags} ${moc_options} -o ${outfile} ${infile}
DEPENDS ${infile})
- ENDIF (WIN32)
+ ENDIF ()
add_custom_target(moc-${_moc_outfile_name} DEPENDS ${outfile})
add_dependencies(moc-${_moc_outfile_name} ${ARGN})
-ENDFUNCTION (TPQT_CREATE_MOC_COMMAND_TARGET_DEPS)
+ENDFUNCTION ()
# add the -i option to QT_GENERATE_MOC
function(TPQT_GENERATE_MOC_I infile outfile)
qt5_get_moc_flags(moc_flags)
get_filename_component(abs_infile ${infile} ABSOLUTE)
qt5_create_moc_command(${abs_infile} ${outfile} "${moc_flags}" "-i")
set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file
-endfunction(TPQT_GENERATE_MOC_I)
+endfunction()
# same as tpqt_generate_moc_i, but lets the caller specify a list of targets which the mocs should depend on
function(TPQT_GENERATE_MOC_I_TARGET_DEPS infile outfile)
qt5_get_moc_flags(moc_flags)
get_filename_component(abs_infile ${infile} ABSOLUTE)
tpqt_create_moc_command_target_deps(${abs_infile} ${outfile} "${moc_flags}" "-i" ${ARGN})
set_source_files_properties(${outfile} PROPERTIES SKIP_AUTOMOC TRUE) # dont run automoc on this file
-endfunction(TPQT_GENERATE_MOC_I_TARGET_DEPS)
+endfunction()
# generates mocs for the passed list. The list should be added to the target's sources
function(tpqt_generate_mocs)
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/_gen" )
foreach(moc_src ${ARGN})
string(REPLACE ".h" ".moc.hpp" generated_file ${moc_src})
tpqt_generate_moc_i(${CMAKE_CURRENT_SOURCE_DIR}/${moc_src} ${CMAKE_CURRENT_BINARY_DIR}/_gen/${generated_file})
set_property(SOURCE ${moc_src} APPEND PROPERTY OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/_gen/${generated_file})
- endforeach(moc_src ${ARGN})
-endfunction(tpqt_generate_mocs)
+ endforeach()
+endfunction()
function(tpqt_client_generator spec group pretty_include namespace)
tpqt_extract_depends(client_generator_args client_generator_depends ${ARGN})
set(ARGS
${CMAKE_SOURCE_DIR}/tools/qt-client-gen.py
--group=${group}
--namespace=${namespace}
--typesnamespace=Tp
--headerfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}.h
--implfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}-body.hpp
--realinclude=TelepathyQt/${spec}.h
--prettyinclude=TelepathyQt/${pretty_include}
--specxml=${CMAKE_CURRENT_BINARY_DIR}/_gen/stable-spec.xml
--ifacexml=${CMAKE_CURRENT_BINARY_DIR}/_gen/spec-${spec}.xml
--extraincludes=${TYPES_INCLUDE}
--must-define=IN_TP_QT_HEADER
--visibility=TP_QT_EXPORT
${client_generator_args})
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}.h ${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}-body.hpp
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${ARGS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/libqtcodegen.py
${CMAKE_SOURCE_DIR}/tools/qt-client-gen.py
${CMAKE_CURRENT_BINARY_DIR}/_gen/stable-spec.xml
${CMAKE_CURRENT_BINARY_DIR}/_gen/spec-${spec}.xml)
add_custom_target(generate_cli-${spec}-body DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}-body.hpp)
add_dependencies(all-generated-sources generate_cli-${spec}-body)
if (client_generator_depends)
add_dependencies(generate_cli-${spec}-body ${client_generator_depends})
- endif (client_generator_depends)
+ endif ()
tpqt_generate_moc_i_target_deps(${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}.h
${CMAKE_CURRENT_BINARY_DIR}/_gen/cli-${spec}.moc.hpp
"generate_cli-${spec}-body")
-endfunction(tpqt_client_generator spec group pretty_include namespace)
+endfunction()
function(tpqt_future_client_generator spec namespace)
tpqt_extract_depends(future_client_generator_args future_client_generator_depends ${ARGN})
set(ARGS
${CMAKE_SOURCE_DIR}/tools/qt-client-gen.py
--namespace=${namespace}
--typesnamespace=TpFuture
--headerfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.h
--implfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}-body.hpp
--realinclude=TelepathyQt/future-internal.h
--prettyinclude=TelepathyQt/future-internal.h
--specxml=${CMAKE_CURRENT_BINARY_DIR}/_gen/future-spec.xml
--ifacexml=${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.xml
--extraincludes=${TYPES_INCLUDE}
--extraincludes=''
--extraincludes=''
--visibility=TP_QT_NO_EXPORT
${future_client_generator_args})
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.h ${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}-body.hpp
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${ARGS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/libqtcodegen.py
${CMAKE_SOURCE_DIR}/tools/qt-client-gen.py
${CMAKE_CURRENT_BINARY_DIR}/_gen/future-spec.xml
${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.xml)
add_custom_target(generate_future-${spec}-body DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}-body.hpp)
add_dependencies(all-generated-sources generate_future-${spec}-body)
if (future_client_generator_depends)
add_dependencies(generate_future-${spec}-body ${future_client_generator_depends})
- endif (future_client_generator_depends)
+ endif ()
tpqt_generate_moc_i_target_deps(${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.h
${CMAKE_CURRENT_BINARY_DIR}/_gen/future-${spec}.moc.hpp
"generate_future-${spec}-body")
-endfunction(tpqt_future_client_generator spec namespace)
+endfunction()
function(tpqt_service_generator spec group pretty_include namespace)
tpqt_extract_depends(service_generator_args service_generator_depends ${ARGN})
string(REPLACE "svc-" "" spec ${spec})
set(ARGS
${CMAKE_SOURCE_DIR}/tools/qt-svc-gen.py
--group=${group}
--namespace=${namespace}
--typesnamespace=Tp
--headerfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.h
--implfile=${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.cpp
--realinclude=TelepathyQt/_gen/svc-${spec}.h
--mocinclude=TelepathyQt/_gen/svc-${spec}.moc.hpp
--specxml=${CMAKE_CURRENT_BINARY_DIR}/_gen/stable-spec.xml
--ifacexml=${CMAKE_CURRENT_BINARY_DIR}/_gen/spec-svc-${spec}.xml
--visibility=TP_QT_EXPORT
${service_generator_args})
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.h ${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.cpp
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${ARGS}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/libqtcodegen.py
${CMAKE_SOURCE_DIR}/tools/qt-svc-gen.py
${CMAKE_CURRENT_BINARY_DIR}/_gen/stable-spec.xml
${CMAKE_CURRENT_BINARY_DIR}/_gen/spec-svc-${spec}.xml)
add_custom_target(generate_service-${spec}-body DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.cpp)
add_dependencies(all-generated-service-sources generate_service-${spec}-body)
if (service_generator_depends)
add_dependencies(generate_service-${spec}-body ${service_generator_depends})
- endif (service_generator_depends)
+ endif ()
tpqt_generate_moc_i_target_deps(${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.h
${CMAKE_CURRENT_BINARY_DIR}/_gen/svc-${spec}.moc.hpp
"generate_service-${spec}-body")
-endfunction(tpqt_service_generator spec group pretty_include namespace)
+endfunction()
# This function is used for generating CM in various examples
function(tpqt_generate_manager_file MANAGER_FILE OUTPUT_FILENAME DEPEND_FILENAME)
# make_directory is required, otherwise the command won't work!!
make_directory(${CMAKE_CURRENT_BINARY_DIR}/_gen)
add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/_gen/param-spec-struct.h
${CMAKE_CURRENT_BINARY_DIR}/_gen/${OUTPUT_FILENAME}
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${CMAKE_SOURCE_DIR}/tools/manager-file.py
${MANAGER_FILE}
_gen
DEPENDS ${CMAKE_SOURCE_DIR}/tools/manager-file.py)
set_source_files_properties(${DEPEND_FILENAME}
PROPERTIES OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/_gen/param-spec-struct.h)
-endfunction(tpqt_generate_manager_file MANAGER_FILE)
+endfunction()
function(tpqt_xincludator _TARGET_NAME _INPUT_FILE _OUTPUT_FILE)
tpqt_extract_depends(xincludator_gen_args xincludator_gen_depends ${ARGN})
# Gather all .xml files in TelepathyQt and spec/ and make this target depend on those
file(GLOB depends_xml_files ${CMAKE_SOURCE_DIR}/TelepathyQt/*.xml ${CMAKE_SOURCE_DIR}/spec/*.xml)
add_custom_command(OUTPUT ${_OUTPUT_FILE}
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${CMAKE_SOURCE_DIR}/tools/xincludator.py
${_INPUT_FILE}
${xincludator_gen_args}
> ${_OUTPUT_FILE}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/xincludator.py
${_INPUT_FILE} ${depends_xml_files})
add_custom_target(${_TARGET_NAME} DEPENDS ${_OUTPUT_FILE})
if (xincludator_gen_depends)
add_dependencies(${_TARGET_NAME} ${xincludator_gen_depends})
- endif (xincludator_gen_depends)
-endfunction(tpqt_xincludator _TARGET_NAME _INPUT_FILE _OUTPUT_FILE)
+ endif ()
+endfunction()
function(tpqt_constants_gen _TARGET_NAME _SPEC_XML _OUTFILE)
tpqt_extract_depends(constants_gen_args constants_gen_depends ${ARGN})
# Gather all .xml files in TelepathyQt and spec/ and make this target depend on those
file(GLOB depends_xml_files ${CMAKE_SOURCE_DIR}/TelepathyQt/*.xml ${CMAKE_SOURCE_DIR}/spec/*.xml)
add_custom_command(OUTPUT ${_OUTFILE}
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${CMAKE_SOURCE_DIR}/tools/qt-constants-gen.py
${constants_gen_args}
--specxml=${_SPEC_XML}
> ${_OUTFILE}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/libqtcodegen.py
${CMAKE_SOURCE_DIR}/tools/qt-constants-gen.py
${_SPEC_XML} ${depends_xml_files})
add_custom_target(${_TARGET_NAME} DEPENDS ${_OUTFILE})
add_dependencies(all-generated-sources ${_TARGET_NAME})
if (constants_gen_depends)
add_dependencies(${_TARGET_NAME} ${constants_gen_depends})
- endif (constants_gen_depends)
-endfunction (tpqt_constants_gen _TARGET_NAME _SPEC_XML _OUTFILE)
+ endif ()
+endfunction ()
function(tpqt_types_gen _TARGET_NAME _SPEC_XML _OUTFILE_DECL _OUTFILE_IMPL _NAMESPACE _REALINCLUDE _PRETTYINCLUDE)
tpqt_extract_depends(types_gen_args types_gen_depends ${ARGN})
# Gather all .xml files in TelepathyQt and spec/ and make this target depend on those
file(GLOB depends_xml_files ${CMAKE_SOURCE_DIR}/TelepathyQt/*.xml ${CMAKE_SOURCE_DIR}/spec/*.xml)
add_custom_command(OUTPUT ${_OUTFILE_DECL} ${_OUTFILE_IMPL}
COMMAND ${PYTHON_EXECUTABLE}
ARGS ${CMAKE_SOURCE_DIR}/tools/qt-types-gen.py
--namespace=${_NAMESPACE}
--declfile=${_OUTFILE_DECL}
--implfile=${_OUTFILE_IMPL}
--realinclude=${_REALINCLUDE}
--prettyinclude=${_PRETTYINCLUDE}
${types_gen_args}
--specxml=${_SPEC_XML}
DEPENDS ${CMAKE_SOURCE_DIR}/tools/libqtcodegen.py
${CMAKE_SOURCE_DIR}/tools/qt-types-gen.py
${_SPEC_XML} ${depends_xml_files})
add_custom_target(${_TARGET_NAME} DEPENDS ${_OUTFILE_IMPL})
add_dependencies(all-generated-sources ${_TARGET_NAME})
if (types_gen_depends)
add_dependencies(${_TARGET_NAME} ${types_gen_depends})
- endif (types_gen_depends)
-endfunction(tpqt_types_gen _TARGET_NAME _SPEC_XML _OUTFILE_DECL _OUTFILE_IMPL _NAMESPACE _REALINCLUDE _PRETTYINCLUDE)
+ endif ()
+endfunction()
macro(tpqt_add_generic_unit_test _fancyName _name)
tpqt_generate_moc_i(${_name}.cpp ${CMAKE_CURRENT_BINARY_DIR}/_gen/${_name}.cpp.moc.hpp)
add_executable(test-${_name} ${_name}.cpp ${CMAKE_CURRENT_BINARY_DIR}/_gen/${_name}.cpp.moc.hpp)
target_link_libraries(test-${_name} ${QT_QTCORE_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTTEST_LIBRARY} telepathy-qt${QT_VERSION_MAJOR} tp-qt-tests ${TP_QT_EXECUTABLE_LINKER_FLAGS} ${ARGN})
add_test(${_fancyName} ${SH} ${CMAKE_CURRENT_BINARY_DIR}/runGenericTest.sh ${CMAKE_CURRENT_BINARY_DIR}/test-${_name})
list(APPEND _telepathy_qt_test_cases test-${_name})
# Valgrind and Callgrind targets
_tpqt_add_check_targets(${_fancyName} ${_name} ${CMAKE_CURRENT_BINARY_DIR}/runGenericTest.sh ${CMAKE_CURRENT_BINARY_DIR}/test-${_name})
-endmacro(tpqt_add_generic_unit_test _fancyName _name)
+endmacro()
macro(tpqt_add_dbus_unit_test _fancyName _name)
tpqt_generate_moc_i(${_name}.cpp ${CMAKE_CURRENT_BINARY_DIR}/_gen/${_name}.cpp.moc.hpp)
add_executable(test-${_name} ${_name}.cpp ${CMAKE_CURRENT_BINARY_DIR}/_gen/${_name}.cpp.moc.hpp)
target_link_libraries(test-${_name} ${QT_QTCORE_LIBRARY} ${QT_QTDBUS_LIBRARY} ${QT_QTNETWORK_LIBRARY} ${QT_QTXML_LIBRARY} ${QT_QTTEST_LIBRARY} telepathy-qt${QT_VERSION_MAJOR} tp-qt-tests ${TP_QT_EXECUTABLE_LINKER_FLAGS} ${ARGN})
set(with_session_bus ${CMAKE_CURRENT_BINARY_DIR}/runDbusTest.sh)
add_test(${_fancyName} ${SH} ${with_session_bus} ${CMAKE_CURRENT_BINARY_DIR}/test-${_name})
list(APPEND _telepathy_qt_test_cases test-${_name})
# Valgrind and Callgrind targets
_tpqt_add_check_targets(${_fancyName} ${_name} ${with_session_bus} ${CMAKE_CURRENT_BINARY_DIR}/test-${_name})
-endmacro(tpqt_add_dbus_unit_test _fancyName _name)
+endmacro()
macro(_tpqt_add_check_targets _fancyName _name _runnerScript)
set_tests_properties(${_fancyName}
PROPERTIES
FAIL_REGULAR_EXPRESSION "^FAIL!")
# Standard check target
add_custom_target(check-${_fancyName} ${SH} ${_runnerScript} ${ARGN})
add_dependencies(check-${_fancyName} test-${_name})
# Lcov target
add_dependencies(lcov-check test-${_name})
# Valgrind target
add_custom_target(check-valgrind-${_fancyName})
add_dependencies(check-valgrind-${_fancyName} test-${_name})
add_custom_command(
TARGET check-valgrind-${_fancyName}
COMMAND G_SLICE=always-malloc ${SH} ${_runnerScript} /usr/bin/valgrind
--tool=memcheck
--leak-check=full
--leak-resolution=high
--child-silent-after-fork=yes
--num-callers=20
--gen-suppressions=all
--log-file=${CMAKE_CURRENT_BINARY_DIR}/test-${_fancyName}.memcheck.log
--suppressions=${CMAKE_SOURCE_DIR}/tools/tp-qt-tests.supp
--suppressions=${CMAKE_SOURCE_DIR}/tools/telepathy-glib.supp
${ARGN}
WORKING_DIRECTORY
${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Running valgrind on test \"${_fancyName}\"")
add_dependencies(check-valgrind check-valgrind-${_fancyName})
# Callgrind target
add_custom_target(check-callgrind-${_fancyName})
add_dependencies(check-callgrind-${_fancyName} test-${_name})
add_custom_command(
TARGET check-callgrind-${_fancyName}
COMMAND ${SH} ${_runnerScript} /usr/bin/valgrind
--tool=callgrind
--dump-instr=yes
--log-file=${CMAKE_CURRENT_BINARY_DIR}/test-${_fancyName}.callgrind.log
--callgrind-out-file=${CMAKE_CURRENT_BINARY_DIR}/test-${_fancyName}.callgrind.out
${ARGN}
WORKING_DIRECTORY
${CMAKE_CURRENT_BINARY_DIR}
COMMENT
"Running callgrind on test \"${_fancyName}\"")
add_dependencies(check-callgrind check-callgrind-${_fancyName})
-endmacro(_tpqt_add_check_targets _fancyName _name)
+endmacro()
function(tpqt_setup_dbus_test_environment)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/runDbusTest.sh "
${test_environment}
sh ${CMAKE_SOURCE_DIR}/tools/with-session-bus.sh \\
--config-file=${CMAKE_BINARY_DIR}/tests/dbus-1/session.conf -- $@
")
-endfunction(tpqt_setup_dbus_test_environment)
+endfunction()
macro(make_install_path_absolute out in)
if (IS_ABSOLUTE "${in}")
set(${out} "${in}")
- else (IS_ABSOLUTE "${in}")
+ else ()
set(${out} "\${TELEPATHY_QT${QT_VERSION_MAJOR}_INSTALL_DIR}/${in}")
- endif (IS_ABSOLUTE "${in}")
-endmacro(make_install_path_absolute out in)
+ endif ()
+endmacro()