Martin Hořeňovský
97ec4e8e2e
Previously, the `catch_discover_tests` would prepare the entire CTest command (e.g. `add_test(...)` or `set_tests_properties(...)`) first, and then escape it when finished. However, this caused lot of the command args to be escaped over and over again (e.g. executable name or Catch2's reporter args), for no reason, as they were always the same, and thus their escaping was always the same. Until recently, the performance overhead didn't matter as there were many spots which had quadratic runtime in number of tests. However, the recent refactorings fixed these, and this commit now improves the throughput by 10-20%. Also extended the benchmarked COUNTS in `benchmark_discovery.py`, because the performance is now good enough that it is reasonable to benchmark 16k tests.
548 lines
21 KiB
CMake
548 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}")
|
|
set(prefix "${_TEST_PREFIX}")
|
|
set(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()
|