File cmake.obscpio of Package Cpputest

0707010000BFBC000041ED000003E8000000640000000268A04FE700000000000000080000003000000000000000000000000E00000000cmake/Scripts0707010000BFBE000041ED000003E8000000640000000268A04FE700000000000000080000003000000000000000000000001100000000cmake/Toolchains0707010000BFB8000041ED000003E8000000640000000268A04FE700000000000000080000003000000000000000000000000E00000000cmake/Modules0707010000BFC4000081A4000003E8000000640000000168A04FE7000008CA000000080000003000000000000000000000001400000000cmake/install.cmakeset(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_INCLUDEDIR}")
set(LIB_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}")
set(INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")

# Pkg-config file.
set(prefix "${CMAKE_INSTALL_PREFIX}")
set(exec_prefix "\${prefix}")
set(libdir "\${exec_prefix}/${LIB_INSTALL_DIR}")
set(includedir "\${prefix}/${INCLUDE_INSTALL_DIR}")
set(PACKAGE_VERSION "${PROJECT_VERSION}")

configure_file(cpputest.pc.in cpputest.pc @ONLY)
install(
    FILES "${CMAKE_CURRENT_BINARY_DIR}/cpputest.pc"
    DESTINATION ${LIB_INSTALL_DIR}/pkgconfig
)

install(
    FILES "${CMAKE_CURRENT_BINARY_DIR}/generated/CppUTestGeneratedConfig.h"
    DESTINATION "${INCLUDE_INSTALL_DIR}/generated"
)

include(CMakePackageConfigHelpers)

set(CPPUTEST_CONFIG_DEST "${LIB_INSTALL_DIR}/CppUTest/cmake")

configure_package_config_file(CppUTestConfig.cmake.install.in
    ${CMAKE_CURRENT_BINARY_DIR}/install/CppUTestConfig.cmake
    INSTALL_DESTINATION "${CPPUTEST_CONFIG_DEST}"
    PATH_VARS INCLUDE_INSTALL_DIR LIB_INSTALL_DIR)
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/install/CppUTestConfigVersion.cmake
    COMPATIBILITY SameMajorVersion
)
install(
    FILES
        ${CMAKE_CURRENT_BINARY_DIR}/install/CppUTestConfig.cmake
        ${CMAKE_CURRENT_BINARY_DIR}/install/CppUTestConfigVersion.cmake
    DESTINATION "${CPPUTEST_CONFIG_DEST}"
)
install(
    EXPORT CppUTestTargets
    NAMESPACE CppUTest::
    DESTINATION "${CPPUTEST_CONFIG_DEST}"
)
install(
    FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Scripts/CppUTestBuildTimeDiscoverTests.cmake
    DESTINATION "${CPPUTEST_CONFIG_DEST}/Scripts"
)
install(
    FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/CppUTestBuildTimeDiscoverTests.cmake
        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/CppUTest.cmake
        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/_CppUTestDiscovery.cmake
    DESTINATION "${CPPUTEST_CONFIG_DEST}/Modules"
)
configure_package_config_file(CppUTestConfig.cmake.build.in
    ${CMAKE_CURRENT_BINARY_DIR}/CppUTestConfig.cmake
    INSTALL_DESTINATION ${CMAKE_CURRENT_BINARY_DIR}
    PATH_VARS INCLUDE_DIR CMAKE_CURRENT_BINARY_DIR
)
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/CppUTestConfigVersion.cmake
    COMPATIBILITY SameMajorVersion
)
0707010000BFC5000081A4000003E8000000640000000168A04FE700000749000000080000003000000000000000000000001500000000cmake/warnings.cmakeunset(WARNING_COMMON_FLAGS)
unset(WARNING_C_FLAGS)
unset(WARNING_CXX_FLAGS)

if(
    (CMAKE_CXX_COMPILER_ID STREQUAL "GNU") OR
    (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") OR
    (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
)
    set(WARNING_COMMON_FLAGS
        -Wall
        -Wextra
        -pedantic
        -Wshadow
        -Wswitch-default
        -Wswitch-enum
        -Wconversion
        -Wsign-conversion
        -Wmissing-include-dirs
        -Wno-padded
        -Wno-disabled-macro-expansion
        -Wreserved-id-macro
        -Wreserved-identifier
        -Wno-long-long
        -Wno-unsafe-buffer-usage
    )

    set(WARNING_C_FLAGS
        -Wstrict-prototypes
    )

    set(WARNING_CXX_FLAGS
        -Woverloaded-virtual
        -Wno-global-constructors
        -Wno-exit-time-destructors
        -Wno-weak-vtables
        -Wno-old-style-cast
    )

    if(DEFINED CMAKE_CXX_STANDARD AND NOT CMAKE_CXX_STANDARD EQUAL 98)
        list(APPEND WARNING_CXX_FLAGS
            -Wno-c++98-compat
            -Wno-c++98-compat-pedantic
            -Wno-c++14-compat
            -Wno-inconsistent-missing-destructor-override
            -Wsuggest-override
        )
    endif()

    set(CMAKE_REQUIRED_FLAGS "-Wno-error")
endif()

include(CheckCCompilerFlag)
foreach(flag IN LISTS WARNING_COMMON_FLAGS WARNING_C_FLAGS)
    check_c_compiler_flag("${flag}" WARNING_C_FLAG_${flag})
    if(WARNING_C_FLAG_${flag})
        add_compile_options("$<$<COMPILE_LANGUAGE:C>:${flag}>")
    endif()
endforeach()

include(CheckCXXCompilerFlag)
foreach(flag IN LISTS WARNING_COMMON_FLAGS WARNING_CXX_FLAGS)
    string(REPLACE "++" "xx" WARNING_CXX_FLAG_VAR "WARNING_CXX_FLAG_${flag}")
    check_cxx_compiler_flag("${flag}" ${WARNING_CXX_FLAG_VAR})
    if(${WARNING_CXX_FLAG_VAR})
        add_compile_options("$<$<COMPILE_LANGUAGE:CXX>:${flag}>")
    endif()
endforeach()
0707010000BFBD000081A4000003E8000000640000000168A04FE700000E38000000080000003000000000000000000000003300000000cmake/Scripts/CppUTestBuildTimeDiscoverTests.cmake# Create CTest entries for EXECUTABLE in CTestTestfile.cmake
# Overwrite CTestTestfile.cmake with update version.

# Usage:
#
# This script is to be called from ../Modules/CppUTestBuildTimeDiscoverTests.cmake
#
# Notes on invocation and used variables:
# ${CMAKE_COMMAND} -DTESTS_DETAILED:BOOL=<ON|OFF> -DEXECUTABLE=<FULLPATH-TO-EXECUTABLE> -P <PATH-TO-THIS-SCRIPT>
#
# TESTS_DETAILED c.f. top-level CMakeLists.txt
# FULLPATH-TO-EXECUTABLE - use  $<TARGET_FILE:${EXECUTABLE}> or explicit
# The overwritten CTestTestfile.cmake is located in ${CMAKE_CURRENT_BINARY_DIR}
#
# Steps to generate ADD_TEST() commands build time
# - Read CTestTestfile.cmake
# - Create update entries
# - Remove duplicate entries
# - Write new CTestTestfile.cmake

######################################################################
# helpers
######################################################################
function (buildtime_add_test)
  # Create ADD_TEST() command string
  # - Extract and remove testname from ARGV
  # - Add inner quotes to test arguments
  # - Add "ADD_TEST()", and first and last quote
  # Append result to CTESTTESTS
  list(GET ARGV 0 testname)
  list(REMOVE_AT ARGV 0)
  string (REPLACE ";" "\" \"" TEST_ARGS "${ARGV}")
  set(test_to_add "ADD_TEST(${testname} \"${TEST_ARGS}\")")
  list(APPEND CTESTTESTS ${test_to_add})
  SET(CTESTTESTS ${CTESTTESTS} PARENT_SCOPE)
endfunction()

function (JOIN VALUES GLUE OUTPUT)
  string (REPLACE ";" "${GLUE}" _TMP_STR "${VALUES}")
  set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE)
endfunction()

function (buildtime_discover_tests EXECUTABLE DISCOVER_ARG OUTPUT)
  execute_process(COMMAND ${EMULATOR} ${EXECUTABLE} ${DISCOVER_ARG}
    OUTPUT_VARIABLE _TMP_OUTPUT
    ERROR_VARIABLE DISCOVER_ERR
    RESULT_VARIABLE DISCOVER_ERR)
  if(NOT ${DISCOVER_ERR} EQUAL 0)
    message(SEND_ERROR "Executable \"${EXECUTABLE} ${DISCOVER_ARG}\" failed with output:\n"
      "${DISCOVER_ERR}\n"
      "Please check that the excutable was added.")
  endif(NOT ${DISCOVER_ERR} EQUAL 0)
  separate_arguments(_TMP_OUTPUT)
  set(${OUTPUT} "${_TMP_OUTPUT}" PARENT_SCOPE)
endfunction()


######################################################################
# Implementation
######################################################################

set(CTESTFNAME "${CMAKE_CURRENT_BINARY_DIR}/CTestTestfile.cmake")
file(STRINGS ${CTESTFNAME} CTESTTESTS)
get_filename_component(EXECUTABLE_SHORT_NAME ${EXECUTABLE} NAME_WE)

if (TESTS_DETAILED)
  set(DISCOVER_ARG "-ln")
  buildtime_discover_tests("${EXECUTABLE}" "${DISCOVER_ARG}" TestList_GroupsAndNames)
  set(lastgroup "")
  foreach(testfullname ${TestList_GroupsAndNames})
    string(REGEX MATCH "^([^/.]+)" groupname ${testfullname})
    string(REGEX MATCH "([^/.]+)$" testname ${testfullname})
    if (NOT ("${groupname}" STREQUAL "${lastgroup}"))
      message("TestGroup: ${groupname}:")
      set(lastgroup "${groupname}")
    endif (NOT ("${groupname}" STREQUAL "${lastgroup}"))
    message("... ${testname}")
    buildtime_add_test(${EXECUTABLE_SHORT_NAME}.${testfullname} ${EMULATOR} ${EXECUTABLE} -sg ${groupname} -sn ${testname})
  endforeach()
else (TESTS_DETAILED)
  set(DISCOVER_ARG "-lg")
  buildtime_discover_tests("${EXECUTABLE}" "${DISCOVER_ARG}" TestList_Groups)
  foreach(group ${TestList_Groups})
    message("TestGroup: ${group}")
    buildtime_add_test(${EXECUTABLE_SHORT_NAME}.${group} ${EMULATOR} "${EXECUTABLE}" -sg ${group})
  endforeach()
endif (TESTS_DETAILED)


# create separate CTest test for each CppUTestTests test

list(REMOVE_DUPLICATES CTESTTESTS)
JOIN("${CTESTTESTS}" "\n" CTESTTESTS)
file(WRITE ${CTESTFNAME} "${CTESTTESTS}\n")
0707010000BFC0000081A4000003E8000000640000000168A04FE70000013F000000080000003000000000000000000000003300000000cmake/Toolchains/clang+mingw-win32.toolchain.cmake# Toolchain to use Clang compiler with MinGW binutils (e.g. linker) in Windows to generate 32-bits executables

set(CMAKE_C_COMPILER clang)
set(CMAKE_C_FLAGS "-target i686-w64-mingw32 -m32" CACHE STRING "" FORCE)
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_FLAGS "-target i686-w64-mingw32 -m32" CACHE STRING "" FORCE)0707010000BFC3000081A4000003E8000000640000000168A04FE7000003AC000000080000003000000000000000000000002B00000000cmake/Toolchains/ewarm-win.toolchain.cmake### BEGIN CMAKE_TOOLCHAIN_FILE
# "Generic" is used when compiling for bare-metal
set(CMAKE_SYSTEM_NAME Generic)

# Set the EW installation root directory
#(Avoid spaces in the path or you need to escape them)
set(EW_ROOT_DIR "E:/Program Files\ (x86)/IAR\ Systems/Embedded\ Workbench\ Arm 8.50.6/arm")

# Compiler flags needed to compile for this CPU
set(CPU_FLAGS "--cpu Cortex-M4F")

# Set up the CMake variables for compiler and assembler
# (The reason for both C and CXX variables is that CMake
# treats C and C++ tools individually)
set(CMAKE_C_COMPILER "${EW_ROOT_DIR}/bin/iccarm.exe" "${CPU_FLAGS} --dlib_config normal")
set(CMAKE_CXX_COMPILER "${EW_ROOT_DIR}/bin/iccarm.exe" "${CPU_FLAGS} --dlib_config normal")
set(CMAKE_ASM_COMPILER "${EW_ROOT_DIR}/bin/iasmarm.exe" "${CPU_FLAGS}")

# Build with cmake -S. -Bbuild -G "NMake Makefiles" -DCMAKE_TOOLCHAIN_FILE=cmake/Toolchains/ewarm-win.toolchain.cmake

### END CMAKE_TOOLCHAIN_FILE
0707010000BFC2000081A4000003E8000000640000000168A04FE700000373000000080000003000000000000000000000002D00000000cmake/Toolchains/ewarm-linux.toolchain.cmake### BEGIN CMAKE_TOOLCHAIN_FILE
# "Generic" is used when compiling for bare-metal
set(CMAKE_SYSTEM_NAME Generic)

# Set the EW installation root directory
#(Avoid spaces in the path or you need to escape them)
set(EW_ROOT_DIR "/opt/iarsystems/bxarm/arm/")

# Compiler flags needed to compile for this CPU
set(CPU_FLAGS "--cpu Cortex-M4F")

# Set up the CMake variables for compiler and assembler
# (The reason for both C and CXX variables is that CMake
# treats C and C++ tools individually)
set(CMAKE_C_COMPILER "${EW_ROOT_DIR}/bin/iccarm" "${CPU_FLAGS} --dlib_config normal")
set(CMAKE_CXX_COMPILER "${EW_ROOT_DIR}/bin/iccarm" "${CPU_FLAGS} --dlib_config normal")
set(CMAKE_ASM_COMPILER "${EW_ROOT_DIR}/bin/iasmarm" "${CPU_FLAGS}")

# Build with cmake -S. -Bbuild -G "Unix Makefiles" -DCMAKE_TOOLCHAIN_FILE=cmake/Toolchains/ewarm-linux.toolchain.cmake

### END CMAKE_TOOLCHAIN_FILE
0707010000BFBF000081A4000003E8000000640000000168A04FE7000000FC000000080000003000000000000000000000003300000000cmake/Toolchains/arm-none-eabi-gcc.toolchain.cmakeset(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR cortex-m4)

set(CMAKE_C_COMPILER arm-none-eabi-gcc)

set(CMAKE_C_FLAGS_INIT "-mcpu=cortex-m4")
set(CMAKE_CXX_FLAGS_INIT "-mcpu=cortex-m4")
set(CMAKE_EXE_LINKER_FLAGS_INIT "-specs=rdimon.specs")
0707010000BFC1000081A4000003E8000000640000000168A04FE700000139000000080000003000000000000000000000003300000000cmake/Toolchains/clang+mingw-win64.toolchain.cmake# Toolchain to use Clang compiler with MinGW binutils (e.g. linker) in Windows to generate 64-bits executables

set(CMAKE_C_COMPILER clang)
set(CMAKE_C_FLAGS "-target x86_64-w64-mingw32" CACHE STRING "" FORCE)
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_FLAGS "-target x86_64-w64-mingw32" CACHE STRING "" FORCE)0707010000BFB9000081A4000003E8000000640000000168A04FE700000DAA000000080000003000000000000000000000001D00000000cmake/Modules/CppUTest.cmakeset(_CPPUTEST_DISCOVERY_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/_CppUTestDiscovery.cmake
    CACHE INTERNAL "CppUTest discovery scripts"
)

option(CPPUTEST_TESTS_DETAILED "Run discovered tests individually")
option(CPPUTEST_JUNIT_REPORT "Output JUnit test reports")

function(cpputest_discover_tests target)
    set(options JUNIT)
    set(oneValueArgs DETAILED)
    set(multiValueArgs EXTRA_ARGS)
    cmake_parse_arguments(
        ""
        "${options}"
        "${oneValueArgs}"
        "${multiValueArgs}"
        ${ARGN}
    )

    # Validate arguments.
    if(NOT TARGET ${target})
        message(FATAL_ERROR
            "Cannot discover tests for target \"${target}\" "
            "which is not built by this project."
        )
    endif()

    get_property(target_type
        TARGET ${target}
        PROPERTY TYPE
    )
    if(NOT target_type STREQUAL "EXECUTABLE")
        message(FATAL_ERROR
        "Cannot discover tests for target \"${target}\" "
        "which is not an executable."
        )
    endif()
    
    get_property(emulator
        TARGET ${target}
        PROPERTY CROSSCOMPILING_EMULATOR
    )
    if(CMAKE_CROSSCOMPILING)
        if(NOT emulator)
            message(WARNING "Cannot discover cross compiled tests without an emulator")
            return()
        endif()
    endif()

    if(NOT DEFINED _EXTRA_ARGS)
        set(_EXTRA_ARGS -v)
    endif()

    if(NOT DEFINED _DETAILED)
        set(_DETAILED ${CPPUTEST_TESTS_DETAILED})
    endif()

    if(_JUNIT OR CPPUTEST_JUNIT_REPORT)
        list(APPEND _EXTRA_ARGS -ojunit)
    endif()

    set(CTEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/${target}_include.cmake")
    if(CMAKE_CONFIGURATION_TYPES)
        set(CTEST_GENERATED_FILE "${CMAKE_CURRENT_BINARY_DIR}/${target}.$<CONFIG>.cmake")
        file(WRITE "${CTEST_INCLUDE_FILE}"
            "if(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/${target}.\${CTEST_CONFIGURATION_TYPE}.cmake\")\n"
            "  include(\"${CMAKE_CURRENT_BINARY_DIR}/${target}.\${CTEST_CONFIGURATION_TYPE}.cmake\")\n"
            "endif()\n"
        )
    else()
        set(CTEST_GENERATED_FILE "${CMAKE_CURRENT_BINARY_DIR}/${target}.cmake")
        file(WRITE "${CTEST_INCLUDE_FILE}"
            "if(EXISTS \"${CTEST_GENERATED_FILE}\")\n"
            "  include(\"${CTEST_GENERATED_FILE}\")\n"
            "endif()\n"
        )
    endif()

    add_custom_command(
        TARGET ${target} POST_BUILD
        BYPRODUCTS "${CTEST_GENERATED_FILE}"
        COMMAND
            "${CMAKE_COMMAND}"
            -D "TESTS_DETAILED:BOOL=${_DETAILED}"
            -D "EXECUTABLE=$<TARGET_FILE:${target}>"
            -D "EMULATOR=${emulator}"
            -D "ARGS=${_EXTRA_ARGS}"
            -D "CTEST_FILE=${CTEST_GENERATED_FILE}"
            -P "${_CPPUTEST_DISCOVERY_SCRIPT}"
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
        VERBATIM
    )

    if(${CMAKE_VERSION} VERSION_LESS "3.10")
        # We can only set one.
        get_property(already_set
            DIRECTORY
            PROPERTY TEST_INCLUDE_FILE
            SET
        )
        if(${already_set})
            message(FATAL_ERROR
                "Cannot discovery multiple tests from the same file"
            )
        endif()
        set_property(
            DIRECTORY
            PROPERTY TEST_INCLUDE_FILE "${CTEST_INCLUDE_FILE}"
        )
    else()
        set_property(
            DIRECTORY APPEND
            PROPERTY TEST_INCLUDE_FILES "${CTEST_INCLUDE_FILE}"
        )
    endif()

endfunction()
0707010000BFBB000081A4000003E8000000640000000168A04FE700000C28000000080000003000000000000000000000002700000000cmake/Modules/_CppUTestDiscovery.cmakeset(script)

function(add_command NAME)
    set(_args "")
    # use ARGV* instead of ARGN, because ARGN splits arrays into multiple arguments
    math(EXPR _last_arg ${ARGC}-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()
    set(script "${script}${NAME}(${_args})\n" PARENT_SCOPE)
endfunction()

if(NOT EXISTS "${EXECUTABLE}")
    message(FATAL_ERROR
        "Executable \"${EXECUTABLE}\" does not exist"
    )
endif()

macro(add_test_to_script TEST_NAME TEST_LOCATION SELECT_ARG)
    add_command(
        add_test
        "${TEST_NAME}"
        ${EMULATOR}
        "${EXECUTABLE}"
        ${ARGS}
        ${SELECT_ARG}
        ${TEST_NAME}
    )
    add_command(
        set_tests_properties
        "${TEST_NAME}"
        PROPERTIES
        DEF_SOURCE_LINE
        "${TEST_LOCATION}"
    )
endmacro()

execute_process(
    COMMAND ${EMULATOR} "${EXECUTABLE}" -ll
    OUTPUT_VARIABLE discovered_tests
    RESULT_VARIABLE result
    ERROR_VARIABLE error
)
if(NOT ${result} EQUAL 0)
    message(FATAL_ERROR
        "Error executing ${EXECUTABLE}:\n"
        "${error}"
    )
endif()

string(CONCAT LL_LINE_REGEX
    "^([^.]*)" # test group
    "\\."
    "([^.]*)"  # test name
    "\\."
    "(.*)"     # file name (only this field is allowed to contain dots)
    "\\."
    "([^.]*)"  # line number
    "\n"
)
string(REGEX MATCHALL "[^\n]+\n" discovered_test_lines "${discovered_tests}")
if(TESTS_DETAILED)
    foreach(line IN LISTS discovered_test_lines)
        string(REGEX MATCH "${LL_LINE_REGEX}" __unused "${line}")
        set(test_name "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}")
        file(TO_CMAKE_PATH "${CMAKE_MATCH_3}" test_file)
        set(test_location "${test_file}:${CMAKE_MATCH_4}")
        add_test_to_script("${test_name}" "${test_location}" -st)
    endforeach()
else()
    foreach(line IN LISTS discovered_test_lines)
        string(REGEX MATCH "${LL_LINE_REGEX}" __unused "${line}")
        set(test_name "${CMAKE_MATCH_1}")
        file(TO_CMAKE_PATH "${CMAKE_MATCH_3}" test_file)
        set(test_line "${CMAKE_MATCH_4}")
        if (NOT _${test_name}_file)
            # if the group spans two files, arbitrarily choose the first one encountered
            set(_${test_name}_file "${test_file}")
            set(_${test_name}_line "${test_line}")
        elseif(test_file STREQUAL _${test_name}_file AND test_line LESS _${test_name}_line)
            # line number will eventually be the first line of the first test in the group's file
            set(_${test_name}_line ${test_line})
        endif()
        list(APPEND groups_seen ${test_name})
    endforeach()
    list(REMOVE_DUPLICATES groups_seen)
    foreach(test_name IN LISTS groups_seen)
        set(test_location "${_${test_name}_file}:${_${test_name}_line}")
        add_test_to_script("${test_name}" "${test_location}" -sg)
    endforeach()
endif()

file(WRITE "${CTEST_FILE}" "${script}")
0707010000BFBA000081A4000003E8000000640000000168A04FE700000581000000080000003000000000000000000000003300000000cmake/Modules/CppUTestBuildTimeDiscoverTests.cmakeoption(CPPUTEST_TESTS_DETAILED "Run discovered tests individually")

set(_DISCOVER_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/../Scripts/CppUTestBuildTimeDiscoverTests.cmake")

# Create target to discover tests
function (cpputest_buildtime_discover_tests tgt)
  message(DEPRECATION
    "Use cpputest_discover_tests from the CppUTest module instead"
  )

  set(options)
  set(oneValueArgs DETAILED)
  set(multiValueArgs)
  cmake_parse_arguments(
    ""
    "${options}"
    "${oneValueArgs}"
    "${multiValueArgs}"
    ${ARGN}
  )
  if(NOT DEFINED _DETAILED)
    set(_DETAILED ${CPPUTEST_TESTS_DETAILED})
  endif()

  if(NOT TARGET ${tgt})
    message(FATAL_ERROR
      "Cannot discover tests for target \"${tgt}\" "
      "which is not built by this project."
    )
  endif()

  get_property(target_type
    TARGET ${tgt}
    PROPERTY TYPE
  )
  if(NOT target_type STREQUAL "EXECUTABLE")
    message(FATAL_ERROR
      "Cannot discover tests for target \"${tgt}\" "
      "which is not an executable."
    )
  endif()

  add_custom_command(
    TARGET ${tgt} POST_BUILD
    COMMAND
      ${CMAKE_COMMAND}
      -D "TESTS_DETAILED:BOOL=${_DETAILED}"
      -D "EXECUTABLE=$<TARGET_FILE:${tgt}>"
      -D "EMULATOR=$<TARGET_PROPERTY:${tgt},CROSSCOMPILING_EMULATOR>"
      -P "${_DISCOVER_SCRIPT}"
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Discovering Tests in ${tgt}"
    VERBATIM
  )
endfunction ()
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!