testing: Teach test helper functions to add both Serial and MPI tests

testing/CMakeLists.txt

@@ -10,27 +10,23 @@ if(ADIOS2_HAVE_MPI)
   mark_as_advanced(MPIEXEC_EXTRA_FLAGS)
   separate_arguments(MPIEXEC_EXTRA_FLAGS)
 
-  set(NUM_TEST_PROCS ${MPIEXEC_MAX_NUMPROCS})
   set(MPIEXEC_COMMAND
     ${MPIEXEC_EXECUTABLE} ${MPIEXEC_EXTRA_FLAGS}
-    ${MPIEXEC_NUMPROC_FLAG} ${NUM_TEST_PROCS}
+    ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS}
   )
-  set(test_mpi TRUE)
-else()
-  set(NUM_TEST_PROCS 1)
-  set(test_mpi FALSE)
 endif()
 
 include(GoogleTest)
 # gtest_add_tests_helper:
 # Create a wrapper around gtest_add_tests that uses common patterns for test
 # names, execurtable names, mpi usage, etc.
-# 
+#
 # Arguments:
 #   testname - The basename of the test file
-#   mpi      - TRUE - build with MPI, execute with mpiexec
-#              FALSE - no mpi
-#              NOEXEC - build with MPI but don't execute with MPI
+#   mpi      - MPI_ALLOW - build MPI test, execute with mpiexec; also build Serial test
+#              MPI_NONE - build Serial test only
+#              MPI_ONLY - build MPI test only, execute with mpiexec
+#              MPI_NOEXEC - build MPI test, execute without MPI; also build Serial test
 #   src_pfx  - Source filename prefix, Test${src_pfs}${testname}.cpp
 #   tst_pfx  - Test name prefix to be added to CTest
 #   tst_sfx  - Test name suffix to be added to CTest
@@ -40,39 +36,62 @@ include(GoogleTest)
 #   You have a gtest file, TestFooThings.cpp that containst Test1 and Test2
 #   gtest functions that can be called with different sets of arguments.
 #
-#     gtest_add_tests_helper(Things TRUE Foo Foo. .Bar EXTRA_ARGS "Bar")
-#     gtest_add_tests_helper(Things TRUE Foo Foo. .Baz EXTRA_ARGS "Baz")
+#     gtest_add_tests_helper(Things MPI_ALLOW Foo Foo. .Bar EXTRA_ARGS "Bar")
+#     gtest_add_tests_helper(Things MPI_ALLOW Foo Foo. .Baz EXTRA_ARGS "Baz")
 #
 #  will create the executable Test.Foo.Things and add the tests
-#    Foo.Things.Test1.Bar
-#    Foo.Things.Test2.Bar
-#    Foo.Things.Test1.Baz
-#    Foo.Things.Test2.Baz
+#    Foo.Things.Test1.Bar.Serial
+#    Foo.Things.Test1.Bar.MPI
+#    Foo.Things.Test2.Bar.Serial
+#    Foo.Things.Test2.Bar.MPI
+#    Foo.Things.Test1.Baz.Serial
+#    Foo.Things.Test1.Baz.MPI
+#    Foo.Things.Test2.Baz.Serial
+#    Foo.Things.Test2.Baz.MPI
 #
 function(gtest_add_tests_helper testname mpi src_pfx tst_pfx tst_sfx)
-  set(tgt Test.${tst_pfx}${testname})
-  if(NOT TARGET ${tgt})
-    add_executable(${tgt} Test${src_pfx}${testname}.cpp)
-    if(mpi)
-      target_link_libraries(${tgt} adios2::cxx11_mpi adios2::c_mpi adios2_core_mpi MPI::MPI_C)
-    else()
-      target_link_libraries(${tgt} adios2::cxx11 adios2::c adios2_core)
-    endif()
-    target_link_libraries(${tgt} gtest)
+  set(test_targets "")
+  if(NOT mpi MATCHES "^MPI_(ALLOW|NONE|ONLY|NOEXEC)$")
+    message(FATAL_ERROR "Invalid mpi argument value '${mpi}'.")
   endif()
-  if(mpi AND NOT mpi STREQUAL "NOEXEC")
-    gtest_add_tests(TARGET ${tgt}
-      TEST_PREFIX "${tst_pfx}" TEST_SUFFIX "${tst_sfx}"
-      EXEC_WRAPPER ${MPIEXEC_COMMAND} TEST_LIST added_tests
-      ${ARGN}
-    )
-    set_tests_properties(${added_tests} PROPERTIES PROCESSORS ${NUM_TEST_PROCS})
-  else()
+  if(NOT mpi STREQUAL "MPI_ONLY")
+    set(tgt Test.${tst_pfx}${testname}.Serial)
+    list(APPEND test_targets "${tgt}")
+    if(NOT TARGET ${tgt})
+      add_executable(${tgt} Test${src_pfx}${testname}.cpp)
+      target_link_libraries(${tgt} adios2::cxx11 adios2::c adios2_core gtest)
+    endif()
     gtest_add_tests(TARGET ${tgt}
-      TEST_PREFIX "${tst_pfx}" TEST_SUFFIX "${tst_sfx}"
+      TEST_PREFIX "${tst_pfx}"
+      TEST_SUFFIX "${tst_sfx}.Serial"
       ${ARGN}
     )
   endif()
+  if(ADIOS2_HAVE_MPI AND NOT mpi STREQUAL "MPI_NONE")
+    set(tgt Test.${tst_pfx}${testname}.MPI)
+    list(APPEND test_targets "${tgt}")
+    if(NOT TARGET ${tgt})
+      add_executable(${tgt} Test${src_pfx}${testname}.cpp)
+      target_link_libraries(${tgt} adios2::cxx11_mpi adios2::c_mpi adios2_core_mpi MPI::MPI_C gtest)
+    endif()
+    if(NOT mpi STREQUAL "MPI_NOEXEC")
+      gtest_add_tests(TARGET ${tgt}
+        TEST_PREFIX "${tst_pfx}"
+        TEST_SUFFIX "${tst_sfx}.MPI"
+        EXEC_WRAPPER ${MPIEXEC_COMMAND}
+        TEST_LIST added_tests
+        ${ARGN}
+        )
+      set_tests_properties(${added_tests} PROPERTIES PROCESSORS "${MPIEXEC_MAX_NUMPROCS}")
+    else()
+      gtest_add_tests(TARGET ${tgt}
+        TEST_PREFIX "${tst_pfx}"
+        TEST_SUFFIX "${tst_sfx}.MPI"
+        ${ARGN}
+        )
+    endif()
+  endif()
+  set("Test.${tst_pfx}${testname}-TARGETS" "${test_targets}" PARENT_SCOPE)
 endfunction()
 
 add_subdirectory(adios2)

testing/adios2/bindings/C/CMakeLists.txt

@@ -3,15 +3,7 @@
 # accompanying file Copyright.txt for details.
 #------------------------------------------------------------------------------#
 
-if(ADIOS2_HAVE_MPI)
-  set(mpi TRUE)
-else()
-  set(mpi FALSE)
-endif()
-
-gtest_add_tests_helper(WriteTypes ${mpi} BP Bindings.C. "")
-gtest_add_tests_helper(WriteReadMultiblock ${mpi} BP Bindings.C. "")
-gtest_add_tests_helper(NullWriteRead ${mpi} "" Bindings.C. "")
-if(mpi)
-  gtest_add_tests_helper(WriteAggregateReadLocal TRUE BP Bindings.C. "")
-endif()
+gtest_add_tests_helper(WriteTypes MPI_ALLOW BP Bindings.C. "")
+gtest_add_tests_helper(WriteReadMultiblock MPI_ALLOW BP Bindings.C. "")
+gtest_add_tests_helper(NullWriteRead MPI_ALLOW "" Bindings.C. "")
+gtest_add_tests_helper(WriteAggregateReadLocal MPI_ONLY BP Bindings.C. "")

testing/adios2/bindings/fortran/CMakeLists.txt

@@ -4,73 +4,58 @@
 #------------------------------------------------------------------------------#
 
 macro(fortran_add_test_helper testname mpi)
+  set(test_targets "")
+  if(NOT "${mpi}" MATCHES "^MPI_(ALLOW|ONLY|NONE)$")
+    message(FATAL_ERROR "Invalid mpi argument value '${mpi}'.")
+  endif()
   set(pfx Bindings.Fortran.)
-  set(tgt Test.${pfx}${testname})
-  add_executable(${tgt} Test${testname}.F90)
-  set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran)
-  if(mpi)
+  if(NOT "${mpi}" STREQUAL "MPI_ONLY")
+    set(tgt Test.${pfx}${testname}.Serial)
+    list(APPEND test_targets "${tgt}")
+    add_executable(${tgt} Test${testname}.F90)
+    set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran)
+    target_link_libraries(${tgt} adios2::fortran)
+    add_test(
+      NAME ${pfx}${testname}.Serial
+      COMMAND ${tgt}
+    )
+  endif()
+  if(ADIOS2_HAVE_MPI AND NOT "${mpi}" STREQUAL "MPI_NONE")
+    set(tgt Test.${pfx}${testname}.MPI)
+    list(APPEND test_targets "${tgt}")
+    add_executable(${tgt} Test${testname}.F90)
+    set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran)
     target_link_libraries(${tgt} adios2::fortran_mpi MPI::MPI_Fortran)
-    add_test(NAME ${pfx}${testname}
+    add_test(
+      NAME ${pfx}${testname}.MPI
       COMMAND ${MPIEXEC_COMMAND} $<TARGET_FILE:${tgt}>
     )
-    set_tests_properties(${pfx}${testname} PROPERTIES
-      PROCESSORS ${NUM_TEST_PROCS}
+    set_tests_properties(${pfx}${testname}.MPI PROPERTIES
+      PROCESSORS "${MPIEXEC_MAX_NUMPROCS}"
     )
-  else()
-    target_link_libraries(${tgt} adios2::fortran)
-    add_test(NAME ${pfx}${testname} COMMAND ${tgt})
   endif()
+  set("Test.${pfx}${testname}-TARGETS" "${test_targets}")
 endmacro()
 
-if(ADIOS2_HAVE_MPI)
-  set(mpi TRUE)
-else()
-  set(mpi FALSE)
-endif()
-
-add_library(SmallTestData_f OBJECT SmallTestData_mod.F90)
-add_library(ISmallTestData_f INTERFACE)
-target_sources(ISmallTestData_f INTERFACE $<TARGET_OBJECTS:SmallTestData_f>)
-
-fortran_add_test_helper(BPWriteTypes ${mpi})
-target_link_libraries(Test.Bindings.Fortran.BPWriteTypes ISmallTestData_f)
-
-fortran_add_test_helper(Remove ${mpi})
-target_link_libraries(Test.Bindings.Fortran.Remove ISmallTestData_f)
-
-if(mpi)
-  fortran_add_test_helper(Adios2BindingsFortranIO TRUE)
-
-  fortran_add_test_helper(BPWriteReadAttributes TRUE)
-  target_link_libraries(Test.Bindings.Fortran.BPWriteReadAttributes
-    ISmallTestData_f
-  )
-
-  fortran_add_test_helper(BPWriteVariableAttributes TRUE) 
-  target_link_libraries(Test.Bindings.Fortran.BPWriteVariableAttributes
-    ISmallTestData_f
-  )
+fortran_add_test_helper(BPWriteTypes MPI_ALLOW)
+fortran_add_test_helper(Remove MPI_ALLOW)
 
-  fortran_add_test_helper(BPWriteTypesByName TRUE)
-  target_link_libraries(Test.Bindings.Fortran.BPWriteTypesByName
-    ISmallTestData_f
-  )
-
-  fortran_add_test_helper(BPWriteTypesLocal TRUE)
-  target_link_libraries(Test.Bindings.Fortran.BPWriteTypesLocal
-    ISmallTestData_f
-  )
-
-  fortran_add_test_helper(BPWriteReadHeatMap2D TRUE)
-  fortran_add_test_helper(BPWriteReadHeatMap3D TRUE)
-  fortran_add_test_helper(BPWriteReadHeatMap4D TRUE)
-  fortran_add_test_helper(BPWriteReadHeatMap5D TRUE)
-  fortran_add_test_helper(BPWriteReadHeatMap6D TRUE)
-  fortran_add_test_helper(BPReadGlobalsByName TRUE)
-  fortran_add_test_helper(BPWriteMemorySelectionRead2D TRUE)
-  fortran_add_test_helper(BPWriteMemorySelectionRead3D TRUE)
-  fortran_add_test_helper(NullEngine TRUE)
+fortran_add_test_helper(Adios2BindingsFortranIO MPI_ONLY)
+fortran_add_test_helper(BPWriteReadAttributes MPI_ONLY)
+fortran_add_test_helper(BPWriteVariableAttributes MPI_ONLY)
+fortran_add_test_helper(BPWriteTypesByName MPI_ONLY)
+fortran_add_test_helper(BPWriteTypesLocal MPI_ONLY)
+fortran_add_test_helper(BPWriteReadHeatMap2D MPI_ONLY)
+fortran_add_test_helper(BPWriteReadHeatMap3D MPI_ONLY)
+fortran_add_test_helper(BPWriteReadHeatMap4D MPI_ONLY)
+fortran_add_test_helper(BPWriteReadHeatMap5D MPI_ONLY)
+fortran_add_test_helper(BPWriteReadHeatMap6D MPI_ONLY)
+fortran_add_test_helper(BPReadGlobalsByName MPI_ONLY)
+fortran_add_test_helper(BPWriteMemorySelectionRead2D MPI_ONLY)
+fortran_add_test_helper(BPWriteMemorySelectionRead3D MPI_ONLY)
+fortran_add_test_helper(NullEngine MPI_ONLY)
 
+if(ADIOS2_HAVE_MPI)
   add_subdirectory(operation) 
 
   # F2C 
@@ -86,6 +71,21 @@ if(mpi)
   )
   set_tests_properties(Bindings.Fortran.F2C.BPReadFBlocks PROPERTIES
     DEPENDS "Bindings.Fortran.BPWriteReadHeatMap2D;Bindings.Fortran.BPWriteReadHeatMap3D"
-    PROCESSORS ${NUM_TEST_PROCS}
+    PROCESSORS "${MPIEXEC_MAX_NUMPROCS}"
   )
 endif()
+
+add_library(SmallTestData_f OBJECT SmallTestData_mod.F90)
+add_library(ISmallTestData_f INTERFACE)
+target_sources(ISmallTestData_f INTERFACE $<TARGET_OBJECTS:SmallTestData_f>)
+
+foreach(tgt
+    ${Test.Bindings.Fortran.BPWriteTypes-TARGETS}
+    ${Test.Bindings.Fortran.Remove-TARGETS}
+    ${Test.Bindings.Fortran.BPWriteReadAttributes-TARGETS}
+    ${Test.Bindings.Fortran.BPWriteVariableAttributes-TARGETS}
+    ${Test.Bindings.Fortran.BPWriteTypesByName-TARGETS}
+    ${Test.Bindings.Fortran.BPWriteTypesLocal-TARGETS}
+    )
+  target_link_libraries(${tgt} ISmallTestData_f)
+endforeach()

testing/adios2/bindings/fortran/operation/CMakeLists.txt

@@ -1,8 +1,8 @@
 if(ADIOS2_HAVE_SZ)
-  fortran_add_test_helper(BPWriteReadSZ2D TRUE)
-  fortran_add_test_helper(BPWriteReadSZ3D TRUE)
+  fortran_add_test_helper(BPWriteReadSZ2D MPI_ONLY)
+  fortran_add_test_helper(BPWriteReadSZ3D MPI_ONLY)
 endif()
 
 if(ADIOS2_HAVE_ZFP)
-  fortran_add_test_helper(BPWriteReadZfp2D TRUE)
+  fortran_add_test_helper(BPWriteReadZfp2D MPI_ONLY)
 endif()

testing/adios2/bindings/python/CMakeLists.txt

@@ -8,7 +8,7 @@ function(add_python_mpi_test testname)
     EXEC_WRAPPER ${MPIEXEC_COMMAND}
   )
   set_tests_properties(Bindings.Python.${testname} PROPERTIES
-    PROCESSORS ${NUM_TEST_PROCS}
+    PROCESSORS "${MPIEXEC_MAX_NUMPROCS}"
   )
 endfunction()
 

testing/adios2/engine/bp/CMakeLists.txt

@@ -8,51 +8,51 @@ set(BP4_DIR ${CMAKE_CURRENT_BINARY_DIR}/bp4)
 file(MAKE_DIRECTORY ${BP3_DIR})
 file(MAKE_DIRECTORY ${BP4_DIR})
 
-macro(bp3_bp4_gtest_add_tests_helper testname)
-  gtest_add_tests_helper(${testname} ${test_mpi} BP Engine.BP. .BP3
+macro(bp3_bp4_gtest_add_tests_helper testname mpi)
+  gtest_add_tests_helper(${testname} ${mpi} BP Engine.BP. .BP3
     WORKING_DIRECTORY ${BP3_DIR} EXTRA_ARGS "BP3"
   )
-  gtest_add_tests_helper(${testname} ${test_mpi} BP Engine.BP. .BP4
+  gtest_add_tests_helper(${testname} ${mpi} BP Engine.BP. .BP4
     WORKING_DIRECTORY ${BP4_DIR} EXTRA_ARGS "BP4"
   )
 endmacro()
 
 add_subdirectory(operations)
 
-bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2)
-bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2fstream)
-bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2stdio)
-bp3_bp4_gtest_add_tests_helper(WriteReadAsStreamADIOS2)
-bp3_bp4_gtest_add_tests_helper(WriteReadAsStreamADIOS2_Threads)
-bp3_bp4_gtest_add_tests_helper(WriteReadAttributes)
-bp3_bp4_gtest_add_tests_helper(FStreamWriteReadHighLevelAPI)
-bp3_bp4_gtest_add_tests_helper(WriteFlushRead)
-bp3_bp4_gtest_add_tests_helper(WriteMultiblockRead)
-bp3_bp4_gtest_add_tests_helper(WriteReadMultiblock)
-bp3_bp4_gtest_add_tests_helper(WriteReadVector)
-bp3_bp4_gtest_add_tests_helper(WriteReadAttributesMultirank)
-bp3_bp4_gtest_add_tests_helper(LargeMetadata)
-bp3_bp4_gtest_add_tests_helper(WriteMemorySelectionRead)
-bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariables)
-bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariablesSel)
-bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariablesSelHighLevel)
-bp3_bp4_gtest_add_tests_helper(ChangingShape)
-bp3_bp4_gtest_add_tests_helper(WriteReadBlockInfo)
-bp3_bp4_gtest_add_tests_helper(WriteReadVariableSpan)
-bp3_bp4_gtest_add_tests_helper(TimeAggregation)
-bp3_bp4_gtest_add_tests_helper(NoXMLRecovery)
+bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2 MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2fstream MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadADIOS2stdio MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadAsStreamADIOS2 MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadAsStreamADIOS2_Threads MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadAttributes MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(FStreamWriteReadHighLevelAPI MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteFlushRead MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteMultiblockRead MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadMultiblock MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadVector MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadAttributesMultirank MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(LargeMetadata MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteMemorySelectionRead MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariables MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariablesSel MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadLocalVariablesSelHighLevel MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(ChangingShape MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadBlockInfo MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(WriteReadVariableSpan MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(TimeAggregation MPI_ALLOW)
+bp3_bp4_gtest_add_tests_helper(NoXMLRecovery MPI_ALLOW)
 
 if(ADIOS2_HAVE_MPI)
-  bp3_bp4_gtest_add_tests_helper(WriteAggregateRead)
+  bp3_bp4_gtest_add_tests_helper(WriteAggregateRead MPI_ONLY)
 endif()
 
 # BP3 only for now
-gtest_add_tests_helper(WriteNull ${test_mpi} BP Engine.BP. .BP3
+gtest_add_tests_helper(WriteNull MPI_ALLOW BP Engine.BP. .BP3
   WORKING_DIRECTORY ${BP3_DIR} EXTRA_ARGS "BP3"
 )
 
 # BP4 only for now
-gtest_add_tests_helper(WriteAppendReadADIOS2 ${test_mpi} BP Engine.BP. .BP4
+gtest_add_tests_helper(WriteAppendReadADIOS2 MPI_ALLOW BP Engine.BP. .BP4
   WORKING_DIRECTORY ${BP4_DIR} EXTRA_ARGS "BP4"
 )