Debian Codegraph @

cmake/tribits/core/test_support/TribitsAddTestHelpers.cmake

raw
1 # @HEADER
2 # *****************************************************************************
3 # TriBITS: Tribal Build, Integrate, and Test System
4 #
5 # Copyright 2013-2016 NTESS and the TriBITS contributors.
6 # SPDX-License-Identifier: BSD-3-Clause
7 # *****************************************************************************
8 # @HEADER
9
10 include_guard()
11
12 include("${CMAKE_CURRENT_LIST_DIR}/TribitsAddExecutableTestHelpers.cmake")
13 include("${CMAKE_CURRENT_LIST_DIR}/TribitsSetTribitsPackageName.cmake")
14 include("${CMAKE_CURRENT_LIST_DIR}/TribitsTestCategories.cmake")
15
16 include("${CMAKE_CURRENT_LIST_DIR}/../utils/GlobalSet.cmake")
17 include("${CMAKE_CURRENT_LIST_DIR}/../utils/AppendGlobalSet.cmake")
18 include("${CMAKE_CURRENT_LIST_DIR}/../utils/AppendStringVarWithSep.cmake")
19 include("${CMAKE_CURRENT_LIST_DIR}/../utils/PrintVar.cmake")
20 include("${CMAKE_CURRENT_LIST_DIR}/../utils/AdvancedSet.cmake")
21 include("${CMAKE_CURRENT_LIST_DIR}/../utils/MessageWrapper.cmake")
22 include("${CMAKE_CURRENT_LIST_DIR}/../utils/TribitsGetCategoriesString.cmake")
23 include("${CMAKE_CURRENT_LIST_DIR}/../utils/TribitsSetCacheVarAndDefault.cmake")
24
25
26 tribits_advanced_set_cache_var_and_default(${PROJECT_NAME}_TRACE_ADD_TEST BOOL
27 "${${PROJECT_NAME}_VERBOSE_CONFIGURE}"
28 "Show a configure-time trace of every test added or not added any why (one line).")
29
30
31 # Do initialization for test helpers
32 #
33 # This must be run just before the packages define their tests and this macro
34 # must be run in the base-level project scope.
35 #
36 macro(tribits_add_test_helpers_init)
37 if (TPL_ENABLE_CUDA)
38 set(TRIBITS_TEST_EXTRA_ENVIRONMENT CTEST_KOKKOS_DEVICE_TYPE=gpus)
39 set(TRIBITS_RESOURCES_PER_PROCESS gpus:1)
40 endif()
41 endmacro()
42
43
44 # Wrapper function for set_tests_properties() to be used in unit testing.
45 #
46 function(tribits_set_tests_properties)
47 cmake_parse_arguments(PARSE_ARGV 0 FWD "" "" "")
48 if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
49 set_tests_properties(${FWD_UNPARSED_ARGUMENTS})
50 endif()
51 if (TRIBITS_SET_TEST_PROPERTIES_CAPTURE_INPUT)
52 append_global_set(TRIBITS_SET_TEST_PROPERTIES_INPUT ${FWD_UNPARSED_ARGUMENTS})
53 endif()
54 endfunction()
55
56
57 # Wrapper function for set_property(TEST ...) to be used in unit testing
58 #
59 function(tribits_set_test_property)
60 cmake_parse_arguments(PARSE_ARGV 0 FWD "" "" "")
61 if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
62 set_property(TEST ${FWD_UNPARSED_ARGUMENTS})
63 endif()
64 if (TRIBITS_SET_TEST_PROPERTIES_CAPTURE_INPUT)
65 append_global_set(TRIBITS_SET_TEST_PROPERTIES_INPUT ${FWD_UNPARSED_ARGUMENTS})
66 endif()
67 endfunction()
68
69
70 # Scale a timeout by ${PROJECT_NAME}_SCALE_TEST_TIMEOUT
71 #
72 # This function will truncate input TIMEOUT_IN but will allow for a simple
73 # fractional scale factor. It will also truncate the scale factor to just one
74 # decimal place. CMake math(EXPR ...) does not support floating point so I
75 # have to use just manual integer arithmetic.
76 #
77 function(tribits_scale_timeout TIMEOUT_IN SCALED_TIMEOUT_OUT)
78
79 if (${PROJECT_NAME}_SCALE_TEST_TIMEOUT
80 AND NOT "${${PROJECT_NAME}_SCALE_TEST_TIMEOUT}" EQUAL "1.0"
81 )
82
83 # Strip of any fractional part of the timeout
84 split("${TIMEOUT_IN}" "[.]" TIMEOUT_IN_ARRAY)
85 #print_var(TIMEOUT_IN_ARRAY)
86 list(GET TIMEOUT_IN_ARRAY 0 TIMEOUT_IN_TRUNCATED)
87 #print_var(TIMEOUT_IN_TRUNCATED)
88
89 # Split the factional part of the scaling factor into SCALE_TEST_INT and
90 # SCALE_TEST_INT_FRAC and do the math ourself with integer floating pint
91 split("${${PROJECT_NAME}_SCALE_TEST_TIMEOUT}" "[.]" SCALE_TEST_ARRAY)
92 list(LENGTH SCALE_TEST_ARRAY SCALE_TEST_ARRAY_LEN)
93 #print_var(SCALE_TEST_ARRAY_LEN)
94
95 list(GET SCALE_TEST_ARRAY 0 SCALE_TEST_INT)
96 #print_var(SCALE_TEST_INT)
97
98 math(EXPR TIMEOUT_USED
99 "${TIMEOUT_IN_TRUNCATED} * ${SCALE_TEST_INT}")
100 #print_var(TIMEOUT_USED)
101
102 if ("${SCALE_TEST_ARRAY_LEN}" GREATER 1)
103 # Handle the factional part (only take the first digit)
104 list(GET SCALE_TEST_ARRAY 1 SCALE_TEST_INT_FRAC_FULL) # Could be more than 1 digit
105 #print_var(SCALE_TEST_INT_FRAC_FULL)
106 string(SUBSTRING "${SCALE_TEST_INT_FRAC_FULL}" 0 1 SCALE_TEST_INT_FRAC)
107 #print_var(SCALE_TEST_INT_FRAC)
108 math(EXPR TIMEOUT_USED
109 "${TIMEOUT_USED} + (${SCALE_TEST_INT_FRAC} * ${TIMEOUT_IN_TRUNCATED}) / 10")
110 #print_var(TIMEOUT_USED)
111 endif()
112
113 else()
114
115 set(TIMEOUT_USED "${TIMEOUT_IN}")
116
117 endif()
118
119 set(${SCALED_TIMEOUT_OUT} ${TIMEOUT_USED} PARENT_SCOPE)
120
121 endfunction()
122
123
124 # Function that converts a complete string of command-line arguments
125 # into a form that add_test(...) can correctly deal with.
126 #
127 # The main thing this function does is to replace spaces ' ' with
128 # array separators ';' since this is how add_test(...) expects to deal
129 # with command-line arguments, as array arguments. However, this
130 # function will not do a replacement of ' ' with ';' if a quote is
131 # active. This allows you to pass in quoted arguments and have them
132 # treated as a single argument.
133 #
134 function(tribits_convert_cmnd_arg_string_to_add_test_arg_array CMND_ARG_STRING ARG_ARRAY_VARNAME)
135
136 #message("TRIBITS_CONVERT_CMND_ARG_STRING_TO_ADD_TEST_ARG_ARRAY")
137 #print_var(CMND_ARG_STRING)
138 #print_var(ARG_ARRAY_VARNAME)
139
140 string(LENGTH ${CMND_ARG_STRING} STR_LEN)
141 #print_var(STR_LEN)
142
143 math(EXPR STR_LAST_IDX "${STR_LEN}-1")
144
145 set(NEWSTR)
146
147 set(ACTIVE_QUOTE OFF)
148
149 foreach(IDX RANGE ${STR_LAST_IDX})
150
151 string(SUBSTRING ${CMND_ARG_STRING} ${IDX} 1 STR_CHAR)
152 #print_var(STR_CHAR)
153
154 if (STR_CHAR STREQUAL "\"")
155 if (NOT ACTIVE_QUOTE)
156 set(ACTIVE_QUOTE ON)
157 else()
158 set(ACTIVE_QUOTE OFF)
159 endif()
160 #print_var(ACTIVE_QUOTE)
161 endif()
162
163 if (NOT STR_CHAR STREQUAL " ")
164 set(NEWSTR "${NEWSTR}${STR_CHAR}")
165 else()
166 if (ACTIVE_QUOTE)
167 set(NEWSTR "${NEWSTR}${STR_CHAR}")
168 else()
169 set(NEWSTR "${NEWSTR};")
170 endif()
171 endif()
172
173 endforeach()
174
175 #print_var(NEWSTR)
176
177 set(${ARG_ARRAY_VARNAME} ${NEWSTR} PARENT_SCOPE)
178
179 endfunction()
180
181
182 # Determine if to add the test based on if testing is enabled for the current
183 # package.
184 #
185 function(tribits_add_test_process_enable_tests ADD_THE_TEST_OUT)
186 if(${PACKAGE_NAME}_ENABLE_TESTS)
187 set(ADD_THE_TEST TRUE)
188 else()
189 message_wrapper(
190 "-- ${TEST_NAME}: NOT added test because"
191 " ${PACKAGE_NAME}_ENABLE_TESTS='${${PACKAGE_NAME}_ENABLE_TESTS}'.")
192 set(ADD_THE_TEST FALSE)
193 endif()
194 set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
195 endfunction()
196
197
198 # Determine if to add the test or not based on [X]HOST and [X]HOSTTYPE arguments
199 #
200 # Warning: Arguments for [X]HOST and [X]HOSTTYPE arguments are passed in
201 # implicitly due to scoping of CMake.
202 #
203 function(tribits_add_test_process_host_hosttype ADD_THE_TEST_OUT)
204
205 if ("${${PROJECT_NAME}_HOSTNAME}" STREQUAL "")
206 set(${PROJECT_NAME}_HOSTNAME dummy_host)
207 endif()
208
209 set(ADD_THE_TEST TRUE)
210
211 if (ADD_THE_TEST)
212 if (NOT PARSE_HOST)
213 set (PARSE_HOST ${${PROJECT_NAME}_HOSTNAME})
214 endif()
215 LIST (FIND PARSE_HOST ${${PROJECT_NAME}_HOSTNAME} INDEX_OF_HOSTNAME_IN_HOST_LIST)
216 if (${INDEX_OF_HOSTNAME_IN_HOST_LIST} EQUAL -1)
217 set(ADD_THE_TEST FALSE)
218 set(HOST_MATCH_MSG
219 "-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_HOSTNAME='${${PROJECT_NAME}_HOSTNAME}' does not match list HOST='${PARSE_HOST}'!"
220 )
221 endif()
222 endif()
223
224 if (ADD_THE_TEST)
225 if (NOT PARSE_XHOST)
226 set (PARSE_XHOST NONE)
227 endif()
228 LIST (FIND PARSE_XHOST ${${PROJECT_NAME}_HOSTNAME} INDEX_OF_HOSTNAME_IN_XHOST_LIST)
229 if (NOT ${INDEX_OF_HOSTNAME_IN_XHOST_LIST} EQUAL -1)
230 set(ADD_THE_TEST FALSE)
231 set(HOST_MATCH_MSG
232 "-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_HOSTNAME='${${PROJECT_NAME}_HOSTNAME}' matches list XHOST='${PARSE_XHOST}'!"
233 )
234 endif()
235 endif()
236
237 if (ADD_THE_TEST)
238 if (NOT PARSE_HOSTTYPE)
239 set(PARSE_HOSTTYPE ${CMAKE_HOST_SYSTEM_NAME})
240 endif()
241 LIST (FIND PARSE_HOSTTYPE ${CMAKE_HOST_SYSTEM_NAME} INDEX_OF_HOSTSYSTEMNAME_IN_HOSTTYPE_LIST)
242 if (${INDEX_OF_HOSTSYSTEMNAME_IN_HOSTTYPE_LIST} EQUAL -1)
243 set(ADD_THE_TEST FALSE)
244 set(HOST_MATCH_MSG
245 "-- ${TEST_NAME}: NOT added test because CMAKE_HOST_SYSTEM_NAME='${CMAKE_HOST_SYSTEM_NAME}' does not match list HOSTTYPE='${PARSE_HOSTTYPE}'!"
246 )
247 endif()
248 endif()
249
250 if (ADD_THE_TEST)
251 if (NOT PARSE_XHOSTTYPE)
252 set(PARSE_XHOSTTYPE NONE)
253 endif()
254 LIST (FIND PARSE_XHOSTTYPE ${CMAKE_HOST_SYSTEM_NAME} INDEX_OF_HOSTSYSTEMNAME_IN_XHOSTTYPE_LIST)
255 if (NOT ${INDEX_OF_HOSTSYSTEMNAME_IN_XHOSTTYPE_LIST} EQUAL -1)
256 set(ADD_THE_TEST FALSE)
257 set(HOST_MATCH_MSG
258 "-- ${TEST_NAME}: NOT added test because CMAKE_HOST_SYSTEM_NAME='${CMAKE_HOST_SYSTEM_NAME}' matches list XHOSTTYPE='${PARSE_XHOSTTYPE}'!"
259 )
260 endif()
261 endif()
262
263 foreach(VAR_NAME ${PARSE_EXCLUDE_IF_NOT_TRUE})
264 if (ADD_THE_TEST AND NOT ${VAR_NAME})
265 set(ADD_THE_TEST FALSE)
266 set(HOST_MATCH_MSG
267 "-- ${TEST_NAME}: NOT added test because EXCLUDE_IF_NOT_TRUE ${VAR_NAME}='${${VAR_NAME}}'!"
268 )
269 endif()
270 endforeach()
271
272 if (HOST_MATCH_MSG AND ${PROJECT_NAME}_TRACE_ADD_TEST)
273 message_wrapper("${HOST_MATCH_MSG}")
274 endif()
275
276 set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
277
278 endfunction()
279
280
281 # Determine if to add the test or not based on CATEGORIES arguments
282 #
283 # Warning: Argument PARSE_CATEGORIES is passed in implicitly due to scoping of
284 # CMake.
285 #
286 function(tribits_add_test_process_categories ADD_THE_TEST_OUT)
287
288 tribits_filter_and_assert_categories(PARSE_CATEGORIES)
289 set(PARSE_CATEGORIES ${PARSE_CATEGORIES} PARENT_SCOPE)
290
291 set(ADD_THE_TEST FALSE)
292
293 # Set the default test-specific category to basic if it is not set
294 if (NOT PARSE_CATEGORIES)
295 set (PARSE_CATEGORIES BASIC)
296 endif()
297
298 #print_var(${PROJECT_NAME}_TEST_CATEGORIES)
299 #print_var(PARSE_CATEGORIES)
300
301 if ("${${PROJECT_NAME}_TEST_CATEGORIES}" STREQUAL "")
302 # In case this is not a TriBITS project!
303 set(${PROJECT_NAME}_TEST_CATEGORIES BASIC)
304 endif()
305
306 # Process the test categories
307 assert_defined(${PROJECT_NAME}_TEST_CATEGORIES)
308 foreach(CATEGORY_USR_SET ${${PROJECT_NAME}_TEST_CATEGORIES})
309 #print_var(CATEGORY_USR_SET)
310 #print_var(PARSE_CATEGORIES)
311 foreach(CATEGORY ${PARSE_CATEGORIES})
312 if (CATEGORY STREQUAL ${CATEGORY_USR_SET})
313 # Exact match for the category, add the test
314 set(ADD_THE_TEST TRUE)
315 elseif(CATEGORY STREQUAL "BASIC")
316 if (CATEGORY_USR_SET STREQUAL "CONTINUOUS" OR CATEGORY_USR_SET STREQUAL "NIGHTLY"
317 OR CATEGORY_USR_SET STREQUAL "HEAVY"
318 )
319 set(ADD_THE_TEST TRUE)
320 endif()
321 elseif(CATEGORY STREQUAL "CONTINUOUS")
322 if (CATEGORY_USR_SET STREQUAL "NIGHTLY" OR CATEGORY_USR_SET STREQUAL "HEAVY")
323 set(ADD_THE_TEST TRUE)
324 endif()
325 elseif(CATEGORY STREQUAL "NIGHTLY")
326 if (CATEGORY_USR_SET STREQUAL "HEAVY")
327 set(ADD_THE_TEST TRUE)
328 endif()
329 else()
330 # No matches for the category, don't add the test
331 endif()
332 endforeach()
333 endforeach()
334
335 #print_var(TEST_NAME)
336 #print_var(ADD_THE_TEST)
337 #print_var(${PROJECT_NAME}_TRACE_ADD_TEST)
338
339 if (TEST_NAME AND NOT ADD_THE_TEST AND ${PROJECT_NAME}_TRACE_ADD_TEST)
340 message_wrapper(
341 "-- ${TEST_NAME}: NOT added test because ${PROJECT_NAME}_TEST_CATEGORIES='${${PROJECT_NAME}_TEST_CATEGORIES}' does not match this test's CATEGORIES='${PARSE_CATEGORIES}'!"
342 )
343 endif()
344
345
346 set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
347 #print_var(${ADD_THE_TEST_OUT})
348
349 endfunction()
350
351
352 # FUNCTION: tribits_add_test_get_exe_binary_name()
353 #
354 # Get the full name of a package executable given its root name and other
355 # arguments.
356 #
357 # Usage:
358 #
359 # tribits_add_test_get_exe_binary_name(
360 # <execRootName>
361 # NOEXEPREFIX_IN
362 # NOEXESUFFIX_IN
363 # ADD_DIR_TO_NAME
364 # EXE_BINARY_NAME_OUT
365 # )
366 #
367 # By default, the full name of the executable is assumed to be::
368 #
369 # ${PACKAGE_NAME}_<execName>${${PROJECT_NAME}_CMAKE_EXECUTABLE_SUFFIX}
370 #
371 function(tribits_add_test_get_exe_binary_name EXE_NAME_IN
372 NOEXEPREFIX_IN NOEXESUFFIX_IN ADD_DIR_TO_NAME EXE_BINARY_NAME_OUT
373 )
374 set(EXE_BINARY_NAME "${EXE_NAME_IN}")
375 if(PARSE_ADD_DIR_TO_NAME)
376 set(DIRECTORY_NAME "")
377 tribits_create_name_from_current_source_directory(DIRECTORY_NAME)
378 set(EXE_BINARY_NAME "${DIRECTORY_NAME}_${EXE_BINARY_NAME}")
379 endif()
380 if (NOEXESUFFIX_IN)
381 set(EXECUTABLE_SUFFIX "")
382 else()
383 set(EXECUTABLE_SUFFIX ${${PROJECT_NAME}_CMAKE_EXECUTABLE_SUFFIX})
384 endif()
385 set(EXE_BINARY_NAME "${EXE_BINARY_NAME}${EXECUTABLE_SUFFIX}")
386 if(PACKAGE_NAME AND NOT NOEXEPREFIX_IN)
387 set(EXE_BINARY_NAME ${PACKAGE_NAME}_${EXE_BINARY_NAME})
388 endif()
389 set(${EXE_BINARY_NAME_OUT} ${EXE_BINARY_NAME} PARENT_SCOPE)
390 endfunction()
391
392
393 # Adjust the directory path to an executable for a test
394 #
395 function(tribits_add_test_adjust_directory EXE_BINARY_NAME DIRECTORY
396 EXECUTABLE_PATH_OUT
397 )
398
399 set(EXECUTABLE_PATH "${EXE_BINARY_NAME}")
400
401 if (NOT IS_ABSOLUTE ${EXECUTABLE_PATH})
402
403 if (CMAKE_CONFIGURATION_TYPE)
404 set(EXECUTABLE_PATH "${CMAKE_CONFIGURATION_TYPE}/${EXECUTABLE_PATH}")
405 endif()
406
407 if (DIRECTORY)
408 set(EXECUTABLE_PATH "${DIRECTORY}/${EXECUTABLE_PATH}")
409 endif()
410
411 if (NOT IS_ABSOLUTE ${EXECUTABLE_PATH})
412 set(EXECUTABLE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${EXECUTABLE_PATH}")
413 endif()
414
415 endif()
416
417 set(${EXECUTABLE_PATH_OUT} ${EXECUTABLE_PATH} PARENT_SCOPE)
418
419 endfunction()
420
421
422 # Get the number of MPI processes to use
423 #
424 function(tribits_add_test_get_num_procs_used NUM_MPI_PROCS_IN
425 NUM_MPI_PROCS_VAR_NAME_IN NUM_MPI_PROCS_USED_OUT
426 NUM_MPI_PROCS_USED_NAME_OUT
427 )
428 if (NOT TPL_ENABLE_MPI)
429 set(MPI_EXEC_DEFAULT_NUMPROCS 1)
430 elseif (NOT DEFINED MPI_EXEC_DEFAULT_NUMPROCS)
431 set(MPI_EXEC_DEFAULT_NUMPROCS 1)
432 endif()
433 if (NOT TPL_ENABLE_MPI)
434 set(MPI_EXEC_MAX_NUMPROCS 1)
435 elseif (NOT DEFINED MPI_EXEC_MAX_NUMPROCS)
436 set(MPI_EXEC_MAX_NUMPROCS 1)
437 endif()
438 if (NOT NUM_MPI_PROCS_IN)
439 set(NUM_MPI_PROCS_IN ${MPI_EXEC_DEFAULT_NUMPROCS})
440 set(NUM_PROCS_VAR_NAME "MPI_EXEC_DEFAULT_NUMPROCS")
441 else()
442 set(NUM_PROCS_VAR_NAME "${NUM_MPI_PROCS_VAR_NAME_IN}")
443 endif()
444 if (${NUM_MPI_PROCS_IN} MATCHES [0-9]+-[0-9]+)
445 string(REGEX REPLACE "([0-9]+)-([0-9]+)" "\\1" MIN_NP ${NUM_MPI_PROCS_IN} )
446 string(REGEX REPLACE "([0-9]+)-([0-9]+)" "\\2" MAX_NP ${NUM_MPI_PROCS_IN} )
447 if(${MIN_NP} LESS ${MPI_EXEC_MAX_NUMPROCS} AND
448 ${MAX_NP} GREATER ${MPI_EXEC_MAX_NUMPROCS}
449 )
450 set(NUM_PROCS_USED ${MPI_EXEC_MAX_NUMPROCS})
451 elseif (${MIN_NP} EQUAL ${MPI_EXEC_MAX_NUMPROCS})
452 set(NUM_PROCS_USED ${MIN_NP})
453 elseif (${MAX_NP} EQUAL ${MPI_EXEC_MAX_NUMPROCS})
454 set(NUM_PROCS_USED ${MAX_NP})
455 elseif (${MAX_NP} LESS ${MPI_EXEC_MAX_NUMPROCS})
456 set(NUM_PROCS_USED ${MAX_NP})
457 else()
458 # The number of available processors is outside the given range so the
459 # test should not be run.
460 set(NUM_PROCS_USED -1)
461 endif()
462 elseif (${NUM_MPI_PROCS_IN} MATCHES [0-9]+,[0-9]+)
463 message(SEND_ERROR "The test ${TEST_NAME} can not be added yet"
464 " because it we do not yet support the form of"
465 " NUM_MPI_PROCS=${NUM_MPI_PROCS_IN}")
466 set(NUM_PROCS_USED -1)
467 else()
468 if(${NUM_MPI_PROCS_IN} GREATER ${MPI_EXEC_MAX_NUMPROCS})
469 set(NUM_PROCS_USED -1)
470 if (${PROJECT_NAME}_TRACE_ADD_TEST)
471 message_wrapper("-- ${TEST_NAME}: NOT added test because ${NUM_PROCS_VAR_NAME}='${NUM_MPI_PROCS_IN}' > MPI_EXEC_MAX_NUMPROCS='${MPI_EXEC_MAX_NUMPROCS}'!")
472 endif()
473 else()
474 set(NUM_PROCS_USED ${NUM_MPI_PROCS_IN})
475 endif()
476 endif()
477 set(${NUM_MPI_PROCS_USED_OUT} ${NUM_PROCS_USED} PARENT_SCOPE)
478 set(${NUM_MPI_PROCS_USED_NAME_OUT} ${NUM_PROCS_VAR_NAME} PARENT_SCOPE)
479 endfunction()
480
481
482 # Generate the array of arguments for an MPI run
483 #
484 # NOTE: The extra test program arguments are passed through ${ARGN}.
485 #
486 function( tribits_add_test_get_test_cmnd_array CMND_ARRAY_OUT
487 EXECUTABLE_PATH NUM_PROCS_USED
488 )
489 if (TPL_ENABLE_MPI)
490 set(${CMND_ARRAY_OUT}
491 "${MPI_EXEC}"
492 ${MPI_EXEC_PRE_NUMPROCS_FLAGS}
493 ${MPI_EXEC_NUMPROCS_FLAG} ${NUM_PROCS_USED}
494 ${MPI_EXEC_POST_NUMPROCS_FLAGS}
495 "${EXECUTABLE_PATH}"
496 ${ARGN}
497 PARENT_SCOPE
498 )
499 else()
500 set(${CMND_ARRAY_OUT}
501 "${EXECUTABLE_PATH}"
502 ${ARGN}
503 PARENT_SCOPE
504 )
505 endif()
506 endfunction()
507
508
509 # Get the number of cores used by process
510 #
511 function(tribits_add_test_get_num_total_cores_used TEST_NAME_IN
512 NUM_TOTAL_CORES_USED_IN NUM_TOTAL_CORES_USED_NAME_IN
513 NUM_PROCS_USED_IN NUM_PROCS_USED_NAME_IN
514 NUM_TOTAL_CORES_USED_OUT SKIP_TEST_OUT
515 )
516
517 set(SKIP_TEST FALSE)
518
519 if (NUM_TOTAL_CORES_USED_IN)
520
521 set(NUM_TOTAL_CORES_USED ${NUM_TOTAL_CORES_USED_IN})
522
523 if (NUM_TOTAL_CORES_USED_IN GREATER MPI_EXEC_MAX_NUMPROCS)
524 if (${PROJECT_NAME}_TRACE_ADD_TEST)
525 message_wrapper(
526 "-- ${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}'!"
527 )
528 endif()
529 set(SKIP_TEST TRUE)
530 endif()
531
532 if (NUM_PROCS_USED_IN GREATER NUM_TOTAL_CORES_USED_IN)
533 message_wrapper(
534 FATAL_ERROR
535 "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!"
536 )
537 set(SKIP_TEST TRUE) # For unit testing since above will not abort!
538 endif()
539
540 else()
541
542 set(NUM_TOTAL_CORES_USED ${NUM_PROCS_USED_IN})
543
544 endif()
545
546 set(${NUM_TOTAL_CORES_USED_OUT} ${NUM_TOTAL_CORES_USED} PARENT_SCOPE)
547 set(${SKIP_TEST_OUT} ${SKIP_TEST} PARENT_SCOPE)
548
549 endfunction()
550
551
552 # Read ${TEST_NAME_IN}_SET_DISABLED_AND_MSG and set output var
553 # <setDisabledAndMsgOut> as used by the TRIBITS_ADD[_ADVANCED]_test()
554 # functions.
555 #
556 # Usage:
557 #
558 # tribits_set_disabled_and_msg(
559 # <testName> # The full test name passed to add_test()
560 # "${PARSE_DISABLED}" # From the input arg "DISABLED <msg>" to TA[A]t()
561 # <setDisabledAndMsgOut> # Sets var of this name on output
562 # )
563 #
564 function(tribits_set_disabled_and_msg TEST_NAME_IN PARSE_DISABLED
565 SET_DISABLED_AND_MSG_OUT
566 )
567
568 set(SET_DISABLED_AND_MSG "${PARSE_DISABLED}")
569 if (NOT "${${TEST_NAME_IN}_SET_DISABLED_AND_MSG}" STREQUAL "") # Override!
570 set(SET_DISABLED_AND_MSG "${${TEST_NAME_IN}_SET_DISABLED_AND_MSG}")
571 endif()
572
573 set(${SET_DISABLED_AND_MSG_OUT} "${SET_DISABLED_AND_MSG}" PARENT_SCOPE)
574
575 endfunction()
576
577
578 # Read ${TEST_NAME_IN}_SET_RUN_SERIAL and set output var SET_RUN_SERIAL_OUT as
579 # used by the TRIBITS_ADD[_ADVANCED]_test() functions.
580 #
581 # Usage:
582 #
583 # tribits_set_run_serial(
584 # <testName> # The full test name passed to add_test()
585 # "${PARSE_RUN_SERIAL}" # From the input option "RUN_SERIAL" to TA[A]t()
586 # <setRunSerialOut> # Sets var of this name on output
587 # )
588 #
589 function(tribits_set_run_serial TEST_NAME_IN PARSE_RUN_SERIAL
590 SET_RUN_SERIAL_OUT
591 )
592
593 set(SET_RUN_SERIAL "${PARSE_RUN_SERIAL}")
594 if (NOT "${${TEST_NAME_IN}_SET_RUN_SERIAL}" STREQUAL "") # Override!
595 set(SET_RUN_SERIAL "${${TEST_NAME_IN}_SET_RUN_SERIAL}")
596 endif()
597
598 set(${SET_RUN_SERIAL_OUT} "${SET_RUN_SERIAL}" PARENT_SCOPE)
599
600 endfunction()
601
602
603 # Determine if the test should be skipped due to a disable var set
604 #
605 # Usage:
606 #
607 # tribits_add_test_query_disable(
608 # <disableThisTestVarOut> # Set var of this name on output
609 # )
610 #
611 function(tribits_add_test_query_disable DISABLE_TEST_VAR_OUT)
612
613 #message("tribits_add_test_query_disable(): ${DISABLE_TEST_VAR_OUT} ${ARGN}")
614 list(GET ARGN 0 TEST_NAME_IN)
615 set(TEST_NAME_DISABLE_VAR ${TEST_NAME_IN}_DISABLE)
616 #print_var(${TEST_NAME_DISABLE_VAR})
617 if (${TEST_NAME_DISABLE_VAR})
618 if (${PROJECT_NAME}_TRACE_ADD_TEST)
619 message_wrapper(
620 "-- ${TEST_NAME_IN}: NOT added test because ${TEST_NAME_DISABLE_VAR}='${${TEST_NAME_DISABLE_VAR}}'!")
621 endif()
622 set(${DISABLE_TEST_VAR_OUT} ON PARENT_SCOPE)
623 else()
624 set(${DISABLE_TEST_VAR_OUT} OFF PARENT_SCOPE)
625 endif()
626
627 endfunction()
628
629
630 #
631 # Determine if to disable test due to <Package>_SKIP_CTEST_ADD_TEST=ON
632 #
633 function(tribits_add_test_process_skip_ctest_add_test ADD_THE_TEST_OUT)
634 if(${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST OR ${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST)
635 if (PARENT_PACKAGE_NAME STREQUAL PACKAGE_NAME)
636 set(DISABLE_VAR_MSG
637 "${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST='${${PACKAGE_NAME}_SKIP_CTEST_ADD_TEST}'")
638 else()
639 set(DISABLE_VAR_MSG
640 "${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST='${${PARENT_PACKAGE_NAME}_SKIP_CTEST_ADD_TEST}'")
641 endif()
642 message_wrapper(
643 "-- ${TEST_NAME}: NOT added test because ${DISABLE_VAR_MSG}!")
644 set(ADD_THE_TEST FALSE)
645 else()
646 set(ADD_THE_TEST TRUE)
647 endif()
648 set(${ADD_THE_TEST_OUT} ${ADD_THE_TEST} PARENT_SCOPE)
649 endfunction()
650
651
652 #
653 # Wrapper for adding a test to facilitate unit testing
654 #
655 function(tribits_add_test_add_test TEST_NAME EXE_NAME)
656
657 string(REPLACE "${PARSE_LIST_SEPARATOR}" "\\;" args "${ARGN}")
658
659 if (TRIBITS_ADD_TEST_ADD_TEST_CAPTURE)
660 append_global_set(TRIBITS_ADD_TEST_ADD_TEST_INPUT NAME ${TEST_NAME} COMMAND ${args})
661 endif()
662
663 if (NOT TRIBITS_ADD_TEST_ADD_TEST_UNITTEST)
664 add_test(NAME ${TEST_NAME} COMMAND ${args})
665 endif()
666
667 tribits_set_tests_properties(${TEST_NAME} PROPERTIES REQUIRED_FILES ${EXE_NAME})
668
669 endfunction()
670
671
672 #
673 # Set the pass/fail properties of a test that has already been added
674 #
675
676 function(tribits_private_add_test_set_passfail_properties TEST_NAME_IN)
677
678 # PASS_REGULAR_EXPRESSION
679
680 if (PARSE_STANDARD_PASS_OUTPUT)
681 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PASS_REGULAR_EXPRESSION
682 "End Result: TEST PASSED")
683 endif()
684
685 if (PARSE_PASS_REGULAR_EXPRESSION)
686 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PASS_REGULAR_EXPRESSION
687 "${PARSE_PASS_REGULAR_EXPRESSION}")
688 endif()
689
690 if (PARSE_WILL_FAIL)
691 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES WILL_FAIL ON)
692 endif()
693
694 # FAIL_REGULAR_EXPRESSION
695
696 if (PARSE_FAIL_REGULAR_EXPRESSION)
697 tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY FAIL_REGULAR_EXPRESSION
698 "${PARSE_FAIL_REGULAR_EXPRESSION}")
699 endif()
700
701 if (${PACKAGE_NAME}_ENABLE_CIRCULAR_REF_DETECTION_FAILURE OR
702 ${PROJECT_NAME}_ENABLE_CIRCULAR_REF_DETECTION_FAILURE
703 )
704 tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY FAIL_REGULAR_EXPRESSION
705 "The following Teuchos::RCPNode objects were created")
706 # NOTE: The above string must be kept in sync with the C++ code!
707 endif()
708 # ToDo: Make a variable ${PROJECT_NAME}_EXTRA_FAIL_REGULAR_EXPRESSION and
709 # move the above logic to Trilinos somehow.
710
711 endfunction()
712
713
714 #
715 # Set the timeout for a test already added
716 #
717 function(tribits_private_add_test_set_timeout TEST_NAME_IN TIMEOUT_USED_OUT)
718
719 if (PARSE_TIMEOUT)
720 tribits_scale_timeout("${PARSE_TIMEOUT}" TIMEOUT_USED)
721 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES TIMEOUT ${TIMEOUT_USED})
722 else()
723 set(TIMEOUT_USED "")
724 endif()
725
726 set(${TIMEOUT_USED_OUT} ${TIMEOUT_USED} PARENT_SCOPE)
727
728 endfunction()
729
730
731 #
732 # Set the environment for a test already added
733 #
734 function(tribits_private_add_test_set_environment TEST_NAME_IN)
735
736 if (PARSE_ENVIRONMENT)
737 string(REPLACE "${PARSE_LIST_SEPARATOR}" "\\;" PARSE_ENVIRONMENT
738 "${PARSE_ENVIRONMENT}")
739 tribits_set_test_property(${TEST_NAME_IN} PROPERTY ENVIRONMENT
740 "${PARSE_ENVIRONMENT}")
741 endif()
742
743 endfunction()
744
745
746 #
747 # Set the environment for a test already added
748 #
749 function(tribits_private_add_test_set_processors TEST_NAME_IN
750 NUM_TOTAL_CORES_USED_IN PROCESSORS_OUT
751 )
752
753 set(PROCESSORS_USED ${NUM_TOTAL_CORES_USED_IN})
754
755 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES PROCESSORS
756 "${PROCESSORS_USED}")
757
758 set(${PROCESSORS_OUT} ${PROCESSORS_USED} PARENT_SCOPE)
759
760 endfunction()
761
762
763 # Print test added message!
764 #
765 function(tribits_private_add_test_print_added TEST_NAME_IN CATEGORIES_IN
766 NUM_MPI_PROCS_IN PROCESSORS_IN TIMEOUT_IN RUN_SERIAL_IN DISABLED_MSG_IN
767 )
768
769 set(ADDED_TEST_PROPS "")
770 tribits_get_categories_string("${CATEGORIES_IN}" CATEGORIES_IN_COMMAS)
771 append_string_var_with_sep(ADDED_TEST_PROPS
772 ", " "${CATEGORIES_IN_COMMAS}")
773 if (NUM_MPI_PROCS_IN AND TPL_ENABLE_MPI)
774 append_string_var_with_sep(ADDED_TEST_PROPS
775 ", " "NUM_MPI_PROCS=${NUM_MPI_PROCS_IN}")
776 endif()
777 if (PROCESSORS_IN)
778 append_string_var_with_sep(ADDED_TEST_PROPS
779 ", " "PROCESSORS=${PROCESSORS_IN}")
780 endif()
781 if (TIMEOUT_IN)
782 append_string_var_with_sep(ADDED_TEST_PROPS
783 ", " "TIMEOUT=${TIMEOUT_IN}")
784 endif()
785
786 if (RUN_SERIAL_IN)
787 append_string_var_with_sep(ADDED_TEST_PROPS
788 ", " "RUN_SERIAL")
789 endif()
790
791 if (DISABLED_MSG_IN)
792 append_string_var_with_sep(ADDED_TEST_PROPS
793 ", " "DISABLED")
794 endif()
795
796 if (ADDED_TEST_PROPS)
797 set(ADDED_TEST_PROPS " (${ADDED_TEST_PROPS})")
798 endif()
799
800 if (${PROJECT_NAME}_TRACE_ADD_TEST)
801 message_wrapper("-- ${TEST_NAME_IN}: Added test${ADDED_TEST_PROPS}!")
802 if (DISABLED_MSG_IN)
803 message_wrapper("-- => Reason DISABLED: ${DISABLED_MSG_IN}")
804 endif()
805 endif()
806
807 endfunction()
808
809
810 # Overall add test command
811 #
812 # NOTE: Pass the command arguments on the end in ARGSN.
813 #
814 function(tribits_add_test_add_test_all TEST_NAME_IN
815 EXECUTABLE_PATH_IN CATEGORIES_IN NUM_PROCS_USED_IN NUM_TOTAL_CORES_USED_IN
816 RUN_SERIAL_IN DISABLED_MSG_IN
817 ADDED_TEST_NAME_OUT
818 )
819
820 tribits_add_test_get_test_cmnd_array( CMND_ARRAY
821 "${EXECUTABLE_PATH_IN}" "${NUM_PROCS_USED_IN}" ${ARGN} )
822
823 tribits_add_test_query_disable(DISABLE_THIS_TEST ${TEST_NAME_IN})
824
825 if (NOT DISABLE_THIS_TEST)
826
827 tribits_add_test_add_test(${TEST_NAME_IN} ${EXECUTABLE_PATH_IN} ${CMND_ARRAY})
828 set(${ADDED_TEST_NAME_OUT} ${TEST_NAME_IN} PARENT_SCOPE)
829
830 tribits_private_add_test_post_process_added_test(${TEST_NAME_IN}
831 "${CATEGORIES_IN}" ${NUM_PROCS_USED_IN} "${NUM_TOTAL_CORES_USED_IN}"
832 "${RUN_SERIAL_IN}" "${DISABLED_MSG_IN}")
833
834 else()
835
836 set(${ADDED_TEST_NAME_OUT} "" PARENT_SCOPE)
837
838 endif()
839
840 endfunction()
841
842
843 # Set the label and keywords
844 #
845 function(tribits_private_add_test_add_label_and_keywords TEST_NAME_IN)
846
847 tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY
848 LABELS ${PARENT_PACKAGE_NAME})
849
850 if(PARSE_KEYWORDS)
851 tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY
852 LABELS ${PARSE_KEYWORDS})
853 endif()
854
855 endfunction()
856
857
858 # Postprocess a test that was added
859 #
860 function(tribits_private_add_test_post_process_added_test TEST_NAME_IN
861 CATEGORIES_IN NUM_PROCS_USED_IN NUM_TOTAL_CORES_USED_IN
862 RUN_SERIAL_IN DISABLED_MSG_IN
863 )
864
865 tribits_private_add_test_set_passfail_properties(${TEST_NAME_IN})
866 tribits_private_add_test_set_environment(${TEST_NAME_IN})
867 tribits_private_add_test_set_processors(${TEST_NAME_IN}
868 "${NUM_TOTAL_CORES_USED_IN}" PROCESSORS_USED)
869 tribits_private_add_test_set_timeout(${TEST_NAME_IN} TIMEOUT_USED)
870
871 if(RUN_SERIAL_IN)
872 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES RUN_SERIAL ON)
873 endif()
874
875 if(DISABLED_MSG_IN)
876 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES DISABLED ON)
877 endif()
878
879 tribits_private_add_test_add_environment_and_resource(${TEST_NAME_IN}
880 ${NUM_PROCS_USED_IN})
881
882 tribits_private_add_test_add_label_and_keywords(${TEST_NAME_IN})
883
884 tribits_private_add_test_print_added(${TEST_NAME_IN}
885 "${CATEGORIES_IN}" "${NUM_PROCS_USED_IN}" "${PROCESSORS_USED}"
886 "${TIMEOUT_USED}" "${RUN_SERIAL_IN}" "${DISABLED_MSG_IN}")
887
888 endfunction()
889
890
891 # Add environment and resource properties to a test
892 #
893 function(tribits_private_add_test_add_environment_and_resource TEST_NAME_IN
894 NUM_PROCS_USED_IN
895 )
896 if(TRIBITS_TEST_EXTRA_ENVIRONMENT)
897 tribits_set_test_property(${TEST_NAME_IN} APPEND PROPERTY ENVIRONMENT
898 "${TRIBITS_TEST_EXTRA_ENVIRONMENT}")
899 endif()
900
901 if(TRIBITS_RESOURCES_PER_PROCESS)
902 set(NUM_PROCESSES ${NUM_PROCS_USED_IN})
903 if(NOT NUM_PROCESSES OR NUM_PROCESSES LESS 1)
904 set(NUM_PROCESSES 1)
905 endif()
906 tribits_set_tests_properties(${TEST_NAME_IN} PROPERTIES RESOURCE_GROUPS
907 "${NUM_PROCESSES},${TRIBITS_RESOURCES_PER_PROCESS}")
908 endif()
909 endfunction()