# **********************************************************
# Copyright (c) 2011-2023 Google, Inc. All rights reserved.
# Copyright (c) 2009-2010 VMware, Inc. All rights reserved.
# **********************************************************
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
#
# * Neither the name of VMware, Inc. nor the names of its contributors may be
# used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
# DAMAGE.
# Test suite script for DynamoRIO split into common pieces for re-use
# by tools.
# Usage:
# 1) In tool test suite script, set the project name, src dir,
# whether to run tests, and include the pre file:
# set(CTEST_PROJECT_NAME "DynamoRIO")
# set(cpack_project_name "DynamoRIO")
# set(run_tests ON)
# include("${PATH_TO_DR_EXPORTS}/cmake/runsuite_common_pre.cmake")
# 2) Do any custom argument processing and setting of base_cache
# or other vars. Can also do argument processing prior to
# the pre include.
# 3) Define function (error_string str outvar)
# It should set ${outvar} in PARENT_SCOPE to the set
# of specific errors found in ${str}.
# 4) Define the build_package boolean and include the post script:
# set(build_package ON)
# include("${PATH_TO_DR_EXPORTS}/cmake/runsuite_common_post.cmake")
# Also define build_source_package to build the package_source
# CPack target (only for non-Visual Studio generators).
#
# extra_ctest_args can also be defined to pass extra args to ctest_test(),
# such as INCLUDE_LABEL.
# ARCH_IS_X86 is defined for running x86 specific tests.
# Unfinished features in i#66 (now under i#121):
# * have a list of known failures and label w/ " (known: i#XX)"
cmake_minimum_required(VERSION 3.7)
set(cmake_ver_string
"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_RELEASE_VERSION}")
if (COMMAND cmake_policy)
# avoid warnings on include()
cmake_policy(VERSION 3.7)
endif()
# arguments are a ;-separated list (must escape as \; from ctest_run_script())
set(arg_nightly OFF) # whether to report the results
set(arg_site "") # site to report results for (for nightly reported runs)
set(arg_include "") # cmake file to include up front
set(arg_preload "") # cmake file to include prior to each 32-bit build
set(arg_preload64 "") # cmake file to include prior to each 64-bit build
set(arg_ssh OFF) # running over cygwin ssh: disable pdbs
set(arg_use_nmake OFF)# use nmake instead of visual studio
set(arg_use_msbuild OFF) # use msbuild instead of devenv for visual studio
if (UNIX)
set(arg_use_make ON) # use unix make
else (UNIX)
set(arg_use_make OFF) # use unix make instead of visual studio
endif (UNIX)
set(arg_use_ninja OFF) # use ninja
set(arg_generator "") # specify precise cmake generator (minus any "Win64")
set(arg_long OFF) # whether to run the long suite
set(arg_already_built OFF) # for testing w/ already-built suite
set(arg_exclude "") # regex of tests to exclude
set(arg_verbose OFF) # extra output
set(arg_32_only OFF) # do not include 64-bit
set(arg_64_only OFF) # do not include 64-bit
set(arg_build_only OFF) # do not run tests
foreach (arg ${CTEST_SCRIPT_ARG})
if (${arg} STREQUAL "nightly")
set(arg_nightly ON)
endif (${arg} STREQUAL "nightly")
if (${arg} MATCHES "^site=")
string(REGEX REPLACE "^site=" "" arg_site "${arg}")
endif (${arg} MATCHES "^site=")
if (${arg} MATCHES "^include=")
string(REGEX REPLACE "^include=" "" arg_include "${arg}")
endif (${arg} MATCHES "^include=")
if (${arg} MATCHES "^preload=")
string(REGEX REPLACE "^preload=" "" arg_preload "${arg}")
endif (${arg} MATCHES "^preload=")
if (${arg} MATCHES "^preload64=")
string(REGEX REPLACE "^preload64=" "" arg_preload64 "${arg}")
endif (${arg} MATCHES "^preload64=")
if (${arg} STREQUAL "ssh")
set(arg_ssh ON)
endif (${arg} STREQUAL "ssh")
if (${arg} STREQUAL "use_nmake")
set(arg_use_nmake ON)
endif ()
if (${arg} STREQUAL "use_msbuild")
set(arg_use_msbuild ON)
endif ()
if (${arg} STREQUAL "use_make")
set(arg_use_make ON)
endif ()
if (${arg} STREQUAL "use_ninja")
set(arg_use_ninja ON)
endif ()
if (${arg} STREQUAL "verbose")
set(arg_verbose ON)
endif ()
if (${arg} MATCHES "^generator=")
string(REGEX REPLACE "^generator=" "" arg_generator "${arg}")
endif ()
if (${arg} STREQUAL "long")
set(arg_long ON)
endif (${arg} STREQUAL "long")
if (${arg} STREQUAL "already_built")
set(arg_already_built ON)
endif (${arg} STREQUAL "already_built")
if (${arg} MATCHES "^exclude=")
# not parallel to include=. this excludes individual tests.
string(REGEX REPLACE "^exclude=" "" arg_exclude "${arg}")
endif (${arg} MATCHES "^exclude=")
if (${arg} MATCHES "^32_only")
set(arg_32_only ON)
endif ()
if (${arg} MATCHES "^64_only")
set(arg_64_only ON)
endif ()
if (${arg} MATCHES "^build_only")
set(arg_build_only ON)
endif ()
endforeach (arg)
# Returns a list of environment variable names to set in ${env_names}.
# For each "name" in the list, sets a variable "name_env_value" in the caller's
# scope containing the value to be set.
#
# We'd like to export this via utils_exposed.cmake but it is difficult to
# import it here from somewhere else.
# Our manual INCLUDEFILE expansion would require all users to point to a
# generated file somewhere, which requires updating all users including
# Dr. Memory which today points directly at the embedded submodule sources.
# Some of these uses have no build dir where a generated file could live.
# Using include() is difficult for a file that is itself included, because
# cmake won't search our same directory, and CTEST_SCRIPT_DIRECTORY is the
# includer's directory, so we can't easily have side-by-side files.
# For now we keep it here, and have the current only other use in
# tests/CMakeLists.txt include() this file.
function (_DR_set_VS_bitwidth_env_vars is64 env_names)
# Convert env vars to run proper compiler.
# Note that this is fragile and won't work with non-standard
# directory layouts: we assume standard VS or SDK.
# XXX: would be nice to have case-insensitive regex flag!
# For now hardcoding VC, Bin, amd64
set(must_change_path OFF)
if (is64)
list(APPEND names_list "ASM")
set(ASM_env_value "ml64" PARENT_SCOPE)
if (NOT "$ENV{LIB}" MATCHES "[Aa][Mm][Dd]64" AND
NOT "$ENV{LIB}" MATCHES "[Xx]64")
set(must_change_path ON)
# Note that we can't set ENV{PATH} as the output var of the replace:
# it has to be its own set().
#
# VS2017 has bin/HostX{86,64}/x{86,64}/
string(REGEX REPLACE "((^|;)[^;]*)HostX86([/\\\\])x86" "\\1HostX64\\3x64"
newpath "$ENV{PATH}")
# i#1421: VS2013 needs base VC/bin on the path (for cross-compiler
# used by cmake) so we duplicate and put amd64 first. Older VS needs
# Common7/IDE instead which should already be elsewhere on path.
string(REGEX REPLACE "((^|;)[^;]*)VC([/\\\\])([Bb][Ii][Nn])"
"\\1VC\\3\\4\\3amd64;\\1VC\\3\\4"
newpath "${newpath}")
# VS2008's SDKs/Windows/v{6.0A,7.0} uses "x64" instead of "amd64"
string(REGEX REPLACE "([/\\\\]v[^/\\\\]*)([/\\\\])([Bb][Ii][Nn])"
"\\1\\2\\3\\2x64"
newpath "${newpath}")
if (arg_verbose)
message("Env setup: setting PATH to ${newpath}")
endif ()
# VS2017 does not append so we replace first.
string(REGEX REPLACE "([/\\\\])x86" "\\1x64" newlib "$ENV{lib}")
# Now try to support pre-VS2017.
string(REGEX REPLACE "([/\\\\])([Ll][Ii][Bb])([^/\\\\])" "\\1\\2\\1amd64\\3"
newlib "${newlib}")
# VS2008's SDKs/Windows/v{6.0A,7.0} uses "x64" instead of "amd64": grrr
string(REGEX REPLACE
"([/\\\\]v[^/\\\\]*[/\\\\][Ll][Ii][Bb][/\\\\])[Aa][Mm][Dd]64"
"\\1x64"
newlib "${newlib}")
# Win8 SDK uses um/x86 and um/x64 after "Lib/win{8,v6.3}/"
string(REGEX REPLACE
"([Ll][Ii][Bb])[/\\\\]amd64([/\\\\][Ww][Ii][Nn][v0-9.]+[/\\\\]um[/\\\\])x86"
"\\1\\2x64" newlib "${newlib}")
if (arg_verbose)
message("Env setup: setting LIB to ${newlib}")
endif ()
string(REGEX REPLACE "([/\\\\])([Ll][Ii][Bb][/\\\\])[Xx]86" "\\1\\2"
newlibpath "$ENV{LIBPATH}")
string(REGEX REPLACE "([/\\\\])([Ll][Ii][Bb])" "\\1\\2\\1amd64"
newlibpath "${newlibpath}")
if (arg_verbose)
message("Env setup: setting LIBPATH to ${newlibpath}")
endif ()
endif ()
else (is64)
list(APPEND ${env_names} "ASM")
set(ASM_env_value "ml" PARENT_SCOPE)
if ("$ENV{LIB}" MATCHES "[Aa][Mm][Dd]64" OR
"$ENV{LIB}" MATCHES "[Xx]64")
set(must_change_path ON)
# VS2017 has bin/HostX{86,64}/x{86,64}/
string(REGEX REPLACE "((^|;)[^;]*)HostX64([/\\\\])x64" "\\1HostX86\\3x86"
newpath "$ENV{PATH}")
# Remove the duplicate we added (see i#1421 comment above).
string(REGEX REPLACE "((^|;)[^;]*)VC[/\\\\][Bb][Ii][Nn][/\\\\][Aa][Mm][Dd]64"
"" newpath "${newpath}")
if (arg_verbose)
message("Env setup: setting PATH to ${newpath}")
endif ()
string(REGEX REPLACE "([Ll][Ii][Bb])[/\\\\][Aa][Mm][Dd]64" "\\1"
newlib "$ENV{LIB}")
string(REGEX REPLACE "([Ll][Ii][Bb][/\\\\])[Xx]64" "\\1x86"
newlib "${newlib}")
# Win8 SDK uses um/x86 and um/x64
string(REGEX REPLACE "([/\\\\]um[/\\\\])x64" "\\1x86" newlib "${newlib}")
string(REGEX REPLACE "([/\\\\]ucrt[/\\\\])x64" "\\1x86" newlib "${newlib}")
if (arg_verbose)
message("Env setup: setting LIB to ${newlib}")
endif ()
string(REGEX REPLACE "([Ll][Ii][Bb])[/\\\\][Aa][Mm][Dd]64" "\\1"
newlibpath "$ENV{LIBPATH}")
string(REGEX REPLACE "([Ll][Ii][Bb][/\\\\])[Xx]64" "\\1x86"
newlibpath "${newlibpath}")
if (arg_verbose)
message("Env setup: setting LIBPATH to ${newlibpath}")
endif ()
endif ()
endif (is64)
if (must_change_path)
list(APPEND names_list "PATH")
set(PATH_env_value "${newpath}" PARENT_SCOPE)
list(APPEND names_list "LIB")
set(LIB_env_value "${newlib}" PARENT_SCOPE)
list(APPEND names_list "LIBPATH")
set(LIBPATH_env_value "${newlibpath}" PARENT_SCOPE)
endif ()
set(${env_names} ${names_list} PARENT_SCOPE)
endfunction ()
# allow setting the base cache variables via an include file
set(base_cache "")
if (arg_include)
message("including ${arg_include}")
include(${arg_include})
endif (arg_include)
if (arg_ssh)
# avoid problems creating pdbs as cygwin ssh user (i#310)
set(base_cache "${base_cache}
GENERATE_PDBS:BOOL=OFF")
endif (arg_ssh)
# Make it clear that single-bitwidth packages only contain that bitwidth
# (and provide unique names for CI deployment).
if (NOT "${base_cache}" MATCHES "PACKAGE_PLATFORM")
if (arg_64_only)
set(base_cache "${base_cache}
PACKAGE_PLATFORM:STRING=x86_64-")
elseif (arg_32_only)
set(base_cache "${base_cache}
PACKAGE_PLATFORM:STRING=i386-")
endif ()
endif ()
if (arg_use_make)
find_program(MAKE_COMMAND make DOC "make command")
if (NOT MAKE_COMMAND)
message(FATAL_ERROR "make requested but make not found")
endif (NOT MAKE_COMMAND)
endif (arg_use_make)
if (arg_use_ninja)
find_program(NINJA_COMMAND ninja DOC "ninja command")
if (NOT NINJA_COMMAND)
message(FATAL_ERROR "ninja requested but ninja not found")
endif (NOT NINJA_COMMAND)
endif (arg_use_ninja)
if (arg_long)
set(TEST_LONG ON)
else (arg_long)
set(TEST_LONG OFF)
endif (arg_long)
if (WIN32)
find_program(CYGPATH cygpath)
if (CYGPATH)
set(have_cygwin ON)
else (CYGPATH)
set(have_cygwin OFF)
endif (CYGPATH)
endif (WIN32)
get_filename_component(BINARY_BASE "." ABSOLUTE)
if (arg_nightly)
# i#11: nightly run
# Caller should have set CTEST_SITE via site= arg
if (arg_site)
set(CTEST_SITE "${arg_site}")
else (arg_site)
message(FATAL_ERROR "must set sitename via site= arg")
endif (arg_site)
set(CTEST_DASHBOARD_ROOT "${BINARY_BASE}")
# We assume a manual check out was done, and that CTest can just do "update".
# If we want a fresh checkout we can set CTEST_BACKUP_AND_RESTORE
# and CTEST_CHECKOUT_COMMAND but the update should be fine.
find_program(CTEST_UPDATE_COMMAND git DOC "source code update command")
set(SUITE_TYPE Nightly)
set(DO_UPDATE ON)
set(DO_SUBMIT ON)
set(SUBMIT_LOCAL OFF)
else (arg_nightly)
# a local run, not a nightly
set(SUITE_TYPE Experimental)
set(DO_UPDATE OFF)
set(DO_SUBMIT ON)
set(SUBMIT_LOCAL ON)
# CTest does "scp file ${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}" so for
# local copy w/o needing sshd on localhost we arrange to have : in the
# absolute filepath. Note that I would prefer having the results inside
# each build dir, but having : in the build dir name complicates
# LD_LIBRARY_PATH.
if (WIN32)
# Colon not allowed in name so use drive
string(REGEX MATCHALL "^[A-Za-z]" drive "${BINARY_BASE}")
string(REGEX REPLACE "^[A-Za-z]:" "" nondrive "${BINARY_BASE}")
set(CTEST_DROP_SITE "${drive}")
set(CTEST_DROP_LOCATION "${nondrive}/xmlresults")
set(RESULTS_DIR "${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}")
else (WIN32)
set(CTEST_DROP_SITE "${BINARY_BASE}/xml")
set(CTEST_DROP_LOCATION "results")
set(RESULTS_DIR "${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}")
endif (WIN32)
if (EXISTS "${RESULTS_DIR}")
file(REMOVE_RECURSE "${RESULTS_DIR}")
endif (EXISTS "${RESULTS_DIR}")
file(MAKE_DIRECTORY "${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}")
endif (arg_nightly)
# Find the number of CPUs on the current system.
# Cribbed from http://www.kitware.com/blog/home/post/63
if(NOT DEFINED PROCESSOR_COUNT)
# Unknown:
set(PROCESSOR_COUNT 4) # Guess
# Linux:
set(cpuinfo_file "/proc/cpuinfo")
if(EXISTS "${cpuinfo_file}")
file(STRINGS "${cpuinfo_file}" procs REGEX "^processor.: [0-9]+$")
list(LENGTH procs PROCESSOR_COUNT)
endif()
# Mac:
if(APPLE)
find_program(cmd_sys_pro "system_profiler")
if(cmd_sys_pro)
execute_process(COMMAND ${cmd_sys_pro} SPHardwareDataType OUTPUT_VARIABLE info)
string(REGEX REPLACE "^.*Total Number [Oo]f Cores: ([0-9]+).*$" "\\1"
PROCESSOR_COUNT "${info}")
endif()
endif()
# Windows:
if(WIN32)
if ($ENV{NUMBER_OF_PROCESSORS})
set(PROCESSOR_COUNT "$ENV{NUMBER_OF_PROCESSORS}")
endif ()
endif()
endif()
math(EXPR PARALLEL_COUNT_BUILD "${PROCESSOR_COUNT} + 2")
# Typically no benefit and sometimes detrimental to exceed core count here
math(EXPR PARALLEL_COUNT_TEST "${PROCESSOR_COUNT}")
# CTest goes and does our builds and then wants to configure
# and build again and complains there's no top-level setting of
# CTEST_BINARY_DIRECTORY:
# "CMake Error: Some required settings in the configuration file were missing:"
# but we don't want to do another build so we just ignore the error.
set(CTEST_CMAKE_COMMAND "${CMAKE_EXECUTABLE_NAME}")
# outer file should set CTEST_PROJECT_NAME
set(CTEST_COMMAND "${CTEST_EXECUTABLE_NAME}")
# Raise the default of 50 to avoid warnings blocking the detection of
# build failures (i#1137):
set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS 200)
set(CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS 200)
# Detect if the arch is x86
if (NOT DEFINED ARCH_IS_X86)
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm|aarch64)")
set(ARCH_IS_X86 OFF)
else ()
set(ARCH_IS_X86 ON)
endif ()
endif ()
# Detect if the kernel is ia32 or x64. If the kernel is ia32, there's no sense
# in trying to run any x64 code. On Windows, the x64 toolchain is built as x64
# code, so we can't even build. On Linux, it's possible to have an ia32
# toolchain that targets x64, but we don't currently support it.
if (NOT DEFINED KERNEL_IS_X64) # Allow variable override.
if (WIN32)
# Check both PROCESSOR_ARCHITECTURE and PROCESSOR_ARCHITEW6432 in case CMake
# was built x64.
if ("$ENV{PROCESSOR_ARCHITECTURE}" MATCHES "AMD64" OR
"$ENV{PROCESSOR_ARCHITEW6432}" MATCHES "AMD64")
set(KERNEL_IS_X64 ON)
else ()
set(KERNEL_IS_X64 OFF)
endif ()
else ()
# uname -m is what the kernel supports.
execute_process(COMMAND uname -m
OUTPUT_VARIABLE machine
RESULT_VARIABLE cmd_result)
# If for some reason uname fails (not on PATH), assume the kernel is x64
# anyway.
if (cmd_result OR "${machine}" MATCHES "x86_64|aarch64|arm64")
set(KERNEL_IS_X64 ON)
else ()
set(KERNEL_IS_X64 OFF)
endif ()
endif ()
endif ()
if (NOT KERNEL_IS_X64)
message("WARNING: Kernel is not x64, skipping x64 builds")
endif ()
if (arg_use_ninja)
set(CTEST_CMAKE_GENERATOR "Ninja")
elseif (arg_use_make)
set(CTEST_CMAKE_GENERATOR "Unix Makefiles")
find_program(MAKE_COMMAND make DOC "make command")
if (have_cygwin)
# seeing errors building in parallel: pdb collision?
# can't repro w/ VERBOSE=1
set(CTEST_BUILD_COMMAND_BASE "${MAKE_COMMAND} -j2")
else (have_cygwin)
set(CTEST_BUILD_COMMAND_BASE "${MAKE_COMMAND} -j${PARALLEL_COUNT_BUILD}")
endif (have_cygwin)
elseif (arg_use_nmake)
set(CTEST_CMAKE_GENERATOR "NMake Makefiles")
else ()
if (arg_generator)
set(vs_generator ${arg_generator})
else ()
set(vs_generator "NOTFOUND")
get_filename_component(current_directory_path "${CMAKE_CURRENT_LIST_FILE}" PATH)
include(${current_directory_path}/lookup_visualstudio.cmake)
get_visualstudio_info(vs_dir vs_version vs_generator)
if (NOT vs_generator)
message(FATAL_ERROR "Cannot determine Visual Studio version")
endif ()
endif ()
message(STATUS "Using ${vs_generator} generators")
if (arg_use_msbuild)
find_program(MSBUILD_PROGRAM msbuild)
if (MSBUILD_PROGRAM)
set(base_cache "${base_cache}
CMAKE_MAKE_PROGRAM:FILEPATH=${MSBUILD_PROGRAM}")
# Unfortunately we have to provide all the args (setting CMAKE_MAKE_PROGRAM
# doesn't do it for ctest builds). We want ALL_BUILD.vcproj for pre-VS2010
# and ALL_BUILD.vcxproj for VS2010.
if (vs_generator MATCHES "Visual Studio 1.")
set(proj_file "ALL_BUILD.vcxproj")
else ()
set(proj_file "ALL_BUILD.vcproj")
endif ()
# Request parallel build on all available cores (sequential by default: i#800)
# via "/m".
# Configuration will be adjusted per build below.
set(CTEST_BUILD_COMMAND
"${MSBUILD_PROGRAM} ${proj_file} /p:Configuration=REPLACE_CONFIG /m")
else (MSBUILD_PROGRAM)
message("WARNING: cannot find msbuild; disabling")
set(arg_use_msbuild OFF)
endif (MSBUILD_PROGRAM)
endif (arg_use_msbuild)
endif ()
function(get_default_config config builddir)
file(READ "${builddir}/CMakeCache.txt" cache)
string(REGEX MATCH "CMAKE_CONFIGURATION_TYPES:STRING=([^\n]*)" cache "${cache}")
string(REGEX REPLACE "CMAKE_CONFIGURATION_TYPES:STRING=([^;]*)" "\\1"
cache "${cache}")
set(${config} ${cache} PARENT_SCOPE)
endfunction(get_default_config)
# Sets two vars in PARENT_SCOPE:
# + returns the build dir in "last_build_dir"
# + for each build for which add_to_package is true:
# - returns the build dir in "last_package_build_dir"
# - adds to "cpack_projects" for project "${cpack_project_name}"
# (set by outer file)
function(testbuild_ex name is64 initial_cache test_only_in_long
add_to_package build_args)
set(CTEST_BUILD_NAME "${name}")
# Skip x64 builds on a true ia32 machine.
if (is64 AND NOT KERNEL_IS_X64)
return()
endif ()
if (is64 AND arg_32_only)
return()
endif ()
if (NOT is64 AND arg_64_only)
return()
endif ()
# Skip 32-bit builds on an AArch64 machine.
if (NOT is64 AND CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64")
return()
endif ()
if (NOT arg_use_nmake AND NOT arg_use_make AND NOT arg_use_ninja)
# we need a separate generator for 64-bit as well as the PATH
# env var changes below (since we run cl directly)
if (is64)
set(CTEST_CMAKE_GENERATOR "${vs_generator} Win64")
else (is64)
set(CTEST_CMAKE_GENERATOR "${vs_generator}")
endif (is64)
# we need to set this for the package build using the last build
set(CTEST_CMAKE_GENERATOR "${CTEST_CMAKE_GENERATOR}" PARENT_SCOPE)
endif ()
set(CTEST_BINARY_DIRECTORY "${BINARY_BASE}/build_${CTEST_BUILD_NAME}")
set(last_build_dir "${CTEST_BINARY_DIRECTORY}" PARENT_SCOPE)
if (NOT arg_already_built)
# Support other VC installations than VS2005 via pre-build include file.
# Preserve path so include file can simply prepend each time.
set(pre_path "$ENV{PATH}")
set(pre_lib "$ENV{LIB}")
if (is64)
set(preload_file "${arg_preload64}")
else (is64)
set(preload_file "${arg_preload}")
endif (is64)
if (preload_file)
# Command-style CTest (i.e., using ctest_configure(), etc.) does
# not support giving args to CTEST_CMAKE_COMMAND so we are forced
# to do an include() instead of -C
include("${preload_file}")
endif (preload_file)
if (WIN32)
# i#111: Disabling progress and status messages can speed the Windows build
# up by up to 50%. I filed CMake bug 8726 on this and this variable will be
# in the 2.8 release; going ahead and setting now.
# For Linux these messages make little perf difference, and can help
# diagnose errors or watch progress.
# The messages only apply to Makefile generators, not Visual Studio.
if (NOT "${CTEST_CMAKE_GENERATOR}" MATCHES "Visual Studio")
set(os_specific_defines "CMAKE_RULE_MESSAGES:BOOL=OFF")
endif ()
else (WIN32)
set(os_specific_defines "")
endif (WIN32)
set(CTEST_INITIAL_CACHE "${initial_cache}
TEST_SUITE:BOOL=ON
${os_specific_defines}
${base_cache}
")
ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY})
file(WRITE "${CTEST_BINARY_DIRECTORY}/CMakeCache.txt" "${CTEST_INITIAL_CACHE}")
if (WIN32)
# If other compilers also on path ensure we pick cl
set(ENV{CC} "cl")
set(ENV{CXX} "cl")
# Convert env vars to run proper compiler.
_DR_set_VS_bitwidth_env_vars(${is64} env_names)
foreach (env ${env_names})
set(ENV{${env}} "${${env}_env_value}")
endforeach ()
else (WIN32)
if (ARCH_IS_X86)
if (is64)
set(ENV{CFLAGS} "-m64")
set(ENV{CXXFLAGS} "-m64")
else (is64)
set(ENV{CFLAGS} "-m32")
set(ENV{CXXFLAGS} "-m32")
endif (is64)
endif (ARCH_IS_X86)
endif (WIN32)
else (NOT arg_already_built)
# remove the Last* files from the prior run
file(GLOB lastrun ${CTEST_BINARY_DIRECTORY}/Testing/Temporary/Last*)
if (lastrun)
file(REMOVE ${lastrun})
endif (lastrun)
endif (NOT arg_already_built)
ctest_start(${SUITE_TYPE})
if (NOT arg_already_built)
if (DO_UPDATE)
ctest_update(SOURCE "${CTEST_SOURCE_DIRECTORY}")
endif (DO_UPDATE)
ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE config_success)
if (config_success EQUAL 0)
# support "make install"
if (DEFINED CTEST_BUILD_COMMAND_BASE)
set(CTEST_BUILD_COMMAND "${CTEST_BUILD_COMMAND_BASE} ${build_args}")
else () # else use default
if ("${CTEST_CMAKE_GENERATOR}" MATCHES "Visual Studio")
# workaround for cmake bug #11830 where assumes "Debug" is
# the default config
get_default_config(defconfig "${CTEST_BINARY_DIRECTORY}")
set(CTEST_BUILD_CONFIGURATION "${defconfig}")
message("building default config \"${defconfig}\"")
if (NOT "${build_args}" STREQUAL "" OR
NOT "${extra_build_args}" STREQUAL "")
set(CTEST_BUILD_FLAGS "-- ${extra_build_args} ${build_args}")
endif ()
if (arg_use_msbuild)
string(REPLACE "REPLACE_CONFIG" "${defconfig}" CTEST_BUILD_COMMAND
"${CTEST_BUILD_COMMAND}")
endif (arg_use_msbuild)
else ()
set(CTEST_BUILD_FLAGS "${build_args}")
endif ()
message("building with args \"${CTEST_BUILD_FLAGS}\"")
endif ()
ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE build_success)
else (config_success EQUAL 0)
set(build_success -1)
if (optional_cross_compile)
# XXX: for platforms requiring special hardware such as ARM, this global indicates
# an optional cross-compilation, for use on more common platforms like x86 Unix
# (would use a parameter instead of a global, except for backward compatibility)
file(GLOB last_config ${CTEST_BINARY_DIRECTORY}/Testing/*/*.xml)
if (last_config)
file(REMOVE ${last_config})
endif (last_config)
set(DO_SUBMIT OFF)
message("Warning: optional cross-compilation \"${name}\" is not available"
"--skipping")
set(add_to_package OFF)
file(WRITE ${CTEST_BINARY_DIRECTORY}/Testing/missing-cross-compile "${name}")
endif (optional_cross_compile)
endif (config_success EQUAL 0)
else (NOT arg_already_built)
set(build_success 0)
endif (NOT arg_already_built)
if (build_success EQUAL 0 AND run_tests AND NOT arg_build_only)
if (NOT test_only_in_long OR ${TEST_LONG})
# to run a subset of tests add an INCLUDE regexp to ctest_test. e.g.:
# INCLUDE broadfun
if (NOT "${arg_exclude}" STREQUAL "")
set(ctest_test_args ${ctest_test_args} EXCLUDE ${arg_exclude})
endif (NOT "${arg_exclude}" STREQUAL "")
set(ctest_test_args ${ctest_test_args} ${extra_ctest_args})
if ("${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.17")
# CMake 3.17 supports retrying failed tests. We avoid flaky tests on
# particular platforms failing the whole suite by trying multiple times.
set(ctest_test_args ${ctest_test_args} "REPEAT" "UNTIL_PASS:3")
endif ()
if (WIN32 AND TEST_LONG)
# FIXME i#265: on Windows we can't run multiple instances of
# the same app b/c of global reg key conflicts: should support
# env vars and not require registry
set(RUN_PARALLEL OFF)
else ()
set(RUN_PARALLEL ON)
endif ()
if (RUN_PARALLEL)
# i#111: run tests in parallel, supported on CTest 2.8.0+
# Note that adding -j to CMAKE_COMMAND does not work, though invoking
# this script with -j does work, but we want parallel by default.
ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}"
PARALLEL_LEVEL ${PARALLEL_COUNT_TEST} ${ctest_test_args})
else (RUN_PARALLEL)
ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}" ${ctest_test_args})
endif (RUN_PARALLEL)
endif (NOT test_only_in_long OR ${TEST_LONG})
endif (build_success EQUAL 0 AND run_tests AND NOT arg_build_only)
if (DO_SUBMIT)
if (CTEST_DROP_METHOD MATCHES "http")
# include any notes via set(CTEST_NOTES_FILES )?
ctest_submit()
else ()
# We used to use the "scp" (could also have used "cp") drop method
# to copy these xml files out for us, but cmake 3.14 dropped that.
# Thus we copy them ourselves.
file(GLOB xml_files "${CTEST_BINARY_DIRECTORY}/Testing/*/*.xml")
set(prefix "___${CTEST_BUILD_NAME}___${SUITE_TYPE}___XML___")
foreach (xml ${xml_files})
get_filename_component(base "${xml}" NAME)
# Avoid confusion with a later package build in the same dir by
# renaming instead of copying.
file(RENAME "${xml}"
"${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}/${prefix}${base}")
message("Moving ${xml} to "
"${CTEST_DROP_SITE}:${CTEST_DROP_LOCATION}/${prefix}${base}")
endforeach ()
endif ()
endif (DO_SUBMIT)
if (NOT arg_already_built)
set(ENV{PATH} "${pre_path}")
set(ENV{LIB} "${pre_lib}")
endif (NOT arg_already_built)
if (add_to_package)
# support having the suite test building the full package
# FIXME: perhaps should replace package.cmake w/ invocation of runsuite.cmake
# w/ certain params, since they're pretty similar at this point?
# communicate w/ caller
set(last_package_build_dir "${CTEST_BINARY_DIRECTORY}" PARENT_SCOPE)
if (CTEST_BINARY_DIRECTORY MATCHES "debug")
# prepend rather than append to get debug first, so we take release
# files preferentially in case of overlap
set(cpack_projects
"\"${CTEST_BINARY_DIRECTORY};${cpack_project_name};ALL;/\"\n ${cpack_projects}"
PARENT_SCOPE)
else ()
set(cpack_projects
"${cpack_projects}\n \"${CTEST_BINARY_DIRECTORY};${cpack_project_name};ALL;/\""
PARENT_SCOPE)
endif ()
if ("${CTEST_CMAKE_GENERATOR}" MATCHES "Visual Studio")
# i#390: workaround for cpack limitation where cpack is run w/
# one config and each build's install rules check only for their
# own config. we change each config check to "TRUE OR <check>".
file(READ "${CTEST_BINARY_DIRECTORY}/cmake_install.cmake" str)
# grab first-level includes
string(REGEX MATCHALL "INCLUDE\\\(\"[^\"]+\"" includes "${str}")
string(REGEX REPLACE "INCLUDE\\\(\"([^\"]+)\"" "\\1" includes "${includes}")
# grab second-level includes
set(includes2nd )
foreach (config ${includes})
file(READ "${config}" str)
string(REGEX MATCHALL "INCLUDE\\\(\"[^\"]+\"" newincs "${str}")
string(REGEX REPLACE "INCLUDE\\\(\"([^\"]+)\"" "\\1" newincs "${newincs}")
set(includes2nd ${includes2nd} ${newincs})
endforeach (config)
# now process each
foreach (config "${CTEST_BINARY_DIRECTORY}/cmake_install.cmake"
${includes} ${includes2nd})
file(READ "${config}" str)
string(REGEX REPLACE "IF\\\((\"\\\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES)"
"IF(TRUE OR \\1" str "${str}")
# set CMP0012 policy to treat TRUE as literal
file(WRITE "${config}" "cmake_policy(VERSION 2.8)\n${str}")
endforeach (config)
endif ()
endif (add_to_package)
endfunction(testbuild_ex)
function(testbuild name is64 initial_cache)
# by default run all tests and do not include in package
testbuild_ex(${name} ${is64} ${initial_cache} OFF OFF "")
# propagate
set(last_build_dir "${last_build_dir}" PARENT_SCOPE)
set(last_package_build_dir "${last_package_build_dir}" PARENT_SCOPE)
set(cpack_projects "${cpack_projects}" PARENT_SCOPE)
endfunction(testbuild)