lib
/
EXODUS
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Cloned SEACAS for EXODUS library with extra build files for internal package management.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
19 MiB
 
 
 
 
 
 
Tag: Branch: Tree: ec572c6da6
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ec572c6da6'
${ noResults }
EXODUS/cmake/tribits/core/package_arch/TribitsAddTestHelpers.cmake

933 lines
28 KiB
Raw Blame History

# @HEADER
# ************************************************************************
#
# TriBITS: Tribal Build, Integrate, and Test System
# Copyright 2013 Sandia Corporation
#
# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
# the U.S. Government retains certain rights in this software.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#
# 2. 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.
#
# 3. Neither the name of the Corporation nor the names of the
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
# 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.
#
# ************************************************************************
# @HEADER
include(TribitsAddExecutableTestHelpers)
include(TribitsGeneralMacros)
include(TribitsTestCategories)
include(CMakeParseArguments)
include(GlobalSet)
include(AppendGlobalSet)
include(AppendStringVarWithSep)
include(PrintVar)
include(AdvancedSet)
include(MessageWrapper)
include(TribitsGetCategoriesString)
# Do initialization for test helpers
#
# This must be run just before the packages define their tests and this macro
# must be run in the base-level project scope.
#
macro(tribits_add_test_helpers_init)
if (TPL_ENABLE_CUDA)
set(TRIBITS_TEST_EXTRA_ENVIRONMENT CTEST_KOKKOS_DEVICE_TYPE=gpus)
set(TRIBITS_RESOURCES_PER_PROCESS gpus:1)
endif()
endmacro()
# Wrapper function for set_tests_properties() to be used in unit testing.
#
function(tribits_set_tests_properties)
cmake_parse_arguments(PARSE_ARGV 0 FWD "" "" "")
if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
set_tests_properties(${FWD_UNPARSED_ARGUMENTS})
endif()
if (TRIBITS_SET_TEST_PROPERTIES_CAPTURE_INPUT)
append_global_set(TRIBITS_SET_TEST_PROPERTIES_INPUT ${FWD_UNPARSED_ARGUMENTS})
endif()
endfunction()
# Wrapper function for set_property(TEST ...) to be used in unit testing
#
function(tribits_set_test_property)
cmake_parse_arguments(PARSE_ARGV 0 FWD "" "" "")
if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
set_property(TEST ${FWD_UNPARSED_ARGUMENTS})
endif()
if (TRIBITS_SET_TEST_PROPERTIES_CAPTURE_INPUT)
append_global_set(TRIBITS_SET_TEST_PROPERTIES_INPUT ${FWD_UNPARSED_ARGUMENTS})
endif()
endfunction()
# Scale a timeout by ${PROJECT_NAME}_SCALE_TEST_TIMEOUT
#
# This function will truncate input TIMEOUT_IN but will allow for a simple
# fractional scale factor. It will also truncate the scale factor to just one
# decimal place. CMake math(EXPR ...) does not support floating point so I
# have to use just manual integer arithmetic.
#
function(tribits_scale_timeout TIMEOUT_IN SCALED_TIMEOUT_OUT)
if (${PROJECT_NAME}_SCALE_TEST_TIMEOUT
AND NOT "${${PROJECT_NAME}_SCALE_TEST_TIMEOUT}" EQUAL "1.0"
)
# Strip of any fractional part of the timeout
split("${TIMEOUT_IN}" "[.]" TIMEOUT_IN_ARRAY)
#print_var(TIMEOUT_IN_ARRAY)
list(GET TIMEOUT_IN_ARRAY 0 TIMEOUT_IN_TRUNCATED)
#print_var(TIMEOUT_IN_TRUNCATED)
# Split the factional part of the scaling factor into SCALE_TEST_INT and
# SCALE_TEST_INT_FRAC and do the math ourself with integer floating pint
split("${${PROJECT_NAME}_SCALE_TEST_TIMEOUT}" "[.]" SCALE_TEST_ARRAY)
list(LENGTH SCALE_TEST_ARRAY SCALE_TEST_ARRAY_LEN)
#print_var(SCALE_TEST_ARRAY_LEN)
list(GET SCALE_TEST_ARRAY 0 SCALE_TEST_INT)
#print_var(SCALE_TEST_INT)
math(EXPR TIMEOUT_USED
"${TIMEOUT_IN_TRUNCATED} * ${SCALE_TEST_INT}")
#print_var(TIMEOUT_USED)
if ("${SCALE_TEST_ARRAY_LEN}" GREATER 1)
# Handle the factional part (only take the first digit)
list(GET SCALE_TEST_ARRAY 1 SCALE_TEST_INT_FRAC_FULL) # Could be more than 1 digit
#print_var(SCALE_TEST_INT_FRAC_FULL)
string(SUBSTRING "${SCALE_TEST_INT_FRAC_FULL}" 0 1 SCALE_TEST_INT_FRAC)
#print_var(SCALE_TEST_INT_FRAC)
math(EXPR TIMEOUT_USED
"${TIMEOUT_USED} + (${SCALE_TEST_INT_FRAC} * ${TIMEOUT_IN_TRUNCATED}) / 10")
#print_var(TIMEOUT_USED)
endif()
else()
set(TIMEOUT_USED "${TIMEOUT_IN}")
endif()
set(${SCALED_TIMEOUT_OUT} ${TIMEOUT_USED} PARENT_SCOPE)
endfunction()
# Function that converts a complete string of command-line arguments
# into a form that add_test(...) can correctly deal with.
#
# The main thing this function does is to replace spaces ' ' with
# array separators ';' since this is how add_test(...) expects to deal
# with command-line arguments, as array arguments. However, this
# function will not do a replacement of ' ' with ';' if a quote is
# active. This allows you to pass in quoted arguments and have them
# treated as a single argument.
#
function(tribits_convert_cmnd_arg_string_to_add_test_arg_array CMND_ARG_STRING ARG_ARRAY_VARNAME)
#message("TRIBITS_CONVERT_CMND_ARG_STRING_TO_ADD_TEST_ARG_ARRAY")
#print_var(CMND_ARG_STRING)
#print_var(ARG_ARRAY_VARNAME)
string(LENGTH ${CMND_ARG_STRING} STR_LEN)
#print_var(STR_LEN)
math(EXPR STR_LAST_IDX "${STR_LEN}-1")
set(NEWSTR)
set(ACTIVE_QUOTE OFF)
foreach(IDX RANGE ${STR_LAST_IDX})
string(SUBSTRING ${CMND_ARG_STRING} ${IDX} 1 STR_CHAR)
#print_var(STR_CHAR)
if (STR_CHAR STREQUAL "\"")
if (NOT ACTIVE_QUOTE)
set(ACTIVE_QUOTE ON)
else()
set(ACTIVE_QUOTE OFF)
endif()
#print_var(ACTIVE_QUOTE)
endif()
if (NOT STR_CHAR STREQUAL " ")
set(NEWSTR "${NEWSTR}${STR_CHAR}")
else()
if (ACTIVE_QUOTE)
set(NEWSTR "${NEWSTR}${STR_CHAR}")
else()
set(NEWSTR "${NEWSTR};")
endif()
endif()
endforeach()
#print_var(NEWSTR)
set(${ARG_ARRAY_VARNAME} ${NEWSTR} PARENT_SCOPE)
endfunction()
# Determine if to add the test based on if testing is enabled for the current
# package.
#
function(tribits_add_test_process_enable_tests ADD_THE_TEST_OUT)
if(${PACKAGE_NAME}_ENABLE_TESTS)
set(ADD_THE_TEST TRUE)
else()
message_wrapper(
"-- ${TEST_NAME}: NOT added test because"
" ${PACKAGE_NAME}_ENABLE_TESTS='${${PACKAGE_NAME}_ENABLE_TESTS}'.")
set(ADD_THE_TEST FALSE)
endif()
set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
endfunction()
# Determine if to add the test or not based on [X]HOST and [X]HOSTTYPE arguments
#
# Warning: Arguments for [X]HOST and [X]HOSTTYPE arguments are passed in
# implicitly due to scoping of CMake.
#
function(tribits_add_test_process_host_hosttype ADD_THE_TEST_OUT)
if ("${${PROJECT_NAME}_HOSTNAME}" STREQUAL "")
set(${PROJECT_NAME}_HOSTNAME dummy_host)
endif()
set(ADD_THE_TEST TRUE)
if (ADD_THE_TEST)
if (NOT PARSE_HOST)
set (PARSE_HOST ${${PROJECT_NAME}_HOSTNAME})
endif()
LIST (FIND PARSE_HOST ${${PROJECT_NAME}_HOSTNAME} INDEX_OF_HOSTNAME_IN_HOST_LIST)
if (${INDEX_OF_HOSTNAME_IN_HOST_LIST} EQUAL -1)
set(ADD_THE_TEST FALSE)
set(HOST_MATCH_MSG
"-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_HOSTNAME='${${PROJECT_NAME}_HOSTNAME}' does not match list HOST='${PARSE_HOST}'!"
)
endif()
endif()
if (ADD_THE_TEST)
if (NOT PARSE_XHOST)
set (PARSE_XHOST NONE)
endif()
LIST (FIND PARSE_XHOST ${${PROJECT_NAME}_HOSTNAME} INDEX_OF_HOSTNAME_IN_XHOST_LIST)
if (NOT ${INDEX_OF_HOSTNAME_IN_XHOST_LIST} EQUAL -1)
set(ADD_THE_TEST FALSE)
set(HOST_MATCH_MSG
"-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_HOSTNAME='${${PROJECT_NAME}_HOSTNAME}' matches list XHOST='${PARSE_XHOST}'!"
)
endif()
endif()
if (ADD_THE_TEST)
if (NOT PARSE_HOSTTYPE)
set(PARSE_HOSTTYPE ${CMAKE_HOST_SYSTEM_NAME})
endif()
LIST (FIND PARSE_HOSTTYPE ${CMAKE_HOST_SYSTEM_NAME} INDEX_OF_HOSTSYSTEMNAME_IN_HOSTTYPE_LIST)
if (${INDEX_OF_HOSTSYSTEMNAME_IN_HOSTTYPE_LIST} EQUAL -1)
set(ADD_THE_TEST FALSE)
set(HOST_MATCH_MSG
"-- ${TEST_NAME}: NOT added test because CMAKE_HOST_SYSTEM_NAME='${CMAKE_HOST_SYSTEM_NAME}' does not match list HOSTTYPE='${PARSE_HOSTTYPE}'!"
)
endif()
endif()
if (ADD_THE_TEST)
if (NOT PARSE_XHOSTTYPE)
set(PARSE_XHOSTTYPE NONE)
endif()
LIST (FIND PARSE_XHOSTTYPE ${CMAKE_HOST_SYSTEM_NAME} INDEX_OF_HOSTSYSTEMNAME_IN_XHOSTTYPE_LIST)
if (NOT ${INDEX_OF_HOSTSYSTEMNAME_IN_XHOSTTYPE_LIST} EQUAL -1)
set(ADD_THE_TEST FALSE)
set(HOST_MATCH_MSG
"-- ${TEST_NAME}: NOT added test because CMAKE_HOST_SYSTEM_NAME='${CMAKE_HOST_SYSTEM_NAME}' matches list XHOSTTYPE='${PARSE_XHOSTTYPE}'!"
)
endif()
endif()
foreach(VAR_NAME ${PARSE_EXCLUDE_IF_NOT_TRUE})
if (ADD_THE_TEST AND NOT ${VAR_NAME})
set(ADD_THE_TEST FALSE)
set(HOST_MATCH_MSG
"-- ${TEST_NAME}: NOT added test because EXCLUDE_IF_NOT_TRUE ${VAR_NAME}='${${VAR_NAME}}'!"
)
endif()
endforeach()
if (HOST_MATCH_MSG AND ${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper("${HOST_MATCH_MSG}")
endif()
set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
endfunction()
# Determine if to add the test or not based on CATEGORIES arguments
#
# Warning: Argument PARSE_CATEGORIES is passed in implicitly due to scoping of
# CMake.
#
function(tribits_add_test_process_categories ADD_THE_TEST_OUT)
tribits_filter_and_assert_categories(PARSE_CATEGORIES)
set(PARSE_CATEGORIES ${PARSE_CATEGORIES} PARENT_SCOPE)
set(ADD_THE_TEST FALSE)
# Set the default test-specific category to basic if it is not set
if (NOT PARSE_CATEGORIES)
set (PARSE_CATEGORIES BASIC)
endif()
#print_var(${PROJECT_NAME}_TEST_CATEGORIES)
#print_var(PARSE_CATEGORIES)
if ("${${PROJECT_NAME}_TEST_CATEGORIES}" STREQUAL "")
# In case this is not a TriBITS project!
set(${PROJECT_NAME}_TEST_CATEGORIES BASIC)
endif()
# Process the test categories
assert_defined(${PROJECT_NAME}_TEST_CATEGORIES)
foreach(CATEGORY_USR_SET ${${PROJECT_NAME}_TEST_CATEGORIES})
#print_var(CATEGORY_USR_SET)
#print_var(PARSE_CATEGORIES)
foreach(CATEGORY ${PARSE_CATEGORIES})
if (CATEGORY STREQUAL ${CATEGORY_USR_SET})
# Exact match for the category, add the test
set(ADD_THE_TEST TRUE)
elseif(CATEGORY STREQUAL "BASIC")
if (CATEGORY_USR_SET STREQUAL "CONTINUOUS" OR CATEGORY_USR_SET STREQUAL "NIGHTLY"
OR CATEGORY_USR_SET STREQUAL "HEAVY"
)
set(ADD_THE_TEST TRUE)
endif()
elseif(CATEGORY STREQUAL "CONTINUOUS")
if (CATEGORY_USR_SET STREQUAL "NIGHTLY" OR CATEGORY_USR_SET STREQUAL "HEAVY")
set(ADD_THE_TEST TRUE)
endif()
elseif(CATEGORY STREQUAL "NIGHTLY")
if (CATEGORY_USR_SET STREQUAL "HEAVY")
set(ADD_THE_TEST TRUE)
endif()
else()
# No matches for the category, don't add the test
endif()
endforeach()
endforeach()
#print_var(TEST_NAME)
#print_var(ADD_THE_TEST)
#print_var(${PROJECT_NAME}_TRACE_ADD_TEST)
if (TEST_NAME AND NOT ADD_THE_TEST AND ${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper(
"-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_TEST_CATEGORIES='${${PROJECT_NAME}_TEST_CATEGORIES}' does not match this test's CATEGORIES='${PARSE_CATEGORIES}'!"
)
endif()
set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
#print_var(${ADD_THE_TEST_OUT})
endfunction()
# FUNCTION: tribits_add_test_get_exe_binary_name()
#
# Get the full name of a package executable given its root name and other
# arguments.
#
# Usage:
#
# tribits_add_test_get_exe_binary_name(
# <execRootName>
# NOEXEPREFIX_IN
# NOEXESUFFIX_IN
# ADD_DIR_TO_NAME
# EXE_BINARY_NAME_OUT
# )
#
# By default, the full name of the executable is assumed to be::
#
# ${PACKAGE_NAME}_<execName>${${PROJECT_NAME}_CMAKE_EXECUTABLE_SUFFIX}
#
function(tribits_add_test_get_exe_binary_name EXE_NAME_IN
NOEXEPREFIX_IN NOEXESUFFIX_IN ADD_DIR_TO_NAME EXE_BINARY_NAME_OUT
)
set(EXE_BINARY_NAME "${EXE_NAME_IN}")
if(PARSE_ADD_DIR_TO_NAME)
set(DIRECTORY_NAME "")
tribits_create_name_from_current_source_directory(DIRECTORY_NAME)
set(EXE_BINARY_NAME "${DIRECTORY_NAME}_${EXE_BINARY_NAME}")
endif()
if (NOEXESUFFIX_IN)
set(EXECUTABLE_SUFFIX "")
else()
set(EXECUTABLE_SUFFIX ${${PROJECT_NAME}_CMAKE_EXECUTABLE_SUFFIX})
endif()
set(EXE_BINARY_NAME "${EXE_BINARY_NAME}${EXECUTABLE_SUFFIX}")
if(PACKAGE_NAME AND NOT NOEXEPREFIX_IN)
set(EXE_BINARY_NAME ${PACKAGE_NAME}_${EXE_BINARY_NAME})
endif()
set(${EXE_BINARY_NAME_OUT} ${EXE_BINARY_NAME} PARENT_SCOPE)
endfunction()
# Adjust the directory path to an executable for a test
#
function(tribits_add_test_adjust_directory EXE_BINARY_NAME DIRECTORY
EXECUTABLE_PATH_OUT
)
set(EXECUTABLE_PATH "${EXE_BINARY_NAME}")
if (NOT IS_ABSOLUTE ${EXECUTABLE_PATH})
if (CMAKE_CONFIGURATION_TYPE)
set(EXECUTABLE_PATH "${CMAKE_CONFIGURATION_TYPE}/${EXECUTABLE_PATH}")
endif()
if (DIRECTORY)
set(EXECUTABLE_PATH "${DIRECTORY}/${EXECUTABLE_PATH}")
endif()
if (NOT IS_ABSOLUTE ${EXECUTABLE_PATH})
set(EXECUTABLE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${EXECUTABLE_PATH}")
endif()
endif()
set(${EXECUTABLE_PATH_OUT} ${EXECUTABLE_PATH} PARENT_SCOPE)
endfunction()
# Get the number of MPI processes to use
#
function(tribits_add_test_get_num_procs_used NUM_MPI_PROCS_IN
NUM_MPI_PROCS_VAR_NAME_IN NUM_MPI_PROCS_USED_OUT
NUM_MPI_PROCS_USED_NAME_OUT
)
if (NOT TPL_ENABLE_MPI)
set(MPI_EXEC_DEFAULT_NUMPROCS 1)
elseif (NOT DEFINED MPI_EXEC_DEFAULT_NUMPROCS)
set(MPI_EXEC_DEFAULT_NUMPROCS 1)
endif()
if (NOT TPL_ENABLE_MPI)
set(MPI_EXEC_MAX_NUMPROCS 1)
elseif (NOT DEFINED MPI_EXEC_MAX_NUMPROCS)
set(MPI_EXEC_MAX_NUMPROCS 1)
endif()
if (NOT NUM_MPI_PROCS_IN)
set(NUM_MPI_PROCS_IN ${MPI_EXEC_DEFAULT_NUMPROCS})
set(NUM_PROCS_VAR_NAME "MPI_EXEC_DEFAULT_NUMPROCS")
else()
set(NUM_PROCS_VAR_NAME "${NUM_MPI_PROCS_VAR_NAME_IN}")
endif()
if (${NUM_MPI_PROCS_IN} MATCHES [0-9]+-[0-9]+)
string(REGEX REPLACE "([0-9]+)-([0-9]+)" "\\1" MIN_NP ${NUM_MPI_PROCS_IN} )
string(REGEX REPLACE "([0-9]+)-([0-9]+)" "\\2" MAX_NP ${NUM_MPI_PROCS_IN} )
if(${MIN_NP} LESS ${MPI_EXEC_MAX_NUMPROCS} AND
${MAX_NP} GREATER ${MPI_EXEC_MAX_NUMPROCS}
)
set(NUM_PROCS_USED ${MPI_EXEC_MAX_NUMPROCS})
elseif (${MIN_NP} EQUAL ${MPI_EXEC_MAX_NUMPROCS})
set(NUM_PROCS_USED ${MIN_NP})
elseif (${MAX_NP} EQUAL ${MPI_EXEC_MAX_NUMPROCS})
set(NUM_PROCS_USED ${MAX_NP})
elseif (${MAX_NP} LESS ${MPI_EXEC_MAX_NUMPROCS})
set(NUM_PROCS_USED ${MAX_NP})
else()
# The number of available processors is outside the given range so the
# test should not be run.
set(NUM_PROCS_USED -1)
endif()
elseif (${NUM_MPI_PROCS_IN} MATCHES [0-9]+,[0-9]+)
message(SEND_ERROR "The test ${TEST_NAME} can not be added yet"
" because it we do not yet support the form of"
" NUM_MPI_PROCS=${NUM_MPI_PROCS_IN}")
set(NUM_PROCS_USED -1)
else()
if(${NUM_MPI_PROCS_IN} GREATER ${MPI_EXEC_MAX_NUMPROCS})
set(NUM_PROCS_USED -1)
if (${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper("-- ${TEST_NAME}: NOT added test because ${NUM_PROCS_VAR_NAME}='${NUM_MPI_PROCS_IN}' > MPI_EXEC_MAX_NUMPROCS='${MPI_EXEC_MAX_NUMPROCS}'!")
endif()
else()
set(NUM_PROCS_USED ${NUM_MPI_PROCS_IN})
endif()
endif()
set(${NUM_MPI_PROCS_USED_OUT} ${NUM_PROCS_USED} PARENT_SCOPE)
set(${NUM_MPI_PROCS_USED_NAME_OUT} ${NUM_PROCS_VAR_NAME} PARENT_SCOPE)
endfunction()
# Generate the array of arguments for an MPI run
#
# NOTE: The extra test program arguments are passed through ${ARGN}.
#
function( tribits_add_test_get_test_cmnd_array CMND_ARRAY_OUT
EXECUTABLE_PATH NUM_PROCS_USED
)
if (TPL_ENABLE_MPI)
set(${CMND_ARRAY_OUT}
"${MPI_EXEC}"
${MPI_EXEC_PRE_NUMPROCS_FLAGS}
${MPI_EXEC_NUMPROCS_FLAG} ${NUM_PROCS_USED}
${MPI_EXEC_POST_NUMPROCS_FLAGS}
"${EXECUTABLE_PATH}"
${ARGN}
PARENT_SCOPE
)
else()
set(${CMND_ARRAY_OUT}
"${EXECUTABLE_PATH}"
${ARGN}
PARENT_SCOPE
)
endif()
endfunction()
# Get the number of cores used by process
#
function(tribits_add_test_get_num_total_cores_used TEST_NAME_IN
NUM_TOTAL_CORES_USED_IN NUM_TOTAL_CORES_USED_NAME_IN
NUM_PROCS_USED_IN NUM_PROCS_USED_NAME_IN
NUM_TOTAL_CORES_USED_OUT SKIP_TEST_OUT
)
set(SKIP_TEST FALSE)
if (NUM_TOTAL_CORES_USED_IN)
set(NUM_TOTAL_CORES_USED ${NUM_TOTAL_CORES_USED_IN})
if (NUM_TOTAL_CORES_USED_IN GREATER MPI_EXEC_MAX_NUMPROCS)
if (${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper(
"-- ${TEST_NAME_IN}: NOT added test because ${NUM_TOTAL_CORES_USED_NAME_IN}='${NUM_TOTAL_CORES_USED_IN}' > MPI_EXEC_MAX_NUMPROCS='${MPI_EXEC_MAX_NUMPROCS}'!"
)
endif()
set(SKIP_TEST TRUE)
endif()
if (NUM_PROCS_USED_IN GREATER NUM_TOTAL_CORES_USED_IN)
message_wrapper(
FATAL_ERROR
"ERROR: ${TEST_NAME_IN}: ${NUM_PROCS_USED_NAME_IN}='${NUM_PROCS_USED}' > ${NUM_TOTAL_CORES_USED_NAME_IN}='${NUM_TOTAL_CORES_USED_IN}' not allowed!"
)
set(SKIP_TEST TRUE) # For unit testing since above will not abort!
endif()
else()
set(NUM_TOTAL_CORES_USED ${NUM_PROCS_USED_IN})
endif()
set(${NUM_TOTAL_CORES_USED_OUT} ${NUM_TOTAL_CORES_USED} PARENT_SCOPE)
set(${SKIP_TEST_OUT} ${SKIP_TEST} PARENT_SCOPE)
endfunction()
# Read ${TEST_NAME_IN}_SET_DISABLED_AND_MSG and set output var
# <setDisabledAndMsgOut> as used by the TRIBITS_ADD[_ADVANCED]_test()
# functions.
#
# Usage:
#
# tribits_set_disabled_and_msg(
# <testName> # The full test name passed to add_test()
# "${PARSE_DISABLED}" # From the input arg "DISABLED <msg>" to TA[A]t()
# <setDisabledAndMsgOut> # Sets var of this name on output
# )
#
function(tribits_set_disabled_and_msg TEST_NAME_IN PARSE_DISABLED
SET_DISABLED_AND_MSG_OUT
)
set(SET_DISABLED_AND_MSG "${PARSE_DISABLED}")
if (NOT "${${TEST_NAME_IN}_SET_DISABLED_AND_MSG}" STREQUAL "") # Override!
set(SET_DISABLED_AND_MSG "${${TEST_NAME_IN}_SET_DISABLED_AND_MSG}")
endif()
set(${SET_DISABLED_AND_MSG_OUT} "${SET_DISABLED_AND_MSG}" PARENT_SCOPE)
endfunction()
# Read ${TEST_NAME_IN}_SET_RUN_SERIAL and set output var SET_RUN_SERIAL_OUT as
# used by the TRIBITS_ADD[_ADVANCED]_test() functions.
#
# Usage:
#
# tribits_set_run_serial(
# <testName> # The full test name passed to add_test()
# "${PARSE_RUN_SERIAL}" # From the input option "RUN_SERIAL" to TA[A]t()
# <setRunSerialOut> # Sets var of this name on output
# )
#
function(tribits_set_run_serial TEST_NAME_IN PARSE_RUN_SERIAL
SET_RUN_SERIAL_OUT
)
set(SET_RUN_SERIAL "${PARSE_RUN_SERIAL}")
if (NOT "${${TEST_NAME_IN}_SET_RUN_SERIAL}" STREQUAL "") # Override!
set(SET_RUN_SERIAL "${${TEST_NAME_IN}_SET_RUN_SERIAL}")
endif()
set(${SET_RUN_SERIAL_OUT} "${SET_RUN_SERIAL}" PARENT_SCOPE)
endfunction()
# Determine if the test should be skipped due to a disable var set
#
# Usage:
#
# tribits_add_test_query_disable(
# <disableThisTestVarOut> # Set var of this name on output
# )
#
function(tribits_add_test_query_disable DISABLE_TEST_VAR_OUT)
#message("tribits_add_test_query_disable(): ${DISABLE_TEST_VAR_OUT} ${ARGN}")
list(GET ARGN 0 TEST_NAME_IN)
set(TEST_NAME_DISABLE_VAR ${TEST_NAME_IN}_DISABLE)
#print_var(${TEST_NAME_DISABLE_VAR})
if (${TEST_NAME_DISABLE_VAR})
if (${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper(
"-- ${TEST_NAME_IN}: NOT added test because ${TEST_NAME_DISABLE_VAR}='${${TEST_NAME_DISABLE_VAR}}'!")
endif()
set(${DISABLE_TEST_VAR_OUT} ON PARENT_SCOPE)
else()
set(${DISABLE_TEST_VAR_OUT} OFF PARENT_SCOPE)
endif()
endfunction()
#
# Determine if to disable test due to <Package>_SKIP_CTEST_ADD_TEST=ON
#
function(tribits_add_test_process_skip_ctest_add_test ADD_THE_TEST_OUT)
if(${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST OR ${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST)
if (PARENT_PACKAGE_NAME STREQUAL PACKAGE_NAME)
set(DISABLE_VAR_MSG
"${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST='${${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST}'")
else()
set(DISABLE_VAR_MSG
"${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST='${${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST}'")
endif()
message_wrapper(
"-- ${TEST_NAME}: NOT added test because ${DISABLE_VAR_MSG}!")
set(ADD_THE_TEST FALSE)
else()
set(ADD_THE_TEST TRUE)
endif()
set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
endfunction()
#
# Wrapper for adding a test to facilitate unit testing
#
function(tribits_add_test_add_test TEST_NAME EXE_NAME)
string(REPLACE "${PARSE_LIST_SEPARATOR}" "\\;" args "${ARGN}")
if (TRIBITS_ADD_TEST_ADD_TEST_CAPTURE)
append_global_set(TRIBITS_ADD_TEST_ADD_TEST_INPUT NAME ${TEST_NAME} COMMAND ${args})
endif()
if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
add_test(NAME ${TEST_NAME} COMMAND ${args})
endif()
tribits_set_tests_properties(${TEST_NAME} PROPERTIES REQUIRED_FILES ${EXE_NAME})
endfunction()
#
# Set the pass/fail properties of a test that has already been added
#
function(tribits_private_add_test_set_passfail_properties TEST_NAME_IN)
# PASS_REGULAR_EXPRESSION
if (PARSE_STANDARD_PASS_OUTPUT)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PASS_REGULAR_EXPRESSION
"End Result: TEST PASSED")
endif()
if (PARSE_PASS_REGULAR_EXPRESSION)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PASS_REGULAR_EXPRESSION
"${PARSE_PASS_REGULAR_EXPRESSION}")
endif()
if (PARSE_WILL_FAIL)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES WILL_FAIL ON)
endif()
# FAIL_REGULAR_EXPRESSION
if (PARSE_FAIL_REGULAR_EXPRESSION)
tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY FAIL_REGULAR_EXPRESSION
"${PARSE_FAIL_REGULAR_EXPRESSION}")
endif()
if (${PACKAGE_NAME}_ENABLE_CIRCULAR_REF_DETECTION_FAILURE OR
${PROJECT_NAME}_ENABLE_CIRCULAR_REF_DETECTION_FAILURE
)
tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY FAIL_REGULAR_EXPRESSION
"The following Teuchos::RCPNode objects were created")
# NOTE: The above string must be kept in sync with the C++ code!
endif()
# ToDo: Make a variable ${PROJECT_NAME}_EXTRA_FAIL_REGULAR_EXPRESSION and
# move the above logic to Trilinos somehow.
endfunction()
#
# Set the timeout for a test already added
#
function(tribits_private_add_test_set_timeout TEST_NAME_IN TIMEOUT_USED_OUT)
if (PARSE_TIMEOUT)
tribits_scale_timeout("${PARSE_TIMEOUT}" TIMEOUT_USED)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES TIMEOUT ${TIMEOUT_USED})
else()
set(TIMEOUT_USED "")
endif()
set(${TIMEOUT_USED_OUT} ${TIMEOUT_USED} PARENT_SCOPE)
endfunction()
#
# Set the environment for a test already added
#
function(tribits_private_add_test_set_environment TEST_NAME_IN)
if (PARSE_ENVIRONMENT)
string(REPLACE "${PARSE_LIST_SEPARATOR}" "\\;" PARSE_ENVIRONMENT
"${PARSE_ENVIRONMENT}")
tribits_set_test_property(${TEST_NAME_IN} PROPERTY ENVIRONMENT
"${PARSE_ENVIRONMENT}")
endif()
endfunction()
#
# Set the environment for a test already added
#
function(tribits_private_add_test_set_processors TEST_NAME_IN
NUM_TOTAL_CORES_USED_IN PROCESSORS_OUT
)
set(PROCESSORS_USED ${NUM_TOTAL_CORES_USED_IN})
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PROCESSORS
"${PROCESSORS_USED}")
set(${PROCESSORS_OUT} ${PROCESSORS_USED} PARENT_SCOPE)
endfunction()
# Print test added message!
#
function(tribits_private_add_test_print_added TEST_NAME_IN CATEGORIES_IN
NUM_MPI_PROCS_IN PROCESSORS_IN TIMEOUT_IN RUN_SERIAL_IN DISABLED_MSG_IN
)
set(ADDED_TEST_PROPS "")
tribits_get_categories_string("${CATEGORIES_IN}" CATEGORIES_IN_COMMAS)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "${CATEGORIES_IN_COMMAS}")
if (NUM_MPI_PROCS_IN AND TPL_ENABLE_MPI)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "NUM_MPI_PROCS=${NUM_MPI_PROCS_IN}")
endif()
if (PROCESSORS_IN)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "PROCESSORS=${PROCESSORS_IN}")
endif()
if (TIMEOUT_IN)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "TIMEOUT=${TIMEOUT_IN}")
endif()
if (RUN_SERIAL_IN)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "RUN_SERIAL")
endif()
if (DISABLED_MSG_IN)
append_string_var_with_sep(ADDED_TEST_PROPS
", " "DISABLED")
endif()
if (ADDED_TEST_PROPS)
set(ADDED_TEST_PROPS " (${ADDED_TEST_PROPS})")
endif()
if (${PROJECT_NAME}_TRACE_ADD_TEST)
message_wrapper("-- ${TEST_NAME_IN}: Added test${ADDED_TEST_PROPS}!")
if (DISABLED_MSG_IN)
message_wrapper("-- => Reason DISABLED: ${DISABLED_MSG_IN}")
endif()
endif()
endfunction()
# Overall add test command
#
# NOTE: Pass the command arguments on the end in ARGSN.
#
function(tribits_add_test_add_test_all TEST_NAME_IN
EXECUTABLE_PATH_IN CATEGORIES_IN NUM_PROCS_USED_IN NUM_TOTAL_CORES_USED_IN
RUN_SERIAL_IN DISABLED_MSG_IN
ADDED_TEST_NAME_OUT
)
tribits_add_test_get_test_cmnd_array( CMND_ARRAY
"${EXECUTABLE_PATH_IN}" "${NUM_PROCS_USED_IN}" ${ARGN} )
tribits_add_test_query_disable(DISABLE_THIS_TEST ${TEST_NAME_IN})
if (NOT DISABLE_THIS_TEST)
tribits_add_test_add_test(${TEST_NAME_IN} ${EXECUTABLE_PATH_IN} ${CMND_ARRAY})
set(${ADDED_TEST_NAME_OUT} ${TEST_NAME_IN} PARENT_SCOPE)
tribits_private_add_test_post_process_added_test(${TEST_NAME_IN}
"${CATEGORIES_IN}" ${NUM_PROCS_USED_IN} "${NUM_TOTAL_CORES_USED_IN}"
"${RUN_SERIAL_IN}" "${DISABLED_MSG_IN}")
else()
set(${ADDED_TEST_NAME_OUT} "" PARENT_SCOPE)
endif()
endfunction()
# Set the label and keywords
#
function(tribits_private_add_test_add_label_and_keywords TEST_NAME_IN)
tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY
LABELS ${PARENT_PACKAGE_NAME})
if(PARSE_KEYWORDS)
tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY
LABELS ${PARSE_KEYWORDS})
endif()
endfunction()
# Postprocess a test that was added
#
function(tribits_private_add_test_post_process_added_test TEST_NAME_IN
CATEGORIES_IN NUM_PROCS_USED_IN NUM_TOTAL_CORES_USED_IN
RUN_SERIAL_IN DISABLED_MSG_IN
)
tribits_private_add_test_set_passfail_properties(${TEST_NAME_IN})
tribits_private_add_test_set_environment(${TEST_NAME_IN})
tribits_private_add_test_set_processors(${TEST_NAME_IN}
"${NUM_TOTAL_CORES_USED_IN}" PROCESSORS_USED)
tribits_private_add_test_set_timeout(${TEST_NAME_IN} TIMEOUT_USED)
if(RUN_SERIAL_IN)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES RUN_SERIAL ON)
endif()
if(DISABLED_MSG_IN)
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES DISABLED ON)
endif()
tribits_private_add_test_add_environment_and_resource(${TEST_NAME_IN}
${NUM_PROCS_USED_IN})
tribits_private_add_test_add_label_and_keywords(${TEST_NAME_IN})
tribits_private_add_test_print_added(${TEST_NAME_IN}
"${CATEGORIES_IN}" "${NUM_PROCS_USED_IN}" "${PROCESSORS_USED}"
"${TIMEOUT_USED}" "${RUN_SERIAL_IN}" "${DISABLED_MSG_IN}")
endfunction()
# Add environment and resource properties to a test
#
function(tribits_private_add_test_add_environment_and_resource TEST_NAME_IN
NUM_PROCS_USED_IN
)
if(TRIBITS_TEST_EXTRA_ENVIRONMENT)
tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY ENVIRONMENT
"${TRIBITS_TEST_EXTRA_ENVIRONMENT}")
endif()
if(TRIBITS_RESOURCES_PER_PROCESS)
set(NUM_PROCESSES ${NUM_PROCS_USED_IN})
if(NOT NUM_PROCESSES OR NUM_PROCESSES LESS 1)
set(NUM_PROCESSES 1)
endif()
tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES RESOURCE_GROUPS
"${NUM_PROCESSES},${TRIBITS_RESOURCES_PER_PROCESS}")
endif()
endfunction()