# enable tests build a common library for all test utilities
add_library(quda_test googletest/src/gtest-all.cc)
target_include_directories(quda_test SYSTEM PUBLIC  googletest/include googletest)
target_link_libraries(quda_test PUBLIC Eigen)
target_link_libraries(quda_test PUBLIC QUDA::quda)
set_target_properties(quda_test PROPERTIES POSITION_INDEPENDENT_CODE ON)
target_compile_options(
  quda_test PUBLIC
  $<IF:$<CONFIG:RELEASE>,-w,-Wall -Wextra>
  $<$<CONFIG:STRICT>:-Werror>
)

# ignore any unkown pragmas if not using OpenMP
if(NOT ${QUDA_OPENMP})
  target_compile_options(quda_test PUBLIC $<$<COMPILE_LANGUAGE:CXX>:
    $<$<CXX_COMPILER_ID:Clang>:-Wno-unknown-pragmas>
    $<$<CXX_COMPILER_ID:GNU>:-Wno-unknown-pragmas>
    >)
endif()

if(BUILD_SHARED_LIBS)
  install(TARGETS quda_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()

add_subdirectory(utils)
add_subdirectory(host_reference)
# enable_language(Fortran)

if(QUDA_NVSHMEM AND QUDA_DOWNLOAD_NVSHMEM)
  add_dependencies(quda_test NVSHMEM)
endif()

set(TEST_LIBS quda_test)

# custom target for building all tests (useful if QUDA_BUILD_ALL_TESTS is OFF)
add_custom_target(all_tests)

macro(QUDA_CHECKBUILDTEST mytarget qudabuildtests)
  if(NOT ${qudabuildtests})
    set_property(TARGET ${mytarget} PROPERTY EXCLUDE_FROM_ALL 1)
    set(QUDA_EXCLUDE_FROM_INSTALL "EXCLUDE_FROM_ALL")
  endif()
  add_dependencies(all_tests ${mytarget})
endmacro()

if(NOT ${QUDA_INSTALL_ALL_TESTS})
  set(QUDA_EXCLUDE_FROM_INSTALL "EXCLUDE_FROM_ALL")
endif()

if(QUDA_ARPACK)
  list(APPEND TEST_LIBS ${ARPACK})
  if(QUDA_MPI OR QUDA_QMP)
    list(APPEND TEST_LIBS ${PARPACK})
  endif()
endif()

# define tests
add_executable(c_interface_test c_interface_test.c)
target_link_libraries(c_interface_test ${TEST_LIBS} "-lstdc++")
quda_checkbuildtest(c_interface_test QUDA_BUILD_ALL_TESTS)

# if we build with QDP JIT the tests cannot run anyway
if(QUDA_QDPJIT)
  set(QUDA_BUILD_ALL_TESTS OFF)
endif()

if(QUDA_DIRAC_WILSON
   OR QUDA_DIRAC_CLOVER
   OR QUDA_DIRAC_TWISTED_MASS
   OR QUDA_DIRAC_TWISTED_CLOVER
   OR QUDA_DIRAC_DOMAIN_WALL)
  add_executable(dslash_test dslash_test.cpp)
  target_link_libraries(dslash_test ${TEST_LIBS})
  quda_checkbuildtest(dslash_test QUDA_BUILD_ALL_TESTS)

  add_executable(dslash_ctest dslash_ctest.cpp)
  target_link_libraries(dslash_ctest ${TEST_LIBS})
  quda_checkbuildtest(dslash_ctest QUDA_BUILD_ALL_TESTS)
  install(TARGETS dslash_test dslash_ctest ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(invert_test invert_test.cpp)
  target_link_libraries(invert_test ${TEST_LIBS})
  quda_checkbuildtest(invert_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS invert_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(eigensolve_test eigensolve_test.cpp)
  target_link_libraries(eigensolve_test ${TEST_LIBS})
  quda_checkbuildtest(eigensolve_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS eigensolve_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  if(QUDA_DIRAC_LAPLACE)
    add_executable(laph_test laph_test.cpp)
    target_link_libraries(laph_test ${TEST_LIBS})
    quda_checkbuildtest(laph_test QUDA_BUILD_ALL_TESTS)
    install(TARGETS laph_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
  endif()
endif()

if(QUDA_DIRAC_WILSON
   OR QUDA_DIRAC_CLOVER
   OR QUDA_DIRAC_TWISTED_MASS
   OR QUDA_DIRAC_TWISTED_CLOVER
   OR QUDA_DIRAC_DOMAIN_WALL
   OR QUDA_DIRAC_STAGGERED)
  add_executable(deflated_invert_test deflated_invert_test.cpp)
  target_link_libraries(deflated_invert_test ${TEST_LIBS})
  quda_checkbuildtest(deflated_invert_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS deflated_invert_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

if(QUDA_DIRAC_STAGGERED OR QUDA_DIRAC_LAPLACE)
  add_executable(staggered_dslash_test staggered_dslash_test.cpp)
  target_link_libraries(staggered_dslash_test ${TEST_LIBS})
  quda_checkbuildtest(staggered_dslash_test QUDA_BUILD_ALL_TESTS)

  add_executable(staggered_dslash_ctest staggered_dslash_ctest.cpp)
  target_link_libraries(staggered_dslash_ctest ${TEST_LIBS})
  quda_checkbuildtest(staggered_dslash_ctest QUDA_BUILD_ALL_TESTS)
  install(TARGETS staggered_dslash_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(staggered_invert_test staggered_invert_test.cpp)
  target_link_libraries(staggered_invert_test ${TEST_LIBS})
  quda_checkbuildtest(staggered_invert_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS staggered_invert_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(staggered_eigensolve_test staggered_eigensolve_test.cpp)
  target_link_libraries(staggered_eigensolve_test ${TEST_LIBS})
  quda_checkbuildtest(staggered_eigensolve_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS staggered_eigensolve_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(contract_ft_test contract_ft_test.cpp)
  target_link_libraries(contract_ft_test ${TEST_LIBS})
  quda_checkbuildtest(contract_ft_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS contract_ft_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

if(QUDA_DIRAC_WILSON
   OR QUDA_DIRAC_CLOVER
   OR QUDA_DIRAC_TWISTED_MASS
   OR QUDA_DIRAC_TWISTED_CLOVER
   OR QUDA_DIRAC_DOMAIN_WALL
   OR QUDA_DIRAC_STAGGERED)
  add_executable(blas_test blas_test.cpp)
  target_link_libraries(blas_test ${TEST_LIBS})

  quda_checkbuildtest(blas_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS blas_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(dilution_test dilution_test.cpp)
  target_link_libraries(dilution_test ${TEST_LIBS})
  quda_checkbuildtest(dilution_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS dilution_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

if(QUDA_MULTIGRID)
  add_executable(multigrid_benchmark_test multigrid_benchmark_test.cpp)
  target_link_libraries(multigrid_benchmark_test ${TEST_LIBS})

  quda_checkbuildtest(multigrid_benchmark_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS multigrid_benchmark_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(multigrid_evolve_test multigrid_evolve_test.cpp)
  target_link_libraries(multigrid_evolve_test ${TEST_LIBS})
  quda_checkbuildtest(multigrid_evolve_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS multigrid_evolve_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

endif()

if(QUDA_BUILD_NATIVE_LAPACK)
  add_executable(blas_interface_test blas_interface_test.cpp)
  target_link_libraries(blas_interface_test ${TEST_LIBS})
  quda_checkbuildtest(blas_interface_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS blas_interface_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

if(QUDA_QIO)
  add_executable(io_test io_test.cpp)
  target_link_libraries(io_test ${TEST_LIBS})
  quda_checkbuildtest(io_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS io_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

add_executable(tune_test tune_test.cpp)
target_link_libraries(tune_test ${TEST_LIBS})
quda_checkbuildtest(tune_test QUDA_BUILD_ALL_TESTS)
install(TARGETS tune_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

add_executable(plaq_test plaq_test.cpp)
target_link_libraries(plaq_test ${TEST_LIBS})
quda_checkbuildtest(plaq_test QUDA_BUILD_ALL_TESTS)
install(TARGETS plaq_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

add_executable(su3_test su3_test.cpp)
target_link_libraries(su3_test ${TEST_LIBS})
quda_checkbuildtest(su3_test QUDA_BUILD_ALL_TESTS)
install(TARGETS su3_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

if(QUDA_DIRAC_LAPLACE)
  add_executable(su3_fermion_test su3_fermion_test.cpp)
  target_link_libraries(su3_fermion_test ${TEST_LIBS})
  quda_checkbuildtest(su3_fermion_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS su3_fermion_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

add_executable(pack_test pack_test.cpp)
target_link_libraries(pack_test ${TEST_LIBS})
quda_checkbuildtest(pack_test QUDA_BUILD_ALL_TESTS)
install(TARGETS pack_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

if(QUDA_DIRAC_COVDEV)
  add_executable(covdev_test covdev_test.cpp)
  target_link_libraries(covdev_test ${TEST_LIBS})
  quda_checkbuildtest(covdev_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS covdev_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

if(QUDA_DIRAC_STAGGERED)
  add_executable(llfat_test llfat_test.cpp)
  target_link_libraries(llfat_test ${TEST_LIBS})
  quda_checkbuildtest(llfat_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS llfat_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(unitarize_link_test unitarize_link_test.cpp)
  target_link_libraries(unitarize_link_test ${TEST_LIBS})
  quda_checkbuildtest(unitarize_link_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS unitarize_link_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(hisq_stencil_test hisq_stencil_test.cpp)
  target_link_libraries(hisq_stencil_test ${TEST_LIBS})
  quda_checkbuildtest(hisq_stencil_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS hisq_stencil_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(hisq_stencil_ctest hisq_stencil_ctest.cpp)
  target_link_libraries(hisq_stencil_ctest ${TEST_LIBS})
  quda_checkbuildtest(hisq_stencil_ctest QUDA_BUILD_ALL_TESTS)
  install(TARGETS hisq_stencil_ctest ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(hisq_paths_force_test hisq_paths_force_test.cpp)
  target_link_libraries(hisq_paths_force_test ${TEST_LIBS})
  quda_checkbuildtest(hisq_paths_force_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS hisq_paths_force_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(hisq_unitarize_force_test hisq_unitarize_force_test.cpp)
  target_link_libraries(hisq_unitarize_force_test ${TEST_LIBS})
  quda_checkbuildtest(hisq_unitarize_force_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS hisq_unitarize_force_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

  add_executable(staggered_gsmear_test staggered_gsmear_test.cpp)
  target_link_libraries(staggered_gsmear_test ${TEST_LIBS})
  quda_checkbuildtest(staggered_gsmear_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS staggered_gsmear_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

add_executable(gauge_path_test gauge_path_test.cpp)
target_link_libraries(gauge_path_test ${TEST_LIBS})
quda_checkbuildtest(gauge_path_test QUDA_BUILD_ALL_TESTS)
install(TARGETS gauge_path_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

if(QUDA_DIRAC_CLOVER OR QUDA_DIRAC_TWISTED_CLOVER OR QUDA_DIRAC_NDEG_TWISTED_CLOVER)
  add_executable(clover_force_test clover_force_test.cpp)
  target_link_libraries(clover_force_test ${TEST_LIBS})
  quda_checkbuildtest(clover_force_test QUDA_BUILD_ALL_TESTS)
  install(TARGETS clover_force_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

add_executable(gauge_alg_test gauge_alg_test.cpp)
target_link_libraries(gauge_alg_test ${TEST_LIBS})
quda_checkbuildtest(gauge_alg_test QUDA_BUILD_ALL_TESTS)
install(TARGETS gauge_alg_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})

add_executable(heatbath_test heatbath_test.cpp)
target_link_libraries(heatbath_test ${TEST_LIBS})
quda_checkbuildtest(heatbath_test QUDA_BUILD_ALL_TESTS)
install(TARGETS heatbath_test ${QUDA_EXCLUDE_FROM_INSTALL} DESTINATION ${CMAKE_INSTALL_BINDIR})


if(QUDA_MPI OR QUDA_QMP)
  #helper function to extract required number of ranks from environment variable
  function(get_test_ranks TEST_GRID RANKS)
    separate_arguments(TEST_GRID)
    LIST(LENGTH TEST_GRID TEST_LENGTH)
    if(NOT ${TEST_LENGTH} EQUAL 4)
      message(SEND_ERROR "QUDA_TEST_GRID_SIZE takes 4 INTEGERS. GOT: ${TEST_GRID_SIZE}")
    endif()
      LIST(JOIN TEST_GRID * TEST_GRID_EXPR)
    math(EXPR TEST_RANKS ${TEST_GRID_EXPR} OUTPUT_FORMAT DECIMAL)
    set(${RANKS} ${TEST_RANKS} PARENT_SCOPE )
  endfunction()

  set(QUDA_TEST_NUM_PROCS 1)
  if(DEFINED ENV{QUDA_TEST_GRID_SIZE})
    get_test_ranks($ENV{QUDA_TEST_GRID_SIZE} QUDA_TEST_NUM_PROCS)
  endif()
  message(STATUS "ctest will run on ${QUDA_TEST_NUM_PROCS} processes")
  set(QUDA_CTEST_LAUNCH ${MPIEXEC_EXECUTABLE};${MPIEXEC_NUMPROC_FLAG};${QUDA_TEST_NUM_PROCS};${MPIEXEC_PREFLAGS}
    CACHE STRING "CTest Launcher command for QUDA's tests")
else()
  set(QUDA_TEST_NUM_PROCS 1)
endif()

# BLAS tests
if(QUDA_DIRAC_WILSON
   OR QUDA_DIRAC_CLOVER
   OR QUDA_DIRAC_TWISTED_MASS
   OR QUDA_DIRAC_TWISTED_CLOVER
   OR QUDA_DIRAC_DOMAIN_WALL)
  add_test(NAME blas_test_parity_wilson
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:blas_test> ${MPIEXEC_POSTFLAGS}
                   --dim 2 4 6 8  --niter 1
                   --nsrc 8 --msrc 9
                   --solve-type direct-pc
                   --gtest_output=xml:blas_test_parity.xml)
  add_test(NAME blas_test_full_wilson
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:blas_test> ${MPIEXEC_POSTFLAGS}
                   --dim 2 4 6 8 --niter 1
                   --nsrc 8 --msrc 9
                   --solve-type direct
                   --gtest_output=xml:blas_test_full.xml)
endif()

if(QUDA_DIRAC_STAGGERED)
  add_test(NAME blas_test_parity_staggered
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:blas_test> ${MPIEXEC_POSTFLAGS}
                   --dim 2 4 6 8 --niter 1
                   --nsrc 8 --msrc 9
                   --dslash-type staggered
                   --solve-type direct-pc
                   --gtest_output=xml:blas_test_parity.xml)
  add_test(NAME blas_test_full_staggered
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:blas_test> ${MPIEXEC_POSTFLAGS}
                   --dim 2 4 6 8 --niter 1
                   --nsrc 8 --msrc 9
                   --dslash-type staggered
                   --solve-type direct
                   --gtest_output=xml:blas_test_full.xml)
endif()

#BLAS interface test
if(QUDA_BUILD_NATIVE_LAPACK)
  add_test(NAME blas_interface_test
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:blas_interface_test> ${MPIEXEC_POSTFLAGS}
    --blas-gemm-mnk 64 64 64
    --blas-gemm-leading-dims 128 128 128
    --blas-gemm-offsets 16 16 16
    --blas-gemm-alpha 1.0 2.0
    --blas-gemm-beta -3.0 1.5
    --blas-gemm-trans-a T
    --blas-gemm-trans-b C
    --blas-lu-inv-mat-size 96
    --blas-data-type Z
    --blas-data-order row
    --blas-batch 20
    --enable-testing true
    --gtest_output=xml:blas_interface_test.xml)
endif()

#Contraction test
if(QUDA_DIRAC_STAGGERED)
  add_test(NAME contract_ft_test
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:contract_ft_test> ${MPIEXEC_POSTFLAGS}
    --dim 2 4 6 8 --enable-testing true
    --gtest_output=xml:contract_ft_test.xml)
endif()

# loop over Dslash policies
if(QUDA_CTEST_SEP_DSLASH_POLICIES)
  set(DSLASH_POLICIES 0 1)

  if(DEFINED ENV{QUDA_ENABLE_ZERO_COPY})
    if($ENV{QUDA_ENABLE_ZERO_COPY} EQUAL 1)
      set(DSLASH_POLICIES 6 7 8 9 12 13 ${DSLASH_POLICIES})
      message(STATUS "QUDA_ENABLE_ZERO_COPY=1: enabling zero-copy dslash policies in ctest")
    else()
      message(STATUS "QUDA_ENABLE_ZERO_COPY!=1: disabling zero-copy dslash policies in ctest")
    endif()
  else()
    message(STATUS "QUDA_ENABLE_ZERO_COPY not set: disabling zero-copy dslash policies in ctest")
  endif()

  if(DEFINED ENV{QUDA_ENABLE_GDR})
    if($ENV{QUDA_ENABLE_GDR} EQUAL 1)
      set(DSLASH_POLICIES 2 3 4 5 10 11 ${DSLASH_POLICIES})
      message(STATUS "QUDA_ENABLE_GDR=1: enabling GDR-enabled dslash policies in ctest")
    else()
      message(STATUS "QUDA_ENABLE_GDR!=1: disabling GDR-enabled dslash policies in ctest")
    endif()
  else()
    message(STATUS "QUDA_ENABLE_GDR not set: disabling GDR-enabled dslash policies in ctest")
  endif()

  if(QUDA_NVSHMEM)
    if(NOT DEFINED $ENV{QUDA_ENABLE_NVSHMEM} OR $ENV{QUDA_ENABLE_NVSHMEM} EQUAL 1)
      set(DSLASH_POLICIES 14 15 16 17 ${DSLASH_POLICIES})
      message(STATUS "QUDA_ENABLE_NVSHMEM=1: enabling NVSHMEM dslash policies in ctest")
    elseif()
      message(STATUS "QUDA_ENABLE_NVSHMEM!=1: disabling NVSHMEM dslash policies in ctest")
    endif()
  endif()

  list(SORT DSLASH_POLICIES COMPARE NATURAL)
  message(STATUS "Enabled dslash policies are ${DSLASH_POLICIES}")
endif()

set(DSLASH_POLICIES ${DSLASH_POLICIES} -1)

foreach(pol IN LISTS DSLASH_POLICIES)

  if(${pol} LESS 0)
    set(pol2 "tune")
    set(polenv OFF)
  else()
    set(pol2 ${pol})
    set(polenv ON)
  endif()

  if(QUDA_DIRAC_WILSON)
    set(DIRAC_NAME wilson)
    add_test(NAME dslash_${DIRAC_NAME}_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 1
                     --test MatPCDagMatPC
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_splitgrid_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 0
                     --test Dslash
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_splitgrid_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
    set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2} PROPERTIES ENVIRONMENT QUDA_TEST_GRID_PARTITION=$ENV{QUDA_TEST_GRID_SIZE})

    add_test(NAME dslash_${DIRAC_NAME}_splitgrid_policy${pol2}_DD
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 0
		     --domain-decomposition 1
                     --test Dslash
                     --dim 4 2 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_splitgrid_test_pol${pol2}_DD.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2}_DD PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
    set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2}_DD PROPERTIES ENVIRONMENT QUDA_TEST_GRID_PARTITION=$ENV{QUDA_TEST_GRID_SIZE})

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 1
                     --test 0
                     --dim 20 20 20 20
                     --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
                     --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
    
    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 0
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_CLOVER)
    set(DIRAC_NAME clover)

    # symmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_CLOVER_HASENBUSCH)
    set(DIRAC_NAME clover-hasenbusch-twist)

    # symmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_TWISTED_MASS)
    set(DIRAC_NAME twisted-mass)

    # symmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_TWISTED_MASS)
    # the ndeg-twisted-mas operator does not fit the pattern used for most other operators
    # since it is defined via 'dslash-type = twisted-mass` and 'flavor = nondeg-doublet'
    set(DIRAC_NAME twisted-mass)

    # symmetric preconditioning
    add_test(NAME dslash_ndeg_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --flavor nondeg-doublet
                     --dim 2 4 6 8
        --gtest_output=xml:dslash_ndeg_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_ndeg_${DIRAC_NAME}_sym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_ndeg_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --flavor nondeg-doublet
                     --dim 2 4 6 8
        --gtest_output=xml:dslash_ndeg_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_ndeg_${DIRAC_NAME}_asym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_ndeg_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --flavor nondeg-doublet
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_TWISTED_CLOVER)
    set(DIRAC_NAME twisted-clover)

    # symmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_TWISTED_CLOVER)
    # the ndeg-twisted-clover operator does not fit the pattern used for most other operators
    # since it is defined via 'dslash-type = twisted-clover` and 'flavor = nondeg-doublet'
    set(DIRAC_NAME twisted-clover)

    # symmetric preconditioning
    add_test(NAME dslash_ndeg_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --flavor nondeg-doublet
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_ndeg_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_ndeg_${DIRAC_NAME}_sym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric preconditioning
    add_test(NAME dslash_ndeg_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --flavor nondeg-doublet
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --gtest_output=xml:dslash_ndeg_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_ndeg_${DIRAC_NAME}_asym_policy${pol2}
                           PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --flavor nondeg-doublet
            --test 0
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_ndeg_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_ndeg_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --flavor nondeg-doublet
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()
  endif()

  if(QUDA_DIRAC_DOMAIN_WALL)
    # 5-d preconditioned
    set(DIRAC_NAME domain-wall)

    add_test(NAME dslash_${DIRAC_NAME}_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --Lsdim 4
        --gtest_output=xml:dslash_${DIRAC_NAME}_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --Lsdim 12
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_ndeg_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
		     --domain-decomposition 1
                     --flavor nondeg-doublet
                     --dim 4 2 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # 4-d preconditioned
    set(DIRAC_NAME domain-wall-4d)

    # symmetric 4-d preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --Lsdim 4
        --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # asymmetric 4-d preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --Lsdim 4
        --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --Lsdim 12
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()


    # Mobius fermions
    set(DIRAC_NAME mobius)

    # 4-d preconditioning
    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --Lsdim 4
                     --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --Lsdim 4
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test 0
            --dim 20 20 20 20
            --Lsdim 12
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # MdagM local operator
    # This requires tensor cores so only enable NVIDIA targets
    # FIXME: Ideally we should have a more sensitive guard -- e.g. QUDA_TENSOR_CORE_AVAILABLE 
    # or some such so that this would not be an architecture specific guard, but a feature
    # specific guard
    # 
    if( QUDA_TARGET_CUDA )
      add_test(NAME dslash_${DIRAC_NAME}_local_policy${pol2}
               COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                       --dslash-type ${DIRAC_NAME}
                       --test MatPCDagMatPCLocal
                       --matpc even-even
                       --dim 2 4 6 8
                       --Lsdim 4
                       --gtest_output=xml:dslash_${DIRAC_NAME}_local{pol2}.xml)
    endif()

    # Mobius-EOFA fermions
    set(DIRAC_NAME mobius-eofa)

    add_test(NAME dslash_${DIRAC_NAME}_sym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even
                     --dim 2 4 6 8
                     --Lsdim 4
        --gtest_output=xml:dslash_${DIRAC_NAME}_sym_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_sym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_asym_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPCDagMatPC
                     --matpc even-even-asym
                     --dim 2 4 6 8
                     --Lsdim 4
                     --gtest_output=xml:dslash_${DIRAC_NAME}_asym_test_pol${pol2}.xml)
 
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_asym_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

  endif()

  if(QUDA_DIRAC_STAGGERED)
    set(DIRAC_NAME staggered)
    add_test(NAME dslash_${DIRAC_NAME}_matpc_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPC
                     --dim 4 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_matpc_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_matpc_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_mat_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test Mat
                     --dim 4 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_mat_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_mat_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_splitgrid_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPC
                     --dim 4 4 6 8
                     --gtest_output=xml:dslash_${DIRAC_NAME}_matpc_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()
    set_tests_properties(dslash_${DIRAC_NAME}_splitgrid_policy${pol2} PROPERTIES ENVIRONMENT QUDA_TEST_GRID_PARTITION=$ENV{QUDA_TEST_GRID_SIZE})

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --test MatPC
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 0
                     --test Mat
		     --domain-decomposition 1
                     --dim 4 4 6 8
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    set(DIRAC_NAME asqtad)
    add_test(NAME dslash_${DIRAC_NAME}_matpc_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 1
                     --test MatPC
                     --dim 6 8 10 12
                     --gtest_output=xml:dslash_${DIRAC_NAME}_matpc_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_matpc_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()

    add_test(NAME dslash_${DIRAC_NAME}_mat_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 1
                     --test Mat
                     --dim 6 8 10 12
                     --gtest_output=xml:dslash_${DIRAC_NAME}_mat_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_mat_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()

    add_test(NAME benchmark_dslash_${DIRAC_NAME}_policy${pol2}
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
            --dslash-type ${DIRAC_NAME}
            --all-partitions 1
            --test MatPC
            --dim 20 20 20 20
            --gtest_output=json:dslash_${DIRAC_NAME}_benchmark_pol${pol2}.json
            --gtest_filter=*benchmark/*n0)
    set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES DISABLED ${QUDA_CTEST_DISABLE_BENCHMARKS})
    if(polenv)
      set_tests_properties(benchmark_dslash_${DIRAC_NAME}_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    # Test setting `--dslash-type hisq`, which implies `--dslash-type asqtad --compute-fat-long true`
    set(DIRAC_NAME hisq)
    add_test(NAME dslash_${DIRAC_NAME}_build_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --test MatPC
                     --dim 6 8 10 12
                     --epsilon-naik -0.01
                     --tadpole-coeff 0.9
        --gtest_output=xml:dslash_${DIRAC_NAME}_build_test_pol${pol2}.xml)
    if(polenv)
      set_tests_properties(dslash_${DIRAC_NAME}_build_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
    endif()

    set(TEST_NAME dslash_${DIRAC_NAME}_mat_policy${pol2}_DD)
    add_test(NAME ${TEST_NAME}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                     --dslash-type ${DIRAC_NAME}
                     --all-partitions 0
                     --test Mat
		     --domain-decomposition 1
                     --dim 8 6 10 12
                     --gtest_output=xml:${TEST_NAME}.xml)
    if(polenv)
      set_tests_properties(${TEST_NAME} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol})
    endif()

    if(QUDA_DIRAC_LAPLACE)
      set(DIRAC_NAME laplace)
      add_test(NAME dslash_${DIRAC_NAME}_mat_policy${pol2}
               COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_dslash_ctest> ${MPIEXEC_POSTFLAGS}
                       --dslash-type ${DIRAC_NAME}
                       --test Mat
                       --dim 4 4 6 8
                       --gtest_output=xml:dslash_${DIRAC_NAME}_mat_test_pol${pol2}.xml)
      if(polenv)
        set_tests_properties(dslash_${DIRAC_NAME}_mat_policy${pol2} PROPERTIES ENVIRONMENT QUDA_ENABLE_DSLASH_POLICY=${pol2})
      endif()
    endif()
  endif()

  if(QUDA_DIRAC_COVDEV)
    add_test(NAME covdev_policy${pol2}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:covdev_test> ${MPIEXEC_POSTFLAGS}
                     --dim 6 8 10 12 --enable-testing true
                     --gtest_output=xml:covdev_test_pol${pol2}.xml)
  endif()

endforeach(pol)

# enable the precisions that are compiled
math(EXPR double_prec  "${QUDA_PRECISION} & 8")
math(EXPR single_prec  "${QUDA_PRECISION} & 4")
math(EXPR half_prec    "${QUDA_PRECISION} & 2")
math(EXPR quarter_prec "${QUDA_PRECISION} & 1")

if(double_prec AND single_prec)
  set(TEST_PRECS single double)
elseif(double_prec)
  set(TEST_PRECS double)
elseif(single_prec)
  set(TEST_PRECS single)
endif()

# Wilson-type Inversions
if(QUDA_DIRAC_WILSON)
  add_test(NAME invert_test_wilson
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type wilson --ngcrkrylov 8 --nsrc 4 --nsrc-tile 4
    --dim 2 4 6 8 --niter 1000
    --enable-testing true
    --gtest_output=xml:invert_test_wilson.xml)

  add_test(NAME invert_test_splitgrid_wilson
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type wilson --ngcrkrylov 8
    --dim 2 4 6 8 --niter 1000
    --nsrc ${QUDA_TEST_NUM_PROCS} --nsrc-tile ${QUDA_TEST_NUM_PROCS}
    --enable-testing true
    --gtest_output=xml:invert_test_splitgrid_wilson.xml)

  set_tests_properties(invert_test_splitgrid_wilson PROPERTIES ENVIRONMENT QUDA_TEST_GRID_PARTITION=$ENV{QUDA_TEST_GRID_SIZE})
endif()
  
if(QUDA_DIRAC_TWISTED_MASS)
  add_test(NAME invert_test_twisted_mass_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even --enable-testing true
    --gtest_output=xml:invert_test_twisted_mass_sym.xml)

  add_test(NAME invert_test_twisted_mass_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:invert_test_twisted_mass_asym.xml)
endif()

if(QUDA_DIRAC_TWISTED_MASS)
  add_test(NAME invert_test_ndeg_twisted_mass_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even --flavor nondeg-doublet
    --enable-testing true
    --gtest_output=xml:invert_test_ndeg_twisted_mass_sym.xml)

  add_test(NAME invert_test_ndeg_twisted_mass_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym --flavor nondeg-doublet
    --enable-testing true
    --gtest_output=xml:invert_test_ndeg_twisted_mass_asym.xml)
endif()

if(QUDA_DIRAC_CLOVER)
  add_test(NAME invert_test_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even --enable-testing true
    --gtest_output=xml:invert_test_clover_sym.xml)

  add_test(NAME invert_test_clover_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:invert_test_clover_asym.xml)
endif()

if(QUDA_DIRAC_TWISTED_CLOVER)
  add_test(NAME invert_test_twisted_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even --enable-testing true
    --gtest_output=xml:invert_test_twisted_clover_sym.xml)

  add_test(NAME invert_test_twisted_clover_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:invert_test_twisted_clover_asym.xml)
endif()

if(QUDA_DIRAC_TWISTED_CLOVER)
  add_test(NAME invert_test_ndeg_twisted_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even --flavor nondeg-doublet
    --enable-testing true
    --gtest_output=xml:invert_test_ndeg_twisted_clover_sym.xml)

  add_test(NAME invert_test_ndeg_twisted_clover_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym --flavor nondeg-doublet
    --enable-testing true
    --gtest_output=xml:invert_test_ndeg_twisted_clover_asym.xml)
endif()

if(QUDA_DIRAC_DOMAIN_WALL)
  add_test(NAME invert_test_domain_wall
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even
    --enable-testing true
    --gtest_output=xml:invert_test_domain_wall.xml)

  add_test(NAME invert_test_domain_wall_4d_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall-4d
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even
    --enable-testing true
    --gtest_output=xml:invert_test_domain_wall_4d_sym.xml)

  add_test(NAME invert_test_domain_wall_4d_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall-4d
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym
    --enable-testing true
    --gtest_output=xml:invert_test_domain_wall_4d_asym.xml)

  add_test(NAME invert_test_mobius_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even
    --enable-testing true
    --gtest_output=xml:invert_test_mobius_sym.xml)

  add_test(NAME invert_test_mobius_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym
    --enable-testing true
    --gtest_output=xml:invert_test_mobius_asym.xml)

  add_test(NAME invert_test_mobius_eofa_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius-eofa
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even
    --enable-testing true
    --gtest_output=xml:invert_test_mobius_eofa_sym.xml)

  add_test(NAME invert_test_mobius_eofa_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius-eofa
    --dim 2 4 6 8 --Lsdim 4 --niter 1000 --ngcrkrylov 8
    --matpc even-even-asym
    --enable-testing true
    --gtest_output=xml:invert_test_mobius_eofa_asym.xml)
endif()

# Staggered-type Inversions
foreach(prec IN LISTS TEST_PRECS)

  # These require looser tolerances to keep iterations to solution in check
  if(${prec} STREQUAL "double")
    set(tol 1e-6)
  elseif(${prec} STREQUAL "single")
    set(tol 1e-5)
  endif()

  if(QUDA_DIRAC_STAGGERED)
    # --compute-fat-long true is necessary to get well-behaved fields

    add_test(NAME invert_test_staggered_${prec}
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type staggered --ngcrkrylov 8 --compute-fat-long true
      --dim 2 4 6 8 --prec ${prec} --tol ${tol} --tolhq ${tol} --niter 1000
      --enable-testing true
      --gtest_output=xml:invert_test_staggered_${prec}.xml)

    add_test(NAME invert_test_splitgrid_staggered_${prec}
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type staggered --ngcrkrylov 8 --compute-fat-long true
      --dim 2 4 6 8 --prec ${prec} --tol ${tol} --tolhq ${tol} --niter 1000
      --nsrc ${QUDA_TEST_NUM_PROCS} --nsrc-tile ${QUDA_TEST_NUM_PROCS}
      --enable-testing true
      --gtest_output=xml:invert_test_splitgrid_staggered_${prec}.xml)

    set_tests_properties(invert_test_splitgrid_staggered_${prec} PROPERTIES ENVIRONMENT QUDA_TEST_GRID_PARTITION=$ENV{QUDA_TEST_GRID_SIZE})

    add_test(NAME invert_test_asqtad_${prec}
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type asqtad --ngcrkrylov 8 --compute-fat-long true
      --dim 6 6 6 8 --prec ${prec} --tol ${tol} --tolhq ${tol} --niter 1000
      --enable-testing true --nsrc 4 --nsrc-tile 4
      --gtest_output=xml:invert_test_asqtad_${prec}.xml)

    add_test(NAME invert_test_splitgrid_asqtad_${prec}
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type asqtad --ngcrkrylov 8 --compute-fat-long true
      --dim 6 6 6 8 --prec ${prec} --tol ${tol} --tolhq ${tol} --niter 1000
      --nsrc ${QUDA_TEST_NUM_PROCS}
      --enable-testing true
      --gtest_output=xml:invert_test_splitgrid_asqtad_${prec}.xml)

    if (QUDA_DIRAC_LAPLACE)
      add_test(NAME invert_test_laplace_${prec}
        COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_invert_test> ${MPIEXEC_POSTFLAGS}
        --dslash-type laplace --ngcrkrylov 8 --compute-fat-long true
        --dim 2 4 6 8 --prec ${prec} --tol ${tol} --tolhq ${tol} --niter 1000
        --enable-testing true
        --gtest_output=xml:invert_test_laplace_${prec}.xml)
    endif()
  endif()
endforeach(prec)

# Distance preconditioning for Wilson/clover
if (QUDA_DIRAC_DISTANCE_PRECONDITIONING)
  # Wilson-type Inversions
  if(QUDA_DIRAC_WILSON)
    add_test(NAME invert_test_wilson_distance_pc
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type wilson --ngcrkrylov 8
      --dim 2 4 6 8 --niter 1000
      --distance-pc-alpha0 0.1 --distance-pc-t0 4
      --enable-testing true
      --gtest_output=xml:invert_test_wilson_distance_pc.xml)
  endif()

  if(QUDA_DIRAC_CLOVER)
    add_test(NAME invert_test_clover_sym_distance_pc
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type clover --compute-clover true
      --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
      --distance-pc-alpha0 0.1 --distance-pc-t0 4
      --matpc even-even --enable-testing true
      --gtest_output=xml:invert_test_clover_sym_distance_pc.xml)

    add_test(NAME invert_test_clover_asym_distance_pc
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:invert_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type clover --compute-clover true
      --dim 2 4 6 8 --niter 1000 --ngcrkrylov 8
      --distance-pc-alpha0 0.1 --distance-pc-t0 4
      --matpc even-even-asym --enable-testing true
      --gtest_output=xml:invert_test_clover_asym_distance_pc.xml)
  endif()
endif()

# Wilson-type eigensolves
if(QUDA_DIRAC_WILSON)    
  add_test(NAME eigensolve_test_wilson
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type wilson --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --dim 2 4 6 8 --eig-max-restarts 1000
    --enable-testing true 
    --gtest_output=xml:eigensolve_test_wilson.xml)
endif()
  
if(QUDA_DIRAC_TWISTED_MASS)
  add_test(NAME eigensolve_test_twisted_mass_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --dim 2 4 6 8 --eig-max-restarts 1000
    --matpc even-even --enable-testing true
    --gtest_output=xml:eigensolve_test_twisted_mass_sym.xml)
    
  add_test(NAME eigensolve_test_twisted_mass_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --dim 2 4 6 8 --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true 
    --gtest_output=xml:eigensolve_test_twisted_mass_asym.xml)
endif()
  
if(QUDA_DIRAC_TWISTED_MASS)
  add_test(NAME eigensolve_test_ndeg_twisted_mass_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --dim 2 4 6 8 --eig-max-restarts 1000
    --matpc even-even --flavor nondeg-doublet 
    --enable-testing true --eig-use-eigen-qr false
    --gtest_output=xml:eigensolve_test_ndeg_twisted_mass_sym.xml)

  add_test(NAME eigensolve_test_ndeg_twisted_mass_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-mass --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --dim 2 4 6 8 --eig-max-restarts 1000
    --matpc even-even-asym --flavor nondeg-doublet
    --enable-testing true --eig-use-eigen-qr false
    --gtest_output=xml:eigensolve_test_ndeg_twisted_mass_asym.xml)
endif()
  
if(QUDA_DIRAC_CLOVER)
  add_test(NAME eigensolve_test_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type clover --compute-clover true      
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true 
    --gtest_output=xml:eigensolve_test_clover_sym.xml)

  add_test(NAME eigensolve_test_clover_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type clover --compute-clover true      
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:eigensolve_test_clover_asym.xml)
endif()

if(QUDA_DIRAC_TWISTED_CLOVER)
  add_test(NAME eigensolve_test_twisted_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true 
    --gtest_output=xml:eigensolve_test_twisted_clover_sym.xml)
    
  add_test(NAME eigensolve_test_twisted_clover_asym      
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true 
    --gtest_output=xml:eigensolve_test_twisted_clover_asym.xml)
endif()
  
if(QUDA_DIRAC_TWISTED_CLOVER)
  add_test(NAME eigensolve_test_ndeg_twisted_clover_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --flavor nondeg-doublet
    --enable-testing true 
    --gtest_output=xml:eigensolve_test_ndeg_twisted_clover_sym.xml)
    
  add_test(NAME eigensolve_test_ndeg_twisted_clover_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type twisted-clover --compute-clover true
    --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --flavor nondeg-doublet
    --enable-testing true 
    --gtest_output=xml:eigensolve_test_ndeg_twisted_clover_asym.xml)
endif()

if(QUDA_DIRAC_DOMAIN_WALL)
  add_test(NAME eigensolve_test_domain_wall
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true
    --gtest_output=xml:eigensolve_test_domain_wall.xml)

  add_test(NAME eigensolve_test_domain_wall_4d_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall-4d
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true
    --gtest_output=xml:eigensolve_test_domain_wall_4d_sym.xml)

  add_test(NAME eigensolve_test_domain_wall_4d_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type domain-wall-4d
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:eigensolve_test_domain_wall_4d_asym.xml)

  add_test(NAME eigensolve_test_mobius_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true
    --gtest_output=xml:eigensolve_test_mobius_sym.xml)

  add_test(NAME eigensolve_test_mobius_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:eigensolve_test_mobius_asym.xml)

  add_test(NAME eigensolve_test_mobius_eofa_sym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius-eofa
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even --enable-testing true
    --gtest_output=xml:eigensolve_test_mobius_eofa_sym.xml)

  add_test(NAME eigensolve_test_mobius_eofa_asym
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type mobius-eofa
    --dim 2 4 6 8 --Lsdim 4 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
    --eig-max-restarts 1000
    --matpc even-even-asym --enable-testing true
    --gtest_output=xml:eigensolve_test_mobius_eofa_asym.xml)
endif()

# Staggered-type eigensolves
if(QUDA_DIRAC_STAGGERED)
  # --compute-fat-long true is necessary to get well-behaved fields

  add_test(NAME eigensolve_test_staggered
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_eigensolve_test> ${MPIEXEC_POSTFLAGS}
    --dslash-type staggered --compute-fat-long true
    --dim 2 4 6 8 --eig-n-conv 24 --eig-n-ev 24 --eig-n-kr 128
    --eig-max-restarts 1000
    --enable-testing true
    --gtest_output=xml:staggered_eigensolve_test_staggered.xml)

  # These tests are particularly expensive so they are disabled by default
  if(QUDA_IMPROVED_STAGGERED_EIGENSOLVER_CTEST)
    add_test(NAME eigensolve_test_asqtad
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_eigensolve_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type asqtad --compute-fat-long true
      --dim 6 6 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 96
      --eig-max-restarts 1000
      --enable-testing true
      --gtest_output=xml:staggered_eigensolve_test_asqtad.xml)
  endif()

  if (QUDA_DIRAC_LAPLACE)
    add_test(NAME eigensolve_test_laplace
      COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_eigensolve_test> ${MPIEXEC_POSTFLAGS}
      --dslash-type laplace --compute-fat-long true
      --dim 2 4 6 8 --eig-n-conv 16 --eig-n-ev 16 --eig-n-kr 48
      --eig-max-restarts 1000
      --enable-testing true
      --gtest_output=xml:staggered_eigensolve_test_laplace.xml)
  endif()
endif()

if (QUDA_DIRAC_LAPLACE AND QUDA_DIRAC_WILSON)
  add_test(NAME laph_test
           COMMAND  ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:laph_test> ${MPIEXEC_POSTFLAGS}
           --dim 2 4 6 8
           --enable-testing true
           --gtest_output=xml:laph_test.xml)

  add_test(NAME su3_fermion_test
           COMMAND  ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:su3_fermion_test> ${MPIEXEC_POSTFLAGS}
           --dim 2 4 6 8
           --enable-testing true --nsrc 2
           --gtest_output=xml:su3_fermion_test.xml)
endif()


if(QUDA_DIRAC_STAGGERED)
  add_test(NAME hisq_stencil
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:hisq_stencil_ctest> ${MPIEXEC_POSTFLAGS}
                   --dim 8 8 8 8
                   --gtest_output=xml:hisq_stencil_test.xml)
endif()

if(QUDA_DIRAC_CLOVER OR QUDA_DIRAC_TWISTED_CLOVER)
  add_test(NAME clover_force_test
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:clover_force_test> ${MPIEXEC_POSTFLAGS}
    --dim 2 4 6 8
    --compute-clover true
    --solution-type mat-pc-dag-mat-pc
    --matpc odd-odd-asym --dagger
    --enable-testing true --niter 1
    --gtest_output=xml:clover_force_test.xml)
endif()

add_test(NAME gauge_path
  COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:gauge_path_test> ${MPIEXEC_POSTFLAGS}
  --dim 2 4 6 8 --enable-testing true --niter 1
  --gtest_output=xml:gauge_path_test.xml)

foreach(prec IN LISTS TEST_PRECS)

  if(QUDA_DIRAC_STAGGERED)
    add_test(NAME unitarize_link_${prec}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:unitarize_link_test> ${MPIEXEC_POSTFLAGS}
                     --dim 2 4 6 8 --prec ${prec}
                     --gtest_output=xml:unitarize_link_test_${prec}.xml)

    add_test(NAME hisq_paths_force_${prec}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:hisq_paths_force_test> ${MPIEXEC_POSTFLAGS}
                     --dim 2 4 6 8 --prec ${prec}
                     --gtest_output=xml:hisq_paths_force_test_${prec}.xml)

    add_test(NAME hisq_unitarize_force_${prec}
             COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:hisq_unitarize_force_test> ${MPIEXEC_POSTFLAGS}
                     --dim 2 4 6 8 --prec ${prec}
                     --gtest_output=xml:hisq_unitarize_force_test_${prec}.xml)

    set(KERNEL_TYPE TwoLink GaussianSmear)
    foreach(kerneltp IN LISTS KERNEL_TYPE)
      if(${kerneltp} STREQUAL "TwoLink")
	set(laplace3D 4)
	set(smear_t0 -1)
      elseif(${kerneltp} STREQUAL "GaussianSmear")
	set(laplace3D 3)
	set(smear_t0 1)
      endif()	    
      add_test(NAME staggered_gsmear_${kerneltp}_${prec}
        COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:staggered_gsmear_test> ${MPIEXEC_POSTFLAGS}
        --dim 6 8 10 12 --prec ${prec}
        --test ${kerneltp}
	--laplace3D ${laplace3D}
	--smear-t0 ${smear_t0}
        --gtest_output=xml:staggered_gsmear_test_${kerneltp}_${prec}.xml)
    endforeach(kerneltp)
  endif()

endforeach(prec)

add_test(NAME gauge_alg
  COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:gauge_alg_test> ${MPIEXEC_POSTFLAGS}
  --dim 4 6 8 10
  --gtest_output=xml:gauge_alg_test.xml)

if (TARGET dilution_test)
  add_test(NAME dilution_test
    COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:dilution_test> ${MPIEXEC_POSTFLAGS}
    --dim 4 6 8 10 --dilution-block-size 4 6 4 5
    --gtest_output=xml:dilution_test.xml)
endif()

if(QUDA_QIO)
  add_test(NAME io_test
           COMMAND ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:io_test> ${MPIEXEC_POSTFLAGS}
                   --dim 4 6 8 10
                   --gtest_output=xml:io_test.xml)
endif()

add_test(NAME tune_test
         COMMAND  ${QUDA_CTEST_LAUNCH} $<TARGET_FILE:tune_test> ${MPIEXEC_POSTFLAGS}
                   --gtest_output=xml:tune_test.xml)