Use SOURCES keyword for source files in EkatCreateUnitTestExec

cmake/EkatCreateUnitTest.cmake

@@ -4,6 +4,7 @@ include(EkatUtils) # To check macro args
 set(CUT_EXEC_OPTIONS EXCLUDE_MAIN_CPP USER_DEFINED_TEST_SESSION)
 set(CUT_EXEC_1V_ARGS)
 set(CUT_EXEC_MV_ARGS
+  SOURCES
   INCLUDE_DIRS
   COMPILER_DEFS
   COMPILER_C_DEFS COMPILER_CXX_DEFS COMPILER_F_DEFS
@@ -29,16 +30,16 @@ set(CUT_TEST_MV_ARGS DEP EXE_ARGS MPI_RANKS THREADS LABELS PROPERTIES
 
 # This function takes the following mandatory arguments:
 #    - exec_name: the name of the test executable that will be created.
-#    - exec_srcs: a list of src files for the executable.
-#      Note: no need to include ekat_catch_main.cpp; this macro will add it (if needed).
-# The following optional arguments can be passed as ARG_NAME "ARG_VAL":
+# The following keyword arguments can be passed as ARG_NAME ARG_VAL.
+# Note: all these arguments are optional EXCEPT for the SOURCES arg, which is required.
+#    - SOURCES: a list of src files for the executable.
 #    - INCLUDE_DIRS: a list of directories to add to the include search path
 #    - COMPILE_[C_|CXX_|F_]DEFS: a list of additional (possibly language-specific) defines for the compiler
 #    - COMPILER_[C_|CXX_|F_]FLAGS: a list of additional flags (possibly language-specific) for the compiler
 #    - LIBS: a list of libraries needed by the executable (i.e., libs/targets to link against)
 #    - LIBS_DIRS: a list of directories to add to the linker search path
 #    - LINKER_FLAGS: a list of additional flags for the linker
-function(EkatCreateUnitTestExec exec_name exec_srcs)
+function(EkatCreateUnitTestExec exec_name)
   #---------------------------#
   #   Parse function inputs   #
   #---------------------------#
@@ -58,7 +59,10 @@ function(EkatCreateUnitTestExec exec_name exec_srcs)
   #-------------------------------------------------#
 
   set(target_name ${exec_name})
-  add_executable(${target_name} ${exec_srcs})
+  if (NOT ecute_SOURCES)
+    message (FATAL_ERROR "Target ${target_name} created without specifying the SOURCES arg")
+  endif()
+  add_executable(${target_name} ${ecute_SOURCES})
 
   #---------------------------#
   # Set all target properties #
@@ -78,7 +82,7 @@ function(EkatCreateUnitTestExec exec_name exec_srcs)
     )
 
   # Check if we need a Fortran modules folder
-  foreach (file ${exec_srcs})
+  foreach (file ${ecute_SOURCES})
     get_filename_component(ext ${file} EXT)
     string(REGEX REPLACE "^\\." "" ext ${ext})
 
@@ -429,7 +433,7 @@ endfunction(EkatCreateUnitTestFromExec)
 # This function combines the two above, to create an executable, and use it
 # to create a suite of unit tests. The optional arguments are the union of
 # the optional arguments of the two functions above
-function(EkatCreateUnitTest test_name test_srcs)
+function(EkatCreateUnitTest test_name)
   set(options ${CUT_EXEC_OPTIONS} ${CUT_TEST_OPTIONS})
   set(oneValueArgs ${CUT_EXEC_1V_ARGS} ${CUT_TEST_1V_ARGS})
   set(multiValueArgs ${CUT_EXEC_MV_ARGS} ${CUT_TEST_MV_ARGS})
@@ -443,7 +447,7 @@ function(EkatCreateUnitTest test_name test_srcs)
   #------------------------------#
 
   separate_cut_arguments(ecut "${CUT_EXEC_OPTIONS}" "${CUT_EXEC_1V_ARGS}" "${CUT_EXEC_MV_ARGS}" options_ExecPhase)
-  EkatCreateUnitTestExec("${test_name}" "${test_srcs}" ${options_ExecPhase})
+  EkatCreateUnitTestExec("${test_name}" ${options_ExecPhase})
 
   #------------------------------#
   #      Create Tests Phase      #

cmake/EkatCreateUnitTestWithAsserts.cmake

@@ -54,7 +54,7 @@ function(EkatCreateUnitTestWithAsserts test_base_name test_meta_src)
   # stripped, which is *not* supposed to fail
   EkatCreateUnitTest(
     ${test_base_name}
-    ${CMAKE_CURRENT_BINARY_DIR}/${base_src}.cpp
+    SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${base_src}.cpp
     ${ARGN}
   )
 
@@ -69,7 +69,7 @@ function(EkatCreateUnitTestWithAsserts test_base_name test_meta_src)
   foreach (N RANGE 1 ${OUT})
     EkatCreateUnitTest(
       ${test_base_name}_check_assert_${N}
-      ${CMAKE_CURRENT_BINARY_DIR}/${base_src}_${N}.cpp
+      SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${base_src}_${N}.cpp
       WILL_FAIL
       ${ARGN}
     )

tests/algorithm/CMakeLists.txt

@@ -1,39 +1,37 @@
 include(EkatCreateUnitTest)
 
 # Test linear interpolation
-set (LIN_INTERP_SRCS
-  lin_interp_test.cpp
-)
-
 if (EKAT_TEST_DOUBLE_PRECISION)
-  EkatCreateUnitTest(lin_interp${DP_POSTFIX} "${LIN_INTERP_SRCS}"
+  EkatCreateUnitTest(lin_interp${DP_POSTFIX}
+    SOURCES lin_interp_test.cpp
     LIBS ekat::Algorithm
     COMPILER_DEFS EKAT_TEST_DOUBLE_PRECISION
     THREADS 1 ${EKAT_TEST_MAX_THREADS} ${EKAT_TEST_THREAD_INC})
 endif()
 if (EKAT_TEST_SINGLE_PRECISION)
-  EkatCreateUnitTest(lin_interp${SP_POSTFIX} "${LIN_INTERP_SRCS}"
+  EkatCreateUnitTest(lin_interp${SP_POSTFIX}
+    SOURCES lin_interp_test.cpp
     LIBS ekat::Algorithm
     COMPILER_DEFS EKAT_TEST_SINGLE_PRECISION
     THREADS 1 ${EKAT_TEST_MAX_THREADS} ${EKAT_TEST_THREAD_INC})
 endif()
 
 # Test tridiag solver
-set (TRIDIAG_SRCS
-  tridiag_tests.cpp
-  tridiag_tests_correctness.cpp
-  tridiag_tests_performance.cpp
-)
-
 if (EKAT_TEST_DOUBLE_PRECISION)
-  EkatCreateUnitTest(tridiag${DP_POSTFIX} "${TRIDIAG_SRCS}"
+  EkatCreateUnitTest(tridiag${DP_POSTFIX}
+    SOURCES tridiag_tests.cpp
+            tridiag_tests_correctness.cpp
+            tridiag_tests_performance.cpp
     LIBS ekat::Algorithm
     COMPILER_DEFS EKAT_TEST_DOUBLE_PRECISION
     THREADS ${EKAT_TEST_MAX_THREADS}
     EXCLUDE_MAIN_CPP)
 endif()
 if (EKAT_TEST_SINGLE_PRECISION)
-  EkatCreateUnitTest(tridiag${SP_POSTFIX} "${TRIDIAG_SRCS}"
+  EkatCreateUnitTest(tridiag${SP_POSTFIX}
+    SOURCES tridiag_tests.cpp
+            tridiag_tests_correctness.cpp
+            tridiag_tests_performance.cpp
     LIBS ekat::Algorithm
     COMPILER_DEFS EKAT_TEST_SINGLE_PRECISION
     THREADS ${EKAT_TEST_MAX_THREADS}
@@ -42,25 +40,29 @@ endif()
 
 # Check that the tridiags main returns nonzero if invalid flags are passed
 if (EKAT_TEST_SINGLE_PRECISION)
-  set (invalid_flags_exec tridiag${SP_POSTFIX})
+  EkatCreateUnitTestFromExec(tridiag_invalid_flags tridiag${SP_POSTFIX}
+    EXE_ARGS "--non-existent-flag"
+    LABELS "MustFail"
+    WILL_FAIL
+  )
 else()
-  set (invalid_flags_exec tridiag${DP_POSTFIX})
+  EkatCreateUnitTestFromExec(tridiag_invalid_flags tridiag${DP_POSTFIX}
+    EXE_ARGS "--non-existent-flag"
+    LABELS "MustFail"
+    WILL_FAIL
+  )
 endif()
 
-EkatCreateUnitTestFromExec(tridiag_invalid_flags ${invalid_flags_exec}
-  EXE_ARGS "--non-existent-flag"
-  LABELS "MustFail"
-  WILL_FAIL
-)
-
 # Test reduction utilities
 if (EKAT_TEST_DOUBLE_PRECISION)
-  EkatCreateUnitTest(reduction${DP_POSTFIX} reduction_tests.cpp
+  EkatCreateUnitTest(reduction${DP_POSTFIX}
+    SOURCES reduction_tests.cpp
     COMPILER_DEFS EKAT_TEST_DOUBLE_PRECISION
     LIBS ekat::Algorithm)
 endif()
 if (EKAT_TEST_SINGLE_PRECISION)
-  EkatCreateUnitTest(reduction${SP_POSTFIX} reduction_tests.cpp
+  EkatCreateUnitTest(reduction${SP_POSTFIX}
+    SOURCES reduction_tests.cpp
     COMPILER_DEFS EKAT_TEST_SINGLE_PRECISION
     LIBS ekat::Algorithm)
 endif()

tests/core/CMakeLists.txt

@@ -1,7 +1,8 @@
 include(EkatCreateUnitTest)
 
 # Test debug tools
-EkatCreateUnitTest(debug_tools debug_tools_tests.cpp
+EkatCreateUnitTest(debug_tools
+  SOURCES debug_tools_tests.cpp
   LIBS ekat::Core)
 
 # Test the framework that checks asserts
@@ -13,7 +14,8 @@ if (EKAT_IS_DEBUG_BUILD)
 endif()
 
 # Ensure that FPE *do* throw when we expect them to
-EkatCreateUnitTestExec (fpe_check "fpe_check.cpp")
+EkatCreateUnitTestExec (fpe_check
+  SOURCES fpe_check.cpp)
 if (EKAT_ENABLE_FPE_DEFAULT_MASK)
   EkatCreateUnitTestFromExec (fpe_check fpe_check
     WILL_FAIL
@@ -23,14 +25,16 @@ else()
 endif()
 
 # Test catch main options
-EkatCreateUnitTest (catch_main_tests catch_main_tests.cpp
+EkatCreateUnitTest (catch_main_tests
+  SOURCES catch_main_tests.cpp
   EXE_ARGS "--args -a 1 --b 2 3 -c=4,5 --d 6,7 -K -foo --bar"
   PROPERTIES PASS_REGULAR_EXPRESSION
   ".*flags: K bar foo, params: a=1, vec_params: a=1 b=2,3 c=4,5 d=6,7")
 
 # Test that failure are indeed spotted. Also, verify that redirection
 # of input is not parsed as test filter, by fwding a file
-EkatCreateUnitTest(regress_fail regress_fail.cpp
+EkatCreateUnitTest(regress_fail
+  SOURCES regress_fail.cpp
   LIBS ekat::Core
   EXE_ARGS " < CTestTestfile.cmake"
   WILL_FAIL
@@ -46,36 +50,44 @@ EkatCreateUnitTestFromExec(catch_main_invalid_flags regress_fail
 
 # Comm tests
 if (EKAT_ENABLE_MPI)
-  EkatCreateUnitTest(comm comm.cpp
+  EkatCreateUnitTest(comm
+    SOURCES comm.cpp
     LIBS ekat::Core
     MPI_RANKS 1 ${EKAT_TEST_MAX_RANKS}
   )
 endif()
 
 # Test units framework
-EkatCreateUnitTest(units units.cpp
+EkatCreateUnitTest(units
+  SOURCES units.cpp
   LIBS ekat::Core)
 
 # Test meta utilities
-EkatCreateUnitTest(meta_utils meta_utils.cpp
+EkatCreateUnitTest(meta_utils
+  SOURCES meta_utils.cpp
   LIBS ekat::Core)
 
 # Test parameter list
-EkatCreateUnitTest(parameter_list parameter_list.cpp
+EkatCreateUnitTest(parameter_list
+  SOURCES parameter_list.cpp
   LIBS ekat::Core)
 
 # Test type traits
-EkatCreateUnitTest(type_traits_utils type_traits_utils.cpp
+EkatCreateUnitTest(type_traits_utils
+  SOURCES type_traits_utils.cpp
   LIBS ekat::Core)
 
 # Test string utilities
-EkatCreateUnitTest(string_utils string_utils.cpp
+EkatCreateUnitTest(string_utils
+  SOURCES string_utils.cpp
   LIBS ekat::Core)
 
 # Test factory
-EkatCreateUnitTest(factory factory.cpp
+EkatCreateUnitTest(factory
+  SOURCES factory.cpp
   LIBS ekat::Core)
 
 # Test zip utility
-EkatCreateUnitTest(zip zip.cpp
+EkatCreateUnitTest(zip
+  SOURCES zip.cpp
   LIBS ekat::Core)

tests/expression/CMakeLists.txt

@@ -1,5 +1,6 @@
 include(EkatCreateUnitTest)
 
 # Test expression templates
-EkatCreateUnitTest(expressions expressions.cpp
+EkatCreateUnitTest(expressions
+  SOURCES expressions.cpp
   LIBS ekat::Expression)

tests/kokkos/CMakeLists.txt

@@ -1,27 +1,33 @@
 include(EkatCreateUnitTest)
 
 # Test upper_bound
-EkatCreateUnitTest(upper_bound upper_bound.cpp
+EkatCreateUnitTest(upper_bound
+  SOURCES upper_bound.cpp
   LIBS ekat::KokkosUtils)
 
 # Test math utils
-EkatCreateUnitTest(math_utils math_utils.cpp
+EkatCreateUnitTest(math_utils
+  SOURCES math_utils.cpp
   LIBS ekat::KokkosUtils)
 
 # Test view utils
-EkatCreateUnitTest(view_utils view_utils.cpp
+EkatCreateUnitTest(view_utils
+  SOURCES view_utils.cpp
   LIBS ekat::KokkosUtils)
 
 # Test view broadcast
-EkatCreateUnitTest(view_broadcast view_broadcast.cpp
+EkatCreateUnitTest(view_broadcast
+  SOURCES view_broadcast.cpp
   LIBS ekat::KokkosUtils)
 
 # Test subview utils
-EkatCreateUnitTest(subview_utils subview_utils.cpp
+EkatCreateUnitTest(subview_utils
+  SOURCES subview_utils.cpp
   LIBS ekat::KokkosUtils)
 
 # Test team policy utils
-EkatCreateUnitTest(team_policy_utils team_policy_utils.cpp
+EkatCreateUnitTest(team_policy_utils
+  SOURCES team_policy_utils.cpp
   LIBS ekat::KokkosUtils
   PRINT_OMP_AFFINITY
   THREADS 1 ${EKAT_TEST_MAX_THREADS} ${EKAT_TEST_THREAD_INC}
@@ -37,17 +43,20 @@ else ()
   set (thr_inc ${EKAT_TEST_THREAD_INC})
 endif()
 
-EkatCreateUnitTest(workspace_mgr workspace_mgr.cpp
+EkatCreateUnitTest(workspace_mgr
+  SOURCES workspace_mgr.cpp
   LIBS ekat::KokkosUtils
   PRINT_OMP_AFFINITY
   THREADS 1 ${max_thr} ${thr_inc})
 
 if (Kokkos_ENABLE_CUDA AND Kokkos_ENABLE_CUDA_UVM)
   # Test ability to move a kernel to host
-  EkatCreateUnitTest (kernel_on_host kernel_on_host.cpp
+  EkatCreateUnitTest (kernel_on_host
+    SOURCES kernel_on_host.cpp
     LIBS ekat::KokkosUtils)
 endif()
 
 # Test the where construct (for scalar types)
-EkatCreateUnitTest(where where.cpp
+EkatCreateUnitTest(where
+  SOURCES where.cpp
   LIBS ekat::KokkosUtils)

tests/logging/CMakeLists.txt

@@ -1,10 +1,12 @@
 include(EkatCreateUnitTest)
 
 # Test basic logger capabilities
-EkatCreateUnitTest(serial_file_log serial_file_log_tests.cpp
+EkatCreateUnitTest(serial_file_log
+  SOURCES serial_file_log_tests.cpp
   LIBS ekat::Logging)
 
-EkatCreateUnitTest(mpi_file_log_tests mpi_file_log_tests.cpp
+EkatCreateUnitTest(mpi_file_log_tests
+  SOURCES mpi_file_log_tests.cpp
   LIBS ekat::Logging
   MPI_RANKS 1 ${EKAT_TEST_MAX_RANKS}
   PROPERTIES FAIL_REGULAR_EXPRESSION "rank1"
@@ -22,7 +24,8 @@ foreach(RANK RANGE 1 ${EKAT_TEST_MAX_RANKS})
   endif()
 endforeach()
 
-EkatCreateUnitTest(console_only_log console_only_log_tests.cpp
+EkatCreateUnitTest(console_only_log
+  SOURCES console_only_log_tests.cpp
   LIBS ekat::Logging
   MPI_RANKS ${EKAT_TEST_MAX_RANKS}
   PROPERTIES PASS_REGULAR_EXPRESSION ${pass}