mirror of
https://github.com/catchorg/Catch2.git
synced 2026-08-25 23:03:25 +02:00
550 lines
21 KiB
CMake
550 lines
21 KiB
CMake
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
# file Copyright.txt or https://cmake.org/licensing for details.
|
|
|
|
# Because natively using CMake's JSON processing for arrays leads to quadratic
|
|
# running times, we do terrible hack and split JSON array by object boundary
|
|
# + commas and try to reconstruct valid JSON objects. During this, we need
|
|
# to replace CMake characters that could be in the test name/tags with
|
|
# placeholder, so it doesn't affect CMake's processing of the strings/lists
|
|
# we create during the parsing.
|
|
#
|
|
# We use 0x01, 0x02, 0x03, and 0x04 as placeholder bytes, as those cannot
|
|
# exist in JSON unescaped.
|
|
#
|
|
# 0x01 <=> ';' (CMake list separator)
|
|
# 0x02 <-> '[' (opens a CMake bracket-argument context)
|
|
# 0x03 <-> ']' (closes a CMake bracket-argument context)
|
|
# 0x04 == element boundary marker used while splitting the tests array
|
|
#
|
|
string(ASCII 1 _SemicolonEscape)
|
|
string(ASCII 2 _OpenBracketEscape)
|
|
string(ASCII 3 _CloseBracketEscape)
|
|
string(ASCII 4 _BoundaryEscape)
|
|
|
|
|
|
# As far as I can tell, the only way of having unclosed '[' or ']' in the
|
|
# list of test names we define for CTest, is to escape them into completely
|
|
# different characters. Otherwise, they will break parsing of unrelated
|
|
# semicolons (inserted by CMake after parsing the list from the user-facing
|
|
# space separated format). This means that the consumers of the list have
|
|
# to unescape them back, but that's CMake :v
|
|
#
|
|
# 0x02 <-> '['
|
|
# 0x03 <-> ']'
|
|
#
|
|
string(ASCII 2 _OpenBracketListingEscape)
|
|
string(ASCII 3 _CloseBracketListingEscape)
|
|
|
|
|
|
# Placeholder bytes in the listing would break our parsing hack, so
|
|
# we check they don't exist. They shouldn't exist in valid JSON, but
|
|
# the reporter might not be escaping them properly.
|
|
function(validate_input_noescapes listing_var)
|
|
foreach(byte "${_SemicolonEscape}" "${_BoundaryEscape}" "${_OpenBracketEscape}" "${_CloseBracketEscape}")
|
|
string(FIND "${${listing_var}}" "${byte}" found)
|
|
if(NOT found EQUAL -1)
|
|
message(FATAL_ERROR
|
|
"The test listing contains raw control byte (0x01-0x04) which should not "
|
|
"be there. This means either bad escaping in JSON reporter, or corrupted file. "
|
|
)
|
|
endif()
|
|
endforeach()
|
|
endfunction()
|
|
|
|
|
|
# Replaces relevant characters with their placeholders, see the top of this file.
|
|
# Modifies argument `var` in place.
|
|
function(magic_escape_chars var)
|
|
set(value "${${var}}")
|
|
string(REPLACE ";" "${_SemicolonEscape}" value "${value}")
|
|
string(REPLACE "[" "${_OpenBracketEscape}" value "${value}")
|
|
string(REPLACE "]" "${_CloseBracketEscape}" value "${value}")
|
|
set(${var} "${value}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
# Turns placeholders back into original characters, see the top of this file.
|
|
# Modifies argument `var` in place.
|
|
function(magic_unescape_chars var)
|
|
set(value "${${var}}")
|
|
string(REPLACE "${_SemicolonEscape}" ";" value "${value}")
|
|
string(REPLACE "${_OpenBracketEscape}" "[" value "${value}")
|
|
string(REPLACE "${_CloseBracketEscape}" "]" value "${value}")
|
|
set(${var} "${value}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
# Abuses knowledge of Catch2's JSON reporter output for listing tests to
|
|
# split JSON array of the test listings into a CMake list of strings,
|
|
# with each element being the JSON string of one array entry.
|
|
#
|
|
# This avoids the terrible quadratic running time of using CMake's JSON
|
|
# support to parse the JSON reporter output "properly", where the whole
|
|
# JSON array of tests is parsed again for every element. Instead, we can
|
|
# use the CMake's API to only parse the individual test's objects, which
|
|
# are usually small and only have to be reparsed fixed number of times
|
|
# (once for test names, once for labels).
|
|
#
|
|
# We process the string representing the JSON array by splitting it on
|
|
# `}<ws>*,<ws>*{` and then checking for each chunk whether it is a valid
|
|
# JSON object representing Catch2's test. If not (e.g. because we split
|
|
# on the presence of `}<ws>*,<ws>*{` inside a test name), then we append
|
|
# the next chunk to the current one and check again. And again, until
|
|
# we get back to a valid JSON.
|
|
#
|
|
# Note that to support passing the object strings back from the function,
|
|
# they will still contain the placeholders and need to be unescaped before
|
|
# further processing (e.g. sending them into CMake's JSON parsing API).
|
|
function(split_json_array json_array_var out_var)
|
|
# We have to pass the input by var name to avoid CMake processing
|
|
# the input as an arg.
|
|
set(json_in "${${json_array_var}}")
|
|
|
|
# Strip the array brackets at the start and end of the JSON array.
|
|
# Must happen before we escape the other [] instances below from the
|
|
# actual array data.
|
|
string(REGEX REPLACE "^[ \t\r\n]*\\[" "" json_in "${json_in}")
|
|
string(REGEX REPLACE "\\][ \t\r\n]*$" "" json_in "${json_in}")
|
|
|
|
magic_escape_chars(json_in)
|
|
|
|
# We need to keep the whitespace around comma around, so that if we
|
|
# split inside the test object, we can reconstruct it losslessly.
|
|
string(REGEX REPLACE "(}[ \t\r\n]*)[,]([ \t\r\n]*{)" "\\1${_BoundaryEscape}\\2" json_in "${json_in}")
|
|
|
|
# We escaped all list separators above, so now we can turn the JSON
|
|
# string into a CMake list of fragments in single pass.
|
|
string(REPLACE "${_BoundaryEscape}" ";" fragments "${json_in}")
|
|
|
|
# And now we have to reconstruct the actual JSON structure from fragments.
|
|
set(array_elements "")
|
|
set(accumulator "")
|
|
foreach(next_fragment IN LISTS fragments)
|
|
if(accumulator)
|
|
set(accumulator "${accumulator},${next_fragment}")
|
|
else()
|
|
set(accumulator "${next_fragment}")
|
|
endif()
|
|
|
|
# Because the fragments (might) contain invalid JSON characters due
|
|
# to escaping, we have to unescape it before checking if we can parse it.
|
|
set(maybe_json "${accumulator}")
|
|
magic_unescape_chars(maybe_json)
|
|
string(JSON unused ERROR_VARIABLE err GET "${maybe_json}" "name")
|
|
if(err STREQUAL "NOTFOUND")
|
|
list(APPEND array_elements "${accumulator}")
|
|
set(accumulator "")
|
|
endif()
|
|
endforeach()
|
|
|
|
set(${out_var} "${array_elements}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
# Prepare (a part of) command with bracketed arguments and return it via `out_var`.
|
|
#
|
|
# This allows the registration script to escape parts of the test script
|
|
# only once, instead of escaping the unchanged arguments over and over again.
|
|
function(prepare_command_fragment out_var)
|
|
set(_args "")
|
|
math(EXPR _last_arg ${ARGC}-1)
|
|
if(_last_arg GREATER_EQUAL 1)
|
|
foreach(_n RANGE 1 ${_last_arg})
|
|
set(_arg "${ARGV${_n}}")
|
|
if(_arg MATCHES "[^-./:a-zA-Z0-9_]")
|
|
set(_args "${_args} [==[${_arg}]==]") # form a bracket_argument
|
|
else()
|
|
set(_args "${_args} ${_arg}")
|
|
endif()
|
|
endforeach()
|
|
endif()
|
|
set(${out_var} "${_args}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
# Generates random filename in the temp folder.
|
|
# Temp folder is retrieved by checking env vars from various platforms.
|
|
function(make_temp_file_path OUT_VARIABLE FALLBACK_PATH)
|
|
set(TEMP_DIR "")
|
|
set(ENV_VARS
|
|
# From XDG base dir specification
|
|
XDG_RUNTIME_DIR
|
|
# From POSIX standard
|
|
TMPDIR
|
|
# From Windows
|
|
TMP
|
|
TEMP
|
|
)
|
|
|
|
foreach(var ${ENV_VARS})
|
|
if(DEFINED ENV{${var}} AND NOT "$ENV{${var}}" STREQUAL "")
|
|
set(TEMP_DIR "$ENV{${var}}")
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
|
|
# If all checks fail, we use the fallback path
|
|
if(TEMP_DIR STREQUAL "")
|
|
set(TEMP_DIR "${FALLBACK_PATH}")
|
|
endif()
|
|
|
|
file(TO_CMAKE_PATH "${TEMP_DIR}" TEMP_DIR)
|
|
|
|
# Generate the random file name
|
|
string(RANDOM LENGTH 8 RAND_ID)
|
|
set(FINAL_TEMP_PATH "${TEMP_DIR}/Catch2-test-listing.${RAND_ID}.json")
|
|
|
|
set(${OUT_VARIABLE} "${FINAL_TEMP_PATH}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# Computes the path of the test-list file based on the path for the main
|
|
# CTest script file (passed in `CTEST_FILE`).
|
|
#
|
|
# It works by replacing the `_tests` part of the original name with
|
|
# `_test-list`, or failing that, it appends `-list.cmake` instead.
|
|
#
|
|
# <base>_tests.cmake -> <base>_test-list.cmake
|
|
# <base>_tests-Debug.cmake -> <base>_test-list-Debug.cmake
|
|
function(make_test_list_file_path CTEST_FILE OUT_VARIABLE)
|
|
if("${CTEST_FILE}" MATCHES "_tests(.*)\\.cmake$")
|
|
string(REGEX REPLACE "_tests(.*)\\.cmake$" "_test-list\\1.cmake" list_file "${CTEST_FILE}")
|
|
else()
|
|
set(list_file "${CTEST_FILE}-list.cmake")
|
|
endif()
|
|
set(${OUT_VARIABLE} "${list_file}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(catch_discover_tests_impl)
|
|
cmake_parse_arguments(
|
|
""
|
|
""
|
|
"TEST_EXECUTABLE;TEST_WORKING_DIR;TEST_OUTPUT_DIR;TEST_OUTPUT_PREFIX;TEST_OUTPUT_SUFFIX;TEST_PREFIX;TEST_REPORTER;TEST_SPEC;TEST_SUFFIX;TEST_LIST;CTEST_FILE"
|
|
"TEST_EXTRA_ARGS;TEST_PROPERTIES;TEST_EXECUTOR;TEST_DL_PATHS;TEST_DL_FRAMEWORK_PATHS;ADD_TAGS_AS_LABELS"
|
|
${ARGN}
|
|
)
|
|
|
|
# We write the list of all discovered tests into a separate file
|
|
make_test_list_file_path("${_CTEST_FILE}" _CTEST_LIST_FILE)
|
|
|
|
# We periodically append to the output files below, so we have to ensure
|
|
# that it is empty at the start, or we get duplicated test scripts.
|
|
file(REMOVE "${_CTEST_FILE}")
|
|
file(REMOVE "${_CTEST_LIST_FILE}")
|
|
|
|
# Size (in Bytes) at which the intermediate `script` var is dumped to file.
|
|
set(_WriteToFileThreshold 50000)
|
|
|
|
set(add_tags "${_ADD_TAGS_AS_LABELS}")
|
|
# TEST_{PREFIX,SUFFIX} is enclosed in single quotes to keep ensure
|
|
# leading/trailing whitespace isn't trimmed by CMake's argument passing.
|
|
string(REGEX REPLACE "^'(.*)'$" "\\1" prefix "${_TEST_PREFIX}")
|
|
string(REGEX REPLACE "^'(.*)'$" "\\1" suffix "${_TEST_SUFFIX}")
|
|
set(spec ${_TEST_SPEC})
|
|
set(extra_args ${_TEST_EXTRA_ARGS})
|
|
set(properties ${_TEST_PROPERTIES})
|
|
set(reporter ${_TEST_REPORTER})
|
|
set(output_dir ${_TEST_OUTPUT_DIR})
|
|
set(output_prefix ${_TEST_OUTPUT_PREFIX})
|
|
set(output_suffix ${_TEST_OUTPUT_SUFFIX})
|
|
set(dl_paths ${_TEST_DL_PATHS})
|
|
set(dl_framework_paths ${_TEST_DL_FRAMEWORK_PATHS})
|
|
set(environment_modifications "")
|
|
set(script)
|
|
set(suite)
|
|
set(tests)
|
|
# Holds the list of all registered test names **as a string**, not list.
|
|
# This avoids issue of CMake removing semicolon escapes even inside
|
|
# bracket-quoted strings.
|
|
set(_test_names)
|
|
|
|
if(WIN32)
|
|
set(dl_paths_variable_name PATH)
|
|
elseif(APPLE)
|
|
set(dl_paths_variable_name DYLD_LIBRARY_PATH)
|
|
else()
|
|
set(dl_paths_variable_name LD_LIBRARY_PATH)
|
|
endif()
|
|
|
|
# Run test executable to get list of available tests
|
|
if(NOT EXISTS "${_TEST_EXECUTABLE}")
|
|
message(FATAL_ERROR
|
|
"Specified test executable '${_TEST_EXECUTABLE}' does not exist"
|
|
)
|
|
endif()
|
|
|
|
if(dl_paths)
|
|
cmake_path(CONVERT "$ENV{${dl_paths_variable_name}}" TO_NATIVE_PATH_LIST env_dl_paths)
|
|
list(PREPEND env_dl_paths "${dl_paths}")
|
|
cmake_path(CONVERT "${env_dl_paths}" TO_NATIVE_PATH_LIST paths)
|
|
set(ENV{${dl_paths_variable_name}} "${paths}")
|
|
endif()
|
|
|
|
if(APPLE AND dl_framework_paths)
|
|
cmake_path(CONVERT "$ENV{DYLD_FRAMEWORK_PATH}" TO_NATIVE_PATH_LIST env_dl_framework_paths)
|
|
list(PREPEND env_dl_framework_paths "${dl_framework_paths}")
|
|
cmake_path(CONVERT "${env_dl_framework_paths}" TO_NATIVE_PATH_LIST paths)
|
|
set(ENV{DYLD_FRAMEWORK_PATH} "${paths}")
|
|
endif()
|
|
|
|
make_temp_file_path(listing_output_path "${_TEST_WORKING_DIR}")
|
|
|
|
set(_Verbosity "quiet")
|
|
if (add_tags)
|
|
set(_Verbosity "normal")
|
|
endif()
|
|
|
|
execute_process(
|
|
COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec}
|
|
--list-tests
|
|
--reporter "json::verbosity=${_Verbosity}"
|
|
--out "${listing_output_path}"
|
|
--order lex # Make sure the output order, and thus test registration order, is consistent across runs.
|
|
OUTPUT_VARIABLE listing_output
|
|
RESULT_VARIABLE result
|
|
WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
|
|
)
|
|
if(NOT ${result} EQUAL 0)
|
|
message(FATAL_ERROR
|
|
"Error listing tests from executable '${_TEST_EXECUTABLE}':\n"
|
|
" Result: ${result}\n"
|
|
" Output: ${listing_output}\n"
|
|
)
|
|
endif()
|
|
|
|
# Read the JSON output back from the output file and validate it.
|
|
file(READ ${listing_output_path} listing_output)
|
|
file(REMOVE ${listing_output_path})
|
|
validate_input_noescapes(listing_output)
|
|
|
|
# Prepare reporter
|
|
if(reporter)
|
|
set(reporter_arg "--reporter ${reporter}")
|
|
|
|
# Run test executable to check whether reporter is available
|
|
# note that the use of --list-reporters is not the important part,
|
|
# we only want to check whether the execution succeeds with ${reporter_arg}
|
|
execute_process(
|
|
COMMAND ${_TEST_EXECUTOR} "${_TEST_EXECUTABLE}" ${spec} ${reporter_arg} --list-reporters
|
|
OUTPUT_VARIABLE reporter_check_output
|
|
RESULT_VARIABLE reporter_check_result
|
|
WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
|
|
)
|
|
if(${reporter_check_result} EQUAL 255)
|
|
message(FATAL_ERROR
|
|
"\"${reporter}\" is not a valid reporter!\n"
|
|
)
|
|
elseif(NOT ${reporter_check_result} EQUAL 0)
|
|
message(FATAL_ERROR
|
|
"Error checking for reporter in test executable '${_TEST_EXECUTABLE}':\n"
|
|
" Result: ${reporter_check_result}\n"
|
|
" Output: ${reporter_check_output}\n"
|
|
)
|
|
endif()
|
|
endif()
|
|
|
|
# Prepare output dir
|
|
if(output_dir AND NOT IS_ABSOLUTE ${output_dir})
|
|
set(output_dir "${_TEST_WORKING_DIR}/${output_dir}")
|
|
if(NOT EXISTS ${output_dir})
|
|
file(MAKE_DIRECTORY ${output_dir})
|
|
endif()
|
|
endif()
|
|
|
|
if(dl_paths)
|
|
foreach(path ${dl_paths})
|
|
cmake_path(NATIVE_PATH path native_path)
|
|
list(PREPEND environment_modifications "${dl_paths_variable_name}=path_list_prepend:${native_path}")
|
|
endforeach()
|
|
endif()
|
|
|
|
if(APPLE AND dl_framework_paths)
|
|
foreach(path ${dl_framework_paths})
|
|
cmake_path(NATIVE_PATH path native_path)
|
|
list(PREPEND environment_modifications "DYLD_FRAMEWORK_PATH=path_list_prepend:${native_path}")
|
|
endforeach()
|
|
endif()
|
|
|
|
# Parse JSON output for list of tests/class names/tags
|
|
string(JSON version GET "${listing_output}" "version")
|
|
if(NOT version STREQUAL "2")
|
|
message(FATAL_ERROR "Unsupported catch output version: '${version}'")
|
|
endif()
|
|
|
|
# Extract just the JSON array with tests and then split them into
|
|
# individual objects.
|
|
string(JSON test_listing GET "${listing_output}" "listings" "tests")
|
|
split_json_array(test_listing tests)
|
|
|
|
# Exit early if no tests are detected
|
|
if(NOT tests)
|
|
# Still emit an (empty) test list file and have the main script include
|
|
# it, so that consumers relying on the `${_TEST_LIST}` variable and on the
|
|
# include structure get consistent behavior regardless of test count.
|
|
file(WRITE "${_CTEST_LIST_FILE}" "set(${_TEST_LIST})\n")
|
|
file(WRITE "${_CTEST_FILE}" "include(\"${_CTEST_LIST_FILE}\")\n")
|
|
return()
|
|
endif()
|
|
|
|
|
|
# The 'set(VAR` header for the test list has to be written separately,
|
|
# so that each test name can be appended file without further processing.
|
|
set(test_names "set(${_TEST_LIST}")
|
|
|
|
# Most of the commands/arguments in the CTest script are identical
|
|
# for every test registered with one `catch_discover_tests` call.
|
|
# To avoid repeating the work in escaping them, we escape them before
|
|
# the per-test loop and reuse the escaped fragments.
|
|
#
|
|
# `add_test` calls are
|
|
# add_test(<name><exec><exe><escaped_name><extra_args><reporter><out_dir>)
|
|
# Of these, <exec>,<exe>,<extra_args>, and <reporter> are the same between
|
|
# all tests.
|
|
prepare_command_fragment(_exec_exe_fragment
|
|
${_TEST_EXECUTOR}
|
|
"${_TEST_EXECUTABLE}"
|
|
)
|
|
prepare_command_fragment(_args_reporter_fragment
|
|
${extra_args}
|
|
"${reporter_arg}"
|
|
)
|
|
|
|
# `set_tests_properties` calls are
|
|
# set_tests_properties(<name> PROPERTIES WORKING_DIRECTORY <dir> <properties>)
|
|
# set_tests_properties(<name> PROPERTIES ENVIRONMENT_MODIFICATION <env_mod>)
|
|
# Of these, only the <name> changes between tests.
|
|
prepare_command_fragment(_properties_fragment
|
|
PROPERTIES
|
|
WORKING_DIRECTORY "${_TEST_WORKING_DIR}"
|
|
${properties}
|
|
)
|
|
# Env modification is optional, so we prepare it in a separate command
|
|
if(environment_modifications)
|
|
prepare_command_fragment(_env_modification_fragment
|
|
PROPERTIES
|
|
ENVIRONMENT_MODIFICATION "${environment_modifications}"
|
|
)
|
|
endif()
|
|
|
|
# Each element in the tests is JSON-string representing one test object.
|
|
# We have to parse it and then turn it into CTest script commands.
|
|
foreach(single_test IN LISTS tests)
|
|
# Because appending to the same string in CMake has quadratic runtime,
|
|
# we flush the script into the file periodically to avoid the worst case.
|
|
string(LENGTH "${script}" script_len)
|
|
if (script_len GREATER _WriteToFileThreshold)
|
|
file(APPEND "${_CTEST_FILE}" "${script}")
|
|
set(script "")
|
|
endif()
|
|
string(LENGTH "${test_names}" names_len)
|
|
if (names_len GREATER _WriteToFileThreshold)
|
|
file(APPEND "${_CTEST_LIST_FILE}" "${test_names}")
|
|
set(test_names "")
|
|
endif()
|
|
|
|
# The elements are still escaped and contain JSON-invalid characters,
|
|
# they have to be unescaped before parsing them as JSON.
|
|
magic_unescape_chars(single_test)
|
|
if(add_tags)
|
|
string(JSON test_tags GET "${single_test}" "tags")
|
|
endif()
|
|
string(JSON plain_name GET "${single_test}" "name")
|
|
|
|
# Escape characters in test case names that would be parsed by Catch2
|
|
# Note that the \ escaping must happen FIRST! Do not change the order.
|
|
set(escaped_name "${plain_name}")
|
|
foreach(char \\ , [ ] ;)
|
|
string(REPLACE ${char} "\\${char}" escaped_name "${escaped_name}")
|
|
endforeach(char)
|
|
# ...add output dir
|
|
if(output_dir)
|
|
string(REGEX REPLACE "[^A-Za-z0-9_]" "_" escaped_name_clean "${escaped_name}")
|
|
set(output_dir_arg "--out ${output_dir}/${output_prefix}${escaped_name_clean}${output_suffix}")
|
|
endif()
|
|
|
|
set(full_name "${prefix}${plain_name}${suffix}")
|
|
prepare_command_fragment(_full_name_fragment "${full_name}")
|
|
prepare_command_fragment(_escaped_name_fragment "${escaped_name}")
|
|
prepare_command_fragment(_outdir_fragment "${output_dir_arg}")
|
|
|
|
string(APPEND script
|
|
"add_test(${_full_name_fragment}${_exec_exe_fragment}${_escaped_name_fragment}${_args_reporter_fragment}${_outdir_fragment})\n")
|
|
string(APPEND script
|
|
"set_tests_properties(${_full_name_fragment}${_properties_fragment})\n")
|
|
|
|
if(add_tags)
|
|
string(JSON num_tags LENGTH "${test_tags}")
|
|
math(EXPR num_tags "${num_tags} - 1")
|
|
set(tag_list "")
|
|
if(num_tags GREATER_EQUAL "0")
|
|
foreach(tag_idx RANGE ${num_tags})
|
|
string(JSON a_tag GET "${test_tags}" "${tag_idx}")
|
|
# Catch2's tags can contain semicolons, which are list element separators
|
|
# in CMake, so we have to escape them. Ideally we could use the [=[...]=]
|
|
# syntax for this, but CTest currently keeps the square quotes in the label
|
|
# name. So we add 2 backslashes to escape it instead.
|
|
# **IMPORTANT**: The number of backslashes depends on how many layers
|
|
# of CMake the tag goes. If this script is changed, the
|
|
# number of backslashes to escape may change as well.
|
|
string(REPLACE ";" "\\;" a_tag "${a_tag}")
|
|
list(APPEND tag_list "${a_tag}")
|
|
endforeach()
|
|
|
|
prepare_command_fragment(_labels_fragment
|
|
PROPERTIES
|
|
LABELS "${tag_list}"
|
|
)
|
|
string(APPEND script "set_tests_properties(${_full_name_fragment}${_labels_fragment})\n")
|
|
endif()
|
|
endif(add_tags)
|
|
|
|
if(environment_modifications)
|
|
string(APPEND script "set_tests_properties(${_full_name_fragment}${_env_modification_fragment})\n")
|
|
endif()
|
|
|
|
# The test name has to be escaped using the same rules as prepare_command
|
|
# uses for the arguments, so that it keeps being single element in list
|
|
# even with weird characters and semicolons.
|
|
set(full_list_name "${prefix}${plain_name}${suffix}")
|
|
string(REPLACE ";" "\\;" full_list_name "${full_list_name}")
|
|
string(REPLACE "[" "${_OpenBracketListingEscape}" full_list_name "${full_list_name}")
|
|
string(REPLACE "]" "${_CloseBracketListingEscape}" full_list_name "${full_list_name}")
|
|
if(full_list_name MATCHES "[^-./:a-zA-Z0-9_]")
|
|
# The space before the start of quote is important, so that we get
|
|
# space-separated list in the final file.
|
|
string(APPEND test_names " [==[${full_list_name}]==]")
|
|
else()
|
|
string(APPEND test_names " ${full_list_name}")
|
|
endif()
|
|
endforeach()
|
|
|
|
# Write any test names leftovers we have
|
|
file(APPEND "${_CTEST_LIST_FILE}" "${test_names})\n")
|
|
# Write any main script leftovers we have, and append the include of test names
|
|
file(APPEND "${_CTEST_FILE}" "${script}")
|
|
file(APPEND "${_CTEST_FILE}" "include(\"${_CTEST_LIST_FILE}\")\n")
|
|
endfunction()
|
|
|
|
# To enable `include`ing this file in the unit test scripts, we only run
|
|
# the impl if an actual `TEST_EXECUTABLE` is provided.
|
|
if(CMAKE_SCRIPT_MODE_FILE AND DEFINED TEST_EXECUTABLE)
|
|
catch_discover_tests_impl(
|
|
TEST_EXECUTABLE ${TEST_EXECUTABLE}
|
|
TEST_EXECUTOR ${TEST_EXECUTOR}
|
|
TEST_WORKING_DIR ${TEST_WORKING_DIR}
|
|
TEST_SPEC ${TEST_SPEC}
|
|
TEST_EXTRA_ARGS ${TEST_EXTRA_ARGS}
|
|
TEST_PROPERTIES ${TEST_PROPERTIES}
|
|
TEST_PREFIX ${TEST_PREFIX}
|
|
TEST_SUFFIX ${TEST_SUFFIX}
|
|
TEST_LIST ${TEST_LIST}
|
|
TEST_REPORTER ${TEST_REPORTER}
|
|
TEST_OUTPUT_DIR ${TEST_OUTPUT_DIR}
|
|
TEST_OUTPUT_PREFIX ${TEST_OUTPUT_PREFIX}
|
|
TEST_OUTPUT_SUFFIX ${TEST_OUTPUT_SUFFIX}
|
|
TEST_DL_PATHS ${TEST_DL_PATHS}
|
|
TEST_DL_FRAMEWORK_PATHS ${TEST_DL_FRAMEWORK_PATHS}
|
|
CTEST_FILE ${CTEST_FILE}
|
|
ADD_TAGS_AS_LABELS ${ADD_TAGS_AS_LABELS}
|
|
)
|
|
endif()
|