vasilito
e0590a0b56
kf6-kcoreaddons 6.28.0 requires ECM >= 6.28.0 but the vendored ECM source/ was still 6.10.0: the sync engine skipped it because ECM's version marker is a bare set(VERSION "X.Y.Z") that the parser didn't recognize (only KF_VERSION / PROJECT_VERSION / RELEASE_SERVICE_VERSION). Re-lay ECM from its 6.28.0 source.tar (pure cmake modules, no Redox port) and teach both the sync engine and the validator to read set(VERSION) so this class is caught, not silently skipped.
465 lines
18 KiB
CMake
465 lines
18 KiB
CMake
# SPDX-FileCopyrightText: 2013 Alexander Richardson <arichardson.kde@gmail.com>
|
|
# SPDX-FileCopyrightText: 2015 Alex Merry <alex.merry@kde.org>
|
|
# SPDX-FileCopyrightText: 2025 Friedrich W. H. Kossebau <kossebau@kde.org>
|
|
#
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
#[=======================================================================[.rst:
|
|
ECMAddTests
|
|
-----------
|
|
|
|
Convenience functions for adding tests.
|
|
|
|
::
|
|
|
|
ecm_add_tests(<sources>
|
|
[COMPILE_DEFINITIONS <definition> [<definition> [...]]] # Since 6.13.0
|
|
[ENVIRONMENT <list>] # Since 6.13.0
|
|
LINK_LIBRARIES <library> [<library> [...]]
|
|
[NAME_PREFIX <prefix> (| NO_NAME_PREFIX] # Since 6.22.0)
|
|
[GUI]
|
|
[TARGET_NAMES_VAR <target_names_var>]
|
|
[TEST_NAMES_VAR <test_names_var>]
|
|
[WORKING_DIRECTORY <dir>] # Since 5.111
|
|
)
|
|
|
|
A convenience function for adding multiple tests, each consisting of a
|
|
single source file. For each file in <sources>, an executable target is
|
|
created (whose name is the base name of the source file) with the compiler
|
|
definitions passed with ``COMPILE_DEFINITIONS``. This will be linked
|
|
against the libraries given with ``LINK_LIBRARIES``. Each executable will
|
|
be added as a test with the same name and can have an environment provided
|
|
by ``ENVIRONMENT``.
|
|
|
|
If ``NAME_PREFIX`` is given, this prefix will be prepended to the test names, but
|
|
not the target names. As a result, it will not prevent clashes between tests
|
|
with the same name in different parts of the project, but it can be used to
|
|
give an indication of where to look for a failing test.
|
|
If ``NAME_PREFIX`` is not set, it will default to a value depending on the
|
|
strategy as controlled by the variable ``ECM_TEST_NAME_PREFIX_STRATEGY``, if
|
|
set in the current scope and ``NO_NAME_PREFIX`` is not set (since 6.22).
|
|
|
|
If the flag ``GUI`` is passed the test binaries will be GUI executables, otherwise
|
|
the resulting binaries will be console applications (regardless of the value
|
|
of ``CMAKE_WIN32_EXECUTABLE`` or ``CMAKE_MACOSX_BUNDLE``). Be aware that this changes
|
|
the executable entry point on Windows (although some frameworks, such as Qt,
|
|
abstract this difference away).
|
|
|
|
The tests will be build with ``-DQT_FORCE_ASSERTS`` to enable assertions in the
|
|
test executable even for release builds.
|
|
|
|
The ``TARGET_NAMES_VAR`` and ``TEST_NAMES_VAR`` arguments, if given, should specify a
|
|
variable name to receive the list of generated target and test names,
|
|
respectively. This makes it convenient to apply properties to them as a
|
|
whole, for example, using ``set_target_properties()`` or ``set_tests_properties()``.
|
|
|
|
The generated target executables will have the effects of ``ecm_mark_as_test()``
|
|
(from the :module:`ECMMarkAsTest` module) applied to it.
|
|
|
|
``WORKING_DIRECTORY`` sets the test property `WORKING_DIRECTORY
|
|
<https://cmake.org/cmake/help/latest/prop_test/WORKING_DIRECTORY.html>`_
|
|
in which to execute the test. By default the test will be run in
|
|
``${CMAKE_CURRENT_BINARY_DIR}``. The working directory can be specified using
|
|
generator expressions. Since 5.111.
|
|
|
|
::
|
|
|
|
ecm_add_test(
|
|
<sources>
|
|
[COMPILE_DEFINITIONS <definition> [<definition> [...]]] # Since 6.13.0
|
|
[ENVIRONMENT <list>] # Since 6.13.0
|
|
LINK_LIBRARIES <library> [<library> [...]]
|
|
[TEST_NAME <name>]
|
|
[NAME_PREFIX <prefix> (| NO_NAME_PREFIX] # Since 6.22.0)
|
|
[GUI]
|
|
[TARGET_NAME_VAR <target_name_var>]
|
|
[TEST_NAME_VAR <test_name_var>]
|
|
[WORKING_DIRECTORY <dir>] # Since 5.111
|
|
)
|
|
|
|
This is a single-test form of ``ecm_add_tests`` that allows multiple source files
|
|
to be used for a single test. If using multiple source files, ``TEST_NAME`` must
|
|
be given; this will be used for both the target and test names.
|
|
|
|
As with ``ecm_add_tests()``, the ``NAME_PREFIX`` argument will be prepended to
|
|
the test name.
|
|
If ``NAME_PREFIX`` is not set, it will default to a value depending on the
|
|
strategy as controlled by the variable ``ECM_TEST_NAME_PREFIX_STRATEGY``, if
|
|
set in the current scope and ``NO_NAME_PREFIX`` is not set (since 6.22).
|
|
|
|
The ``TARGET_NAME_VAR`` and ``TEST_NAME_VAR`` arguments, if given, should specify a
|
|
variable name to receive the generated target and test name,
|
|
respectively. This makes it convenient to apply properties to them as a
|
|
whole, for example, using ``set_target_properties()`` or ``set_tests_properties()``.
|
|
|
|
``WORKING_DIRECTORY`` sets the test property `WORKING_DIRECTORY
|
|
<https://cmake.org/cmake/help/latest/prop_test/WORKING_DIRECTORY.html>`_
|
|
in which to execute the test. By default the test will be run in
|
|
``${CMAKE_CURRENT_BINARY_DIR}``. The working directory can be specified using
|
|
generator expressions. Since 5.111.
|
|
|
|
::
|
|
|
|
ecm_test_set_dir_properties( # Since 6.22.0
|
|
[DIR <dir>]
|
|
[PREFIX_NAME <name>]
|
|
[PREFIX_NAME_IGNORE | PREFIX_NAME_NOT_IGNORE]
|
|
[FIRST_PREFIX_NAME]
|
|
[LAST_PREFIX_NAME]
|
|
)
|
|
|
|
|
|
The function can be used to set properties to individual directories to
|
|
influence the behaviour of the test functions. The properties will be set to
|
|
the current source directory. For source directories which themselves do not
|
|
have a CMakeLists.txt file and thus are not added by any `add_subdirectory()
|
|
<https://cmake.org/cmake/help/latest/command/add_subdirectory.html>`_ calls,
|
|
the ``DIR`` argument can be used to instead set the property to any such
|
|
subdirectory ``<dir>``.
|
|
|
|
``PREFIX_NAME`` can be used to override by ``<name>`` the name derived from
|
|
the given directory.
|
|
|
|
``PREFIX_NAME_IGNORE`` or ``PREFIX_NAME_NOT_IGNORE`` can be used to override
|
|
the filtering done by ``ECM_TEST_NAME_PREFIX_IGNORE_DIRS`` for the name of the
|
|
given directory.
|
|
|
|
``FIRST_PREFIX_NAME`` and ``LAST_PREFIX_NAME`` can be used to limit the range
|
|
of directories in the path used for deriving the prefix name.
|
|
|
|
::
|
|
|
|
ecm_test_get_name_prefix( # Since 6.22.0
|
|
<name_prefix_var>
|
|
)
|
|
|
|
The ``name_prefix_var`` argument should specify a variable name to receive the
|
|
default test prefix name for the current scope, based on
|
|
the value of ``ECM_TEST_NAME_PREFIX_STRATEGY`` and the respective further setup.
|
|
|
|
::
|
|
|
|
ECM_TEST_NAME_PREFIX_STRATEGY # Since 6.22.0
|
|
|
|
This variable is specifying the strategy to use when estimating the default
|
|
test name prefix to use by the macros ``ecm_add_tests()`` and ``ecm_add_test()``
|
|
when no explicit ``NAME_PREFIX`` argument is passed. The supported values are:
|
|
|
|
* ``VARIABLE``: The default name prefix is taken from the value of the variable
|
|
``ECM_TEST_NAME_PREFIX`` in the scope where the macros are called.
|
|
|
|
* ``PATH``: The default name prefix is derived from the relative path of the
|
|
current source directory where the macros are called, by replacing the
|
|
dir separators with "-".
|
|
See also ``ECM_TEST_NAME_PREFIX_IGNORE_DIRS`` for skipping some directory names.
|
|
|
|
When unset, the ``VARIABLE`` strategy is used.
|
|
|
|
::
|
|
|
|
ECM_TEST_NAME_PREFIX # Since 6.22.0
|
|
|
|
When ``ECM_TEST_NAME_PREFIX_STRATEGY`` is set to ``VARIABLE``,
|
|
the current value of the variable is used as default for the test name prefix.
|
|
|
|
::
|
|
|
|
ECM_TEST_NAME_PREFIX_IGNORE_DIRS # Since 6.22.0
|
|
|
|
When ``ECM_TEST_NAME_PREFIX_STRATEGY`` is set to ``PATH``, this variable is used
|
|
to filter out directory names in the relative path of the current source directory
|
|
when deriving the name prefix. By default the variable is set to
|
|
"src", "test", "tests", "autotest", "autotests" when including the ``ECMAddTest`` module,
|
|
if not already defined.
|
|
|
|
|
|
Example usage:
|
|
|
|
.. code-block:: cmake
|
|
|
|
set(ECM_TEST_NAME_PREFIX_STRATEGY "PATH")
|
|
list(APPEND ECM_TEST_NAME_PREFIX_IGNORE_DIRS "plugins")
|
|
|
|
# Being in subdir "src/plugins/foo" this test will get
|
|
# the test name prefix set to "foo-", next to base name "mytest":
|
|
ecm_add_test(
|
|
mytest.cpp
|
|
LINK_LIBRARIES mylib
|
|
)
|
|
|
|
Since pre-1.0.0.
|
|
#]=======================================================================]
|
|
|
|
cmake_policy(VERSION 3.16)
|
|
|
|
include(ECMMarkAsTest)
|
|
include(ECMMarkNonGuiExecutable)
|
|
|
|
# set variable on the include scope, as consumers are supposed to have access to it
|
|
if(NOT DEFINED ECM_TEST_NAME_PREFIX_IGNORE_DIRS)
|
|
set(ECM_TEST_NAME_PREFIX_IGNORE_DIRS "src" "test" "tests" "autotest" "autotests")
|
|
endif()
|
|
|
|
function(_ecm_test_name_prefix_from_project_path _name_prefix_varname)
|
|
# estimate names of chain of dirs of current source dir to main dir
|
|
file(RELATIVE_PATH _project_path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
|
|
|
|
if(_project_path MATCHES "^\\.\\./")
|
|
message(FATAL_ERROR "The PATH strategy can not be used with directories outside the root source dir.")
|
|
endif()
|
|
|
|
string(REPLACE "/" ";" _dirs ${_project_path})
|
|
|
|
# derive prefix names
|
|
set(_names)
|
|
set(_subpath ${CMAKE_SOURCE_DIR})
|
|
set(_lastcmakesubpath ${_subpath}) # path of current including CMakeLists.txt
|
|
set(_relativelastcmakesubpath)
|
|
get_directory_property(_cmakesubdirs DIRECTORY ${_lastcmakesubpath} "SUBDIRECTORIES")
|
|
foreach(_dir ${_dirs})
|
|
string(APPEND _subpath "/${_dir}")
|
|
|
|
# subdir with CMakeLists.txt?
|
|
if(_subpath IN_LIST _cmakesubdirs)
|
|
set(_lastcmakesubpath ${_subpath})
|
|
set(_relativelastcmakesubpath)
|
|
set(_property_name_suffix)
|
|
# prepare nexs subdir
|
|
get_directory_property(_cmakesubdirs DIRECTORY ${_lastcmakesubpath} "SUBDIRECTORIES")
|
|
else()
|
|
string(APPEND _relativelastcmakesubpath "/${_dir}")
|
|
# keep in sync with writing the properties in ecm_test_set_dir_properties
|
|
string(SHA1 _relativelastcmakesubpath_hash ${_relativelastcmakesubpath})
|
|
set(_property_name_suffix ":${_relativelastcmakesubpath_hash}")
|
|
endif()
|
|
|
|
get_directory_property(_substitute_name DIRECTORY ${_lastcmakesubpath} "ECM_TEST_NAME_PREFIX_DIR_NAME${_property_name_suffix}")
|
|
|
|
get_directory_property(_first_name DIRECTORY ${_lastcmakesubpath} "ECM_TEST_NAME_PREFIX_DIR_FIRST${_property_name_suffix}")
|
|
|
|
if(_first_name)
|
|
# drop any current names
|
|
set(_names)
|
|
endif()
|
|
|
|
if (_substitute_name)
|
|
list(APPEND _names ${_substitute_name})
|
|
else()
|
|
get_directory_property(_ignore_dir DIRECTORY ${_lastcmakesubpath} "ECM_TEST_NAME_PREFIX_DIR_IGNORE${_property_name_suffix}")
|
|
if (_ignore_dir STREQUAL "")
|
|
if(_dir IN_LIST ECM_TEST_NAME_PREFIX_IGNORE_DIRS)
|
|
set(_ignore_dir TRUE)
|
|
else()
|
|
set(_ignore_dir FALSE)
|
|
endif()
|
|
endif()
|
|
if(NOT _ignore_dir)
|
|
list(APPEND _names ${_dir})
|
|
endif()
|
|
endif()
|
|
|
|
get_directory_property(_last_name DIRECTORY ${_lastcmakesubpath} "ECM_TEST_NAME_PREFIX_DIR_LAST${_property_name_suffix}")
|
|
if(_last_name)
|
|
# finish estimating prefix names
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
|
|
# create final prefix name
|
|
string(JOIN "-" _name_prefix ${_names})
|
|
if (_name_prefix)
|
|
string(APPEND _name_prefix "-")
|
|
endif()
|
|
|
|
set(${_name_prefix_varname} ${_name_prefix} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(ecm_test_set_dir_properties)
|
|
set(options PREFIX_NAME_IGNORE PREFIX_NAME_NOT_IGNORE FIRST_PREFIX_NAME LAST_PREFIX_NAME)
|
|
set(oneValueArgs PREFIX_NAME DIR)
|
|
set(multiValueArgs)
|
|
cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
|
|
if(ARG_UNPARSED_ARGUMENTS)
|
|
message(FATAL_ERROR "Unknown keywords given to ECM_TEST_SET_DIR_PROPERTIES(): \"${ARG_UNPARSED_ARGUMENTS}\"")
|
|
endif()
|
|
if(ARG_PREFIX_NAME_IGNORE AND ARG_PREFIX_NAME_NOT_IGNORE)
|
|
message(FATAL_ERROR "Pass either PREFIX_NAME_IGNORE or PREFIX_NAME_NOT_IGNORE to ECM_TEST_SET_DIR_PROPERTIES.")
|
|
endif()
|
|
set(_subdir)
|
|
if(ARG_DIR)
|
|
get_filename_component(_subdir ${ARG_DIR} REALPATH)
|
|
if(NOT IS_DIRECTORY "${_subdir}")
|
|
message(FATAL_ERROR "DIR argument passed to ECM_TEST_SET_DIR_PROPERTIES is not a directory: \"${ARG_DIR}\"")
|
|
endif()
|
|
if (_subdir STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
|
|
set(_subdir)
|
|
else()
|
|
file(RELATIVE_PATH _subdir ${CMAKE_CURRENT_SOURCE_DIR} ${_subdir})
|
|
if(_subdir MATCHES "^\\.\\./")
|
|
message(FATAL_ERROR "DIR argument passed to ECM_TEST_SET_DIR_PROPERTIES is not a subdirectory: \"${ARG_DIR}\"")
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
if(_subdir)
|
|
# map to a hash, as cmake does not specify allowed property characters
|
|
# keep in sync with reading the properties in _ecm_test_name_prefix_from_project_path
|
|
string(SHA1 _subdir_hash "/${_subdir}")
|
|
set(_property_name_suffix ":${_subdir_hash}")
|
|
else()
|
|
set(_property_name_suffix)
|
|
endif()
|
|
|
|
if (ARG_PREFIX_NAME)
|
|
set_directory_properties(PROPERTIES "ECM_TEST_NAME_PREFIX_DIR_NAME${_property_name_suffix}" "${ARG_PREFIX_NAME}")
|
|
endif()
|
|
if (ARG_PREFIX_NAME_IGNORE)
|
|
set_directory_properties(PROPERTIES "ECM_TEST_NAME_PREFIX_DIR_IGNORE${_property_name_suffix}" "TRUE")
|
|
endif()
|
|
if (ARG_PREFIX_NAME_NOT_IGNORE)
|
|
set_directory_properties(PROPERTIES "ECM_TEST_NAME_PREFIX_DIR_IGNORE${_property_name_suffix}" "FALSE")
|
|
endif()
|
|
if (ARG_FIRST_PREFIX_NAME)
|
|
set_directory_properties(PROPERTIES "ECM_TEST_NAME_PREFIX_DIR_FIRST${_property_name_suffix}" "TRUE")
|
|
endif()
|
|
if (ARG_LAST_PREFIX_NAME)
|
|
set_directory_properties(PROPERTIES "ECM_TEST_NAME_PREFIX_DIR_LAST${_property_name_suffix}" "TRUE")
|
|
endif()
|
|
endfunction()
|
|
|
|
function(ecm_test_get_name_prefix _name_prefix_varname)
|
|
if(NOT ECM_TEST_NAME_PREFIX_STRATEGY)
|
|
set(_strategy "VARIABLE")
|
|
else()
|
|
set(_strategies "VARIABLE" "PATH")
|
|
if (NOT ECM_TEST_NAME_PREFIX_STRATEGY IN_LIST _strategies)
|
|
message(FATAL_ERROR "ECM_TEST_NAME_PREFIX_STRATEGY set to unknown value ${ECM_TEST_NAME_PREFIX_STRATEGY}")
|
|
endif()
|
|
set(_strategy ${ECM_TEST_NAME_PREFIX_STRATEGY})
|
|
endif()
|
|
|
|
if (${_strategy} STREQUAL "PATH")
|
|
_ecm_test_name_prefix_from_project_path(_name_prefix)
|
|
else()
|
|
set(_name_prefix ${ECM_TEST_NAME_PREFIX})
|
|
endif()
|
|
set(${_name_prefix_varname} ${_name_prefix} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(ecm_add_test)
|
|
set(options GUI NO_NAME_PREFIX)
|
|
set(oneValueArgs TEST_NAME NAME_PREFIX TARGET_NAME_VAR TEST_NAME_VAR WORKING_DIRECTORY)
|
|
set(multiValueArgs COMPILE_DEFINITIONS ENVIRONMENT LINK_LIBRARIES)
|
|
cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
set(_sources ${ARG_UNPARSED_ARGUMENTS})
|
|
list(LENGTH _sources _sourceCount)
|
|
if(ARG_TEST_NAME)
|
|
set(_targetname ${ARG_TEST_NAME})
|
|
elseif(${_sourceCount} EQUAL "1")
|
|
#use the source file name without extension as the testname
|
|
get_filename_component(_targetname ${_sources} NAME_WE)
|
|
else()
|
|
#more than one source file passed, but no test name given -> error
|
|
message(FATAL_ERROR "ecm_add_test() called with multiple source files but without setting \"TEST_NAME\"")
|
|
endif()
|
|
|
|
if (NOT ARG_NAME_PREFIX)
|
|
if(NOT ARG_NO_NAME_PREFIX)
|
|
ecm_test_get_name_prefix(ARG_NAME_PREFIX)
|
|
endif()
|
|
else()
|
|
if(ARG_NO_NAME_PREFIX)
|
|
message(FATAL_ERROR "ecm_add_test() called with both \"NO_NAME_PREFIX\" and \"NAME_PREFIX\"")
|
|
endif()
|
|
endif()
|
|
set(_testname ${ARG_NAME_PREFIX}${_targetname})
|
|
set(gui_args)
|
|
if(ARG_GUI)
|
|
set(gui_args WIN32 MACOSX_BUNDLE)
|
|
endif()
|
|
add_executable(${_targetname} ${gui_args} ${_sources})
|
|
if(NOT ARG_GUI)
|
|
ecm_mark_nongui_executable(${_targetname})
|
|
endif()
|
|
set(test_args)
|
|
if(DEFINED ARG_WORKING_DIRECTORY)
|
|
list(APPEND test_args WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY})
|
|
endif()
|
|
add_test(NAME ${_testname} COMMAND ${_targetname} ${test_args})
|
|
target_link_libraries(${_targetname} ${ARG_LINK_LIBRARIES})
|
|
target_compile_definitions(${_targetname} PRIVATE -DQT_FORCE_ASSERTS ${ARG_COMPILE_DEFINITIONS})
|
|
ecm_mark_as_test(${_targetname})
|
|
if (CMAKE_LIBRARY_OUTPUT_DIRECTORY)
|
|
set(_plugin_path ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
|
|
if (DEFINED ENV{QT_PLUGIN_PATH})
|
|
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
|
|
# https://stackoverflow.com/questions/59862894/how-do-i-make-a-list-in-cmake-with-the-semicolon-value
|
|
set(PATHSEP "\\\;") # Don't want cmake to treat it like a list
|
|
else() # e.g. Linux
|
|
set(PATHSEP ":")
|
|
endif()
|
|
set(_plugin_path "${_plugin_path}${PATHSEP}$ENV{QT_PLUGIN_PATH}")
|
|
endif()
|
|
list(APPEND ARG_ENVIRONMENT "QT_PLUGIN_PATH=${_plugin_path}")
|
|
endif()
|
|
if (ARG_ENVIRONMENT)
|
|
list(JOIN ARG_ENVIRONMENT ";" env)
|
|
set_property(TEST ${_testname} PROPERTY ENVIRONMENT "${env}")
|
|
endif()
|
|
if (ARG_TARGET_NAME_VAR)
|
|
set(${ARG_TARGET_NAME_VAR} "${_targetname}" PARENT_SCOPE)
|
|
endif()
|
|
if (ARG_TEST_NAME_VAR)
|
|
set(${ARG_TEST_NAME_VAR} "${_testname}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(ecm_add_tests)
|
|
set(options GUI NO_NAME_PREFIX)
|
|
set(oneValueArgs NAME_PREFIX TARGET_NAMES_VAR TEST_NAMES_VAR WORKING_DIRECTORY)
|
|
set(multiValueArgs COMPILE_DEFINITIONS ENVIRONMENT LINK_LIBRARIES)
|
|
cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
|
|
set(_name_prefix "")
|
|
if(ARG_NO_NAME_PREFIX)
|
|
if(ARG_NAME_PREFIX)
|
|
message(FATAL_ERROR "ecm_add_tests() called with both \"NO_NAME_PREFIX\" and \"NAME_PREFIX\"")
|
|
endif()
|
|
elseif(ARG_NAME_PREFIX)
|
|
set(_name_prefix "NAME_PREFIX" "${ARG_NAME_PREFIX}")
|
|
endif()
|
|
|
|
if(ARG_GUI)
|
|
set(_exe_type GUI)
|
|
else()
|
|
set(_exe_type "")
|
|
endif()
|
|
set(test_args)
|
|
if(DEFINED ARG_WORKING_DIRECTORY)
|
|
list(APPEND test_args WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY})
|
|
endif()
|
|
set(test_names)
|
|
set(target_names)
|
|
foreach(_test_source ${ARG_UNPARSED_ARGUMENTS})
|
|
ecm_add_test(${_test_source}
|
|
${_name_prefix}
|
|
COMPILE_DEFINITIONS ${ARG_COMPILE_DEFINITIONS}
|
|
ENVIRONMENT ${ARG_ENVIRONMENT}
|
|
LINK_LIBRARIES ${ARG_LINK_LIBRARIES}
|
|
TARGET_NAME_VAR target_name
|
|
TEST_NAME_VAR test_name
|
|
${_exe_type}
|
|
${test_args}
|
|
)
|
|
list(APPEND _test_names "${test_name}")
|
|
list(APPEND _target_names "${target_name}")
|
|
endforeach()
|
|
if (ARG_TARGET_NAMES_VAR)
|
|
set(${ARG_TARGET_NAMES_VAR} "${_target_names}" PARENT_SCOPE)
|
|
endif()
|
|
if (ARG_TEST_NAMES_VAR)
|
|
set(${ARG_TEST_NAMES_VAR} "${_test_names}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|