Rework Fortran configure to allow cross compile overrides (#5720)

Behavior:
Modify HDF5UseFortran.cmake to handle cross-compilation by providing default KINDs and sizes when CMAKE_CROSSCOMPILING is true.
Default values for INTEGER and REAL KINDs and their sizes are set when cross-compiling.
Error messages are adjusted to reflect cross-compilation scenarios.
Logic:
Conditional checks added for CMAKE_CROSSCOMPILING to determine if default values should be used.
Default values include INTEGER KINDs {1,2,4,8,16} and REAL KINDs {4,8,10,16}.
Default sizes for native kinds are set to 4 for INTEGER and REAL, and 8 for DOUBLE PRECISION when cross-compiling.
Misc:
Adjustments to verbose messages to indicate when defaults are used during cross-compilation.

.github/workflows/call-workflows.yml

@@ -84,6 +84,12 @@ jobs:
             thread_safety: ""
             build_mode: "Debug"
 
+    call-release-cross:
+        name: "Release Cross Compile Workflows"
+        uses: ./.github/workflows/cross-compile.yml
+        with:
+            build_mode: "Release"
+
     call-release-cmake:
         name: "Release Workflows"
         uses: ./.github/workflows/main.yml

.github/workflows/cross-compile.yml

@@ -0,0 +1,104 @@
+name: hdf5 dev CMake CI
+
+# Triggers the workflow on a call from another workflow
+on:
+  workflow_call:
+    inputs:
+      build_mode:
+        description: "release vs. debug build"
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build_and_test_linux:
+    name: "Ubuntu mingw64-${{ inputs.build_mode }}"
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Install CMake Dependencies (Linux)
+        run: |
+          sudo apt-get update
+          sudo apt-get install ninja-build graphviz
+          sudo apt install libssl3 libssl-dev libcurl4 libcurl4-openssl-dev
+
+      - name: Install Wine64 and dependencies
+        run: |
+          sudo apt update
+          sudo apt install -y wine64 winbind
+
+#      - name: Verify Wine64 installation
+#        run: wine64 --version
+
+      - name: Install MinGW64 Cross-Compiler
+        run: |
+          sudo apt update
+          sudo apt-get install -y mingw-w64
+          sudo apt-get install gfortran-mingw-w64-x86-64-win32
+
+      - name: Install Dependencies
+        uses: ssciwr/doxygen-install@v1
+        with:
+          version: "1.13.2"
+
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - name: Get Sources
+        uses: actions/checkout@v4.1.7
+
+      # CMAKE CONFIGURE
+      - name: CMake Configure
+        run: |
+           mkdir "${{ runner.workspace }}/build"
+           cd "${{ runner.workspace }}/build"
+           cmake -C $GITHUB_WORKSPACE/config/cmake/cacheinit.cmake \
+             -G Ninja \
+             --log-level=VERBOSE \
+             -DCMAKE_TOOLCHAIN_FILE:STRING=config/toolchain/mingw64.cmake \
+             -DCMAKE_BUILD_TYPE=${{ inputs.build_mode }} \
+             -DHDF5_ENABLE_DOXY_WARNINGS:BOOL=ON \
+             -DHDF5_BUILD_DOC:BOOL=ON \
+             -DHDF5_BUILD_JAVA:BOOL=OFF \
+             -DHDF5_ENABLE_PLUGIN_SUPPORT:BOOL=OFF \
+             -DHDF5_ENABLE_ZLIB_SUPPORT:BOOL=ON \
+             -DHDF5_ENABLE_SZIP_SUPPORT:BOOL=ON \
+             -DLIBAEC_USE_LOCALCONTENT:BOOL=OFF \
+             -DZLIB_USE_LOCALCONTENT:BOOL=OFF \
+             -DHDF5_PACK_EXAMPLES:BOOL=ON \
+             -DHDF5_PACKAGE_EXTLIBS:BOOL=ON \
+             -DHDF5_TEST_API:BOOL=OFF \
+             -DHDF5_USE_PREGEN:BOOL=ON \
+             $GITHUB_WORKSPACE
+        shell: bash
+
+      # BUILD
+      - name: CMake Build
+        run: cmake --build . --parallel 3 --config ${{ inputs.build_mode }}
+        working-directory: ${{ runner.workspace }}/build
+
+      # RUN TESTS
+#      - name: CMake Run Tests
+#        run: ctest . --parallel 2 -C ${{ inputs.build_mode }} -V -E "err_compat|filenotclosed|swmr|cache_api"
+#        working-directory: ${{ runner.workspace }}/build
+
+      # RUN Failing TESTS
+#      - name: CMake Run Tests
+#        run: ctest . --parallel 2 -C ${{ inputs.build_mode }} -V -R "err_compat|filenotclosed|swmr|cache_api"
+#        working-directory: ${{ runner.workspace }}/build
+#        continue-on-error: true
+
+      - name: CMake Run Package
+        run: cpack -C ${{ inputs.build_mode }} -V
+        working-directory: ${{ runner.workspace }}/build
+
+      - name: List files in the space
+        run: |
+               ls -l ${{ runner.workspace }}/build
+
+      - name: Save published binary (linux)
+        uses: actions/upload-artifact@v4
+        with:
+          name: tgz-ubuntu-2404_mingw64-${{ inputs.build_mode }}-binary
+          path: ${{ runner.workspace }}/build/HDF5-*-win64.zip
+          if-no-files-found: error # 'warn' or 'ignore' are also available, defaults to `warn`
+        if:  ${{ inputs.build_mode != 'Debug' }}

CMakeLists.txt

@@ -325,6 +325,12 @@ set (HDF5_DOXYGEN_DIR              ${HDF5_SOURCE_DIR}/doxygen)
 
 set (HDF5_SRC_INCLUDE_DIRS ${HDF5_SRC_DIR})
 
+if (HDF5_USE_PREGEN)
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_USE_PREGEN_DIR})
+else ()
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_F90_SRC_BINARY_DIR})
+endif ()
+
 #-----------------------------------------------------------------------------
 # parse the full version number from H5public.h and include in H5_VERS_INFO
 #-----------------------------------------------------------------------------

HDF5Examples/C/H5D/CMakeLists.txt

@@ -12,7 +12,7 @@ foreach (example_name ${common_examples})
   else ()
     add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
   endif ()
-  target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_${example_name}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -38,7 +38,7 @@ endforeach ()
 if (HDF5_VERSION_MAJOR VERSION_GREATER_EQUAL "1.8")
   foreach (example_name ${1_8_examples})
     add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
-    target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+    target_compile_options (${EXAMPLE_VARNAME}_${example_name}
         PRIVATE
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -217,18 +217,18 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -238,12 +238,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -253,7 +255,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()

HDF5Examples/C/H5FLT/CMakeLists.txt

@@ -174,7 +174,7 @@ endif ()
 foreach (example ${dyn_examples})
   add_executable (${EXAMPLE_VARNAME}_${example} ${PROJECT_SOURCE_DIR}/${example}.c)
   TARGET_C_PROPERTIES (${EXAMPLE_VARNAME}_${example} ${LIB_TYPE})
-  target_compile_options(${EXAMPLE_VARNAME}_${example}
+  target_compile_options (${EXAMPLE_VARNAME}_${example}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -196,8 +196,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove
-            -E remove
             ${testname}.out
             ${testname}.out.err
             ${testname}.ddl.out
@@ -212,7 +211,6 @@ if (H5EXAMPLE_BUILD_TESTING)
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}-ERR
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -228,7 +226,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname}-ERR PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname}-ERR PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
@@ -240,7 +241,6 @@ if (H5EXAMPLE_BUILD_TESTING)
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -252,7 +252,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     endif ()
     set (last_test "${EXAMPLE_VARNAME}_${testname}")
     if (HDF5_PROVIDES_TOOLS)
@@ -260,7 +263,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=--enable-error-stack;-p;${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -278,7 +280,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=--enable-error-stack;-pH;${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -296,7 +297,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=--enable-error-stack;-p;${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -311,7 +311,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
       endif ()
-      set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+      set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       set (last_test "${EXAMPLE_VARNAME}_H5DUMP-${testname}")
     endif ()
   endmacro ()
@@ -320,17 +323,17 @@ if (H5EXAMPLE_BUILD_TESTING)
   # Copy all the HDF5 files from the source directory into the test directory
   # --------------------------------------------------------------------
   foreach (h5_file ${dyn_examples})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}.tst" "${PROJECT_BINARY_DIR}/${h5_file}.tst" "example_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}.tst" "${PROJECT_BINARY_DIR}/${h5_file}.tst" "example_files")
     if (WIN32 AND MSVC_VERSION LESS 1900 AND ${h5_file} MATCHES "h5ex_d_zfp")
-      HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/tfiles/h5ex_d_zfp.wddl" "${PROJECT_BINARY_DIR}/h5ex_d_zfp.ddl" "example_files")
+      HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/tfiles/h5ex_d_zfp.wddl" "${PROJECT_BINARY_DIR}/h5ex_d_zfp.ddl" "example_files")
     else ()
-      HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}.ddl" "${PROJECT_BINARY_DIR}/${h5_file}.ddl" "example_files")
+      HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}.ddl" "${PROJECT_BINARY_DIR}/${h5_file}.ddl" "example_files")
     endif()
   endforeach ()
   foreach (h5_file ${LIST_HDF5_TEST_FILES} ${LIST_OTHER_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "example_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/tfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "example_files")
   endforeach ()
-  add_custom_target(${EXAMPLE_VARNAME}_example_files ALL COMMENT "Copying files needed by example tests" DEPENDS ${example_files_list})
+  add_custom_target (${EXAMPLE_VARNAME}_example_files ALL COMMENT "Copying files needed by example tests" DEPENDS ${example_files_list})
 
   foreach (h5_file ${dyn_examples})
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)

HDF5Examples/C/H5G/CMakeLists.txt

@@ -12,7 +12,7 @@ foreach (example_name ${common_examples})
   else ()
     add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
   endif ()
-  target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_${example_name}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -229,18 +229,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_DUMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -250,12 +247,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -265,20 +264,22 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
     endif ()
     endif ()
   endmacro ()
 
   macro (ADD_H5_DUMP_TEST testname)
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -292,7 +293,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -302,7 +302,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -310,19 +313,17 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_DUMP2_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove
-            -E remove
             ${testname}1.h5
             ${testname}2.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -332,12 +333,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}1
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${testname}1.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -347,11 +350,13 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname}1 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname}1 PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}2
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${testname}2.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -361,7 +366,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname}2 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_H5DUMP-${testname}1)
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname}2 PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_H5DUMP-${testname}1
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -369,18 +377,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_CMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.out.tmp
-            -E remove
-            ${testname}.out.tmp
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -390,7 +395,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     endif ()
   endmacro ()
 

HDF5Examples/C/H5T/CMakeLists.txt

@@ -12,7 +12,7 @@ foreach (example_name ${common_examples})
   else ()
     add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
   endif ()
-  target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_${example_name}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -350,18 +350,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -371,12 +368,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -386,7 +385,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -394,18 +396,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_CMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -415,7 +414,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     endif ()
   endmacro ()
 

HDF5Examples/C/H5VDS/CMakeLists.txt

@@ -12,7 +12,7 @@ include (C_sourcefiles.cmake)
 if (HDF5_VERSION_MAJOR VERSION_GREATER_EQUAL "1.10")
   foreach (example_name ${1_10_examples})
     add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
-    target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+    target_compile_options (${EXAMPLE_VARNAME}_${example_name}
         PRIVATE
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -124,18 +124,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}*.h5
-            -E remove
-            ${testname}*.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -145,12 +142,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -160,7 +159,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()

HDF5Examples/C/HL/CMakeLists.txt

@@ -8,7 +8,7 @@ include (C_sourcefiles.cmake)
 
 foreach (example_name ${common_examples})
   add_executable (${EXAMPLE_VARNAME}_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
-  target_compile_options(${EXAMPLE_VARNAME}_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_${example_name}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -121,7 +121,7 @@ if (HDF5_PROVIDES_TOOLS)
   )
   foreach (example_name ${common_examples})
     if (NOT ${example_name} STREQUAL "h5ex_lite1" AND NOT ${example_name} STREQUAL "h5ex_lite2")
-      if (H5EX_WORDS_BIGENDIAN)
+      if (H5EXAMPLE_WORDS_BIGENDIAN)
         add_custom_command (
             TARGET     ${EXAMPLE_VARNAME}_${example_name}
             POST_BUILD
@@ -195,18 +195,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -216,12 +213,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -231,7 +230,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -239,18 +241,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_NOCMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -260,12 +259,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -276,7 +277,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-${testname} PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -292,20 +296,23 @@ if (H5EXAMPLE_BUILD_TESTING)
   # special test for h5ex_lite1 and h5ex_lite2
   add_test (
       NAME ${EXAMPLE_VARNAME}_h5ex_lite-clearall
-      COMMAND    ${CMAKE_COMMAND}
+      COMMAND ${CMAKE_COMMAND} -E remove h5ex_lite1.h5
-          -E remove
-          h5ex_lite1.h5
   )
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME ${EXAMPLE_VARNAME}_h5ex_lite1 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite1>)
+    add_test (NAME ${EXAMPLE_VARNAME}_h5ex_lite1 COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite1>)
-    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite1 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite-clearall)
+    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite1 PROPERTIES
-    add_test (NAME ${EXAMPLE_VARNAME}_h5ex_lite2 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite2>)
+        DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite-clearall
-    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite2 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite1)
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
+    add_test (NAME ${EXAMPLE_VARNAME}_h5ex_lite2 COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite2>)
+    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite2 PROPERTIES
+        DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite1
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
   else ()
     add_test (
         NAME ${EXAMPLE_VARNAME}_h5ex_lite1
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite1>"
             -D "TEST_ARGS:STRING="
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -315,11 +322,13 @@ if (H5EXAMPLE_BUILD_TESTING)
             -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
             -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
     )
-    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite1 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite-clearall)
+    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite1 PROPERTIES
+        DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite-clearall
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     add_test (
         NAME ${EXAMPLE_VARNAME}_h5ex_lite2
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_h5ex_lite2>"
             -D "TEST_ARGS:STRING="
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -329,6 +338,9 @@ if (H5EXAMPLE_BUILD_TESTING)
             -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
             -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
     )
-    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite2 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite1)
+    set_tests_properties (${EXAMPLE_VARNAME}_h5ex_lite2 PROPERTIES
+        DEPENDS ${EXAMPLE_VARNAME}_h5ex_lite1
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
   endif ()
 endif ()

HDF5Examples/C/TUTR/CMakeLists.txt

@@ -8,7 +8,7 @@ include (C_sourcefiles.cmake)
 
 foreach (example_name ${examples})
   add_executable (${EXAMPLE_VARNAME}_tutr_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.c)
-  target_compile_options(${EXAMPLE_VARNAME}_tutr_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_tutr_${example_name}
       PRIVATE
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -67,7 +67,7 @@ if (H5EXAMPLE_BUILD_TESTING)
    # Remove any output file left over from previous test run
   add_test (
       NAME ${EXAMPLE_VARNAME}_tutr-clear-objects
-      COMMAND    ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_tutr_CLEANFILES}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_tutr_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_tutr-clear-objects PROPERTIES
       FIXTURES_SETUP clear_${EXAMPLE_VARNAME}_tutr
@@ -75,7 +75,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   add_test (
       NAME ${EXAMPLE_VARNAME}_tutr-clean-objects
-      COMMAND    ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_tutr_CLEANFILES}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_tutr_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_tutr-clean-objects PROPERTIES
       FIXTURES_CLEANUP clear_${EXAMPLE_VARNAME}_tutr
@@ -84,12 +84,11 @@ if (H5EXAMPLE_BUILD_TESTING)
 
   macro (ADD_H5_TEST testname)
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_tutr_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_tutr_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_tutr_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_tutr_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_tutr_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_tutr_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -100,7 +99,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_tutr_${testname} PROPERTIES FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_tutr)
+    set_tests_properties (${EXAMPLE_VARNAME}_tutr_${testname} PROPERTIES
+        FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_tutr
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (last_test)
       set_tests_properties (${EXAMPLE_VARNAME}_tutr_${testname} PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/CXX/H5D/CMakeLists.txt

@@ -9,7 +9,7 @@ include (C_sourcefiles.cmake)
 if (HDF5_VERSION_MAJOR VERSION_GREATER_EQUAL "1.8")
   foreach (example_name ${examples})
     add_executable (${EXAMPLE_VARNAME}_cpp_ex_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.cpp)
-    target_compile_options(${EXAMPLE_VARNAME}_cpp_ex_${example_name}
+    target_compile_options (${EXAMPLE_VARNAME}_cpp_ex_${example_name}
         PRIVATE
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -35,8 +35,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   add_test (
       NAME ${EXAMPLE_VARNAME}_cpp_ex-clear-objects
-      COMMAND    ${CMAKE_COMMAND}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
-          -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex-clear-objects PROPERTIES
       FIXTURES_SETUP clear_${EXAMPLE_VARNAME}_cpp_ex
@@ -44,8 +43,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   add_test (
       NAME ${EXAMPLE_VARNAME}_cpp_ex-clean-objects
-      COMMAND    ${CMAKE_COMMAND}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
-          -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex-clean-objects PROPERTIES
       FIXTURES_CLEANUP clear_${EXAMPLE_VARNAME}_cpp_ex
@@ -54,12 +52,11 @@ if (H5EXAMPLE_BUILD_TESTING)
 
   macro (ADD_H5_TEST testname)
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -70,7 +67,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_cpp_ex)
+    set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES
+        FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_cpp_ex
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (last_test)
       set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/CXX/HL/CMakeLists.txt

@@ -9,7 +9,7 @@ include (C_sourcefiles.cmake)
 if (HDF5_VERSION_MAJOR VERSION_GREATER_EQUAL "1.8")
   foreach (example_name ${common_examples})
     add_executable (${EXAMPLE_VARNAME}_cpp_ex_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.cpp)
-    target_compile_options(${EXAMPLE_VARNAME}_cpp_ex_${example_name}
+    target_compile_options (${EXAMPLE_VARNAME}_cpp_ex_${example_name}
         PRIVATE
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -31,8 +31,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   add_test (
       NAME ${EXAMPLE_VARNAME}_cpp_ex-clear-objects
-      COMMAND    ${CMAKE_COMMAND}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
-          -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex-clear-objects PROPERTIES
       FIXTURES_SETUP clear_${EXAMPLE_VARNAME}_cpp_ex
@@ -40,8 +39,7 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   add_test (
       NAME ${EXAMPLE_VARNAME}_cpp_ex-clean-objects
-      COMMAND    ${CMAKE_COMMAND}
+      COMMAND ${CMAKE_COMMAND} -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
-          -E remove ${${EXAMPLE_VARNAME}_cpp_ex_CLEANFILES}
   )
   set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex-clean-objects PROPERTIES
       FIXTURES_CLEANUP clear_${EXAMPLE_VARNAME}_cpp_ex
@@ -50,12 +48,11 @@ if (H5EXAMPLE_BUILD_TESTING)
 
   macro (ADD_H5_TEST testname)
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -66,7 +63,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_cpp_ex)
+    set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES
+        FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_cpp_ex
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (last_test)
       set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/CXX/TUTR/CMakeLists.txt

@@ -9,7 +9,7 @@ include (C_sourcefiles.cmake)
 if (HDF5_VERSION_MAJOR VERSION_GREATER_EQUAL "1.8")
   foreach (example_name ${examples})
     add_executable (${EXAMPLE_VARNAME}_cpp_ex_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.cpp)
-    target_compile_options(${EXAMPLE_VARNAME}_cpp_ex_${example_name}
+    target_compile_options (${EXAMPLE_VARNAME}_cpp_ex_${example_name}
         PRIVATE
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
             "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_18_API}>:-DH5_USE_18_API>"
@@ -29,18 +29,15 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_cpp_ex_${testname}-clearall)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_cpp_ex_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_cpp_ex_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -50,7 +47,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_cpp_ex_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_cpp_ex_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     endif ()
     if (last_test)
       set_tests_properties (${EXAMPLE_VARNAME}_cpp_ex_${testname} PROPERTIES DEPENDS ${last_test})

HDF5Examples/FORTRAN/H5D/CMakeLists.txt

@@ -9,8 +9,8 @@ project (HDF5Examples_FORTRAN_H5D Fortran)
 #-----------------------------------------------------------------------------
 # Setup include Directories
 #-----------------------------------------------------------------------------
-set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES
+set_directory_properties (PROPERTIES INCLUDE_DIRECTORIES
-  "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+    "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
 )
 
 #-----------------------------------------------------------------------------
@@ -20,7 +20,7 @@ include (Fortran_sourcefiles.cmake)
 
 foreach (example_name ${common_examples})
   add_executable (${EXAMPLE_VARNAME}_f90_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.F90)
-  target_compile_options(${EXAMPLE_VARNAME}_f90_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_f90_${example_name}
       PRIVATE
           "-DH5_LIBVER_DIR=${H5_LIBVER_DIR}"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
@@ -240,25 +240,20 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -268,15 +263,19 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (last_test)
-        set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+        )
       endif ()
       set (last_test "${EXAMPLE_VARNAME}_f90_${testname}")
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -286,14 +285,15 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (last_test "${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}")
       endif ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/FORTRAN/H5G/CMakeLists.txt

@@ -9,8 +9,8 @@ project (HDF5Examples_FORTRAN_H5G Fortran)
 #-----------------------------------------------------------------------------
 # Setup include Directories
 #-----------------------------------------------------------------------------
-set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES
+set_directory_properties (PROPERTIES INCLUDE_DIRECTORIES
-  "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+    "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
 )
 
 #-----------------------------------------------------------------------------
@@ -20,7 +20,7 @@ include (Fortran_sourcefiles.cmake)
 
 foreach (example_name ${common_examples})
   add_executable (${EXAMPLE_VARNAME}_f90_${example_name} ${PROJECT_SOURCE_DIR}/${example_name}.F90)
-  target_compile_options(${EXAMPLE_VARNAME}_f90_${example_name}
+  target_compile_options (${EXAMPLE_VARNAME}_f90_${example_name}
       PRIVATE
           "-DH5_LIBVER_DIR=${H5_LIBVER_DIR}"
           "$<$<BOOL:${${EXAMPLE_VARNAME}_USE_16_API}>:-DH5_USE_16_API>"
@@ -187,25 +187,23 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_DUMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
+      )
-              ${testname}.h5
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -215,6 +213,9 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (last_test)
         set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${last_test})
       endif ()
@@ -223,7 +224,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -233,14 +233,15 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (last_test "${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}")
       endif ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${last_test})
     endif ()
@@ -248,20 +249,17 @@ if (H5EXAMPLE_BUILD_TESTING)
 
   macro (ADD_H5_DUMP_TEST testname)
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -271,6 +269,9 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (last_test)
         set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${last_test})
       endif ()
@@ -279,7 +280,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}
            COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -289,14 +289,15 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (last_test "${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}")
       endif ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${last_test})
     endif ()
@@ -305,20 +306,20 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_DUMP2_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove
-            -E remove
             ${testname}.h5
             ${testname}1.h5
             ${testname}2.h5
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
-      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
     else ()
@@ -326,7 +327,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
                 -D "TEST_ARGS:STRING="
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -340,7 +340,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
                 -D "TEST_ARGS:STRING="
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -351,12 +350,14 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
       endif ()
-      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (HDF5_PROVIDES_TOOLS)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}1
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${testname}1.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -366,11 +367,13 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}1 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}1 PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}2
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${testname}2.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -380,7 +383,10 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}2 PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}1)
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}2 PROPERTIES
+            DEPENDS ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}1
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     endif ()
   endmacro ()
@@ -388,17 +394,14 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_CMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.out.tmp
-            -E remove
-            ${testname}.out.tmp
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -409,12 +412,13 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
+    set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+        DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.out.tmp
-            -E remove
-            ${testname}.out.tmp
     )
     set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
   endmacro ()

HDF5Examples/FORTRAN/H5T/CMakeLists.txt

@@ -4,8 +4,8 @@ project (HDF5Examples_FORTRAN_H5T Fortran)
 #-----------------------------------------------------------------------------
 # Setup include Directories
 #-----------------------------------------------------------------------------
-set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES
+set_directory_properties (PROPERTIES INCLUDE_DIRECTORIES
-  "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+    "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
 )
 
 #-----------------------------------------------------------------------------
@@ -301,25 +301,23 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
+      )
-              ${testname}.h5
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -329,6 +327,9 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (last_test)
         set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${last_test})
       endif ()
@@ -337,7 +338,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -347,14 +347,15 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (last_test "${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}")
       endif ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${last_test})
     endif ()
@@ -363,17 +364,14 @@ if (H5EXAMPLE_BUILD_TESTING)
   macro (ADD_H5_CMP_TEST testname)
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clearall
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -384,12 +382,13 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
+    set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+        DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     add_test (
         NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-        COMMAND    ${CMAKE_COMMAND}
+        COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-            -E remove
-            ${testname}.h5
     )
     set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
   endmacro ()

HDF5Examples/FORTRAN/HL/CMakeLists.txt

@@ -9,8 +9,8 @@ project (HDF5Examples_FORTRAN_HL Fortran)
 #-----------------------------------------------------------------------------
 # Setup include Directories
 #-----------------------------------------------------------------------------
-set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES
+set_directory_properties (PROPERTIES INCLUDE_DIRECTORIES
-  "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+    "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
 )
 
 #-----------------------------------------------------------------------------
@@ -161,7 +161,7 @@ if (H5EXAMPLE_BUILD_TESTING)
             ${testname}.h5
     )
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}-clearall)
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
@@ -169,12 +169,14 @@ if (H5EXAMPLE_BUILD_TESTING)
               -E remove
               ${testname}.h5
       )
-      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${EXAMPLE_VARNAME}_f90_${testname})
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES
+          DEPENDS ${EXAMPLE_VARNAME}_f90_${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -184,6 +186,9 @@ if (H5EXAMPLE_BUILD_TESTING)
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
+      set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (last_test)
         set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname} PROPERTIES DEPENDS ${last_test})
       endif ()
@@ -192,7 +197,6 @@ if (H5EXAMPLE_BUILD_TESTING)
         add_test (
             NAME ${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=${H5EXAMPLE_HDF5_DUMP_EXECUTABLE}"
                 -D "TEST_ARGS:STRING=${ARGN};${testname}.h5"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -203,14 +207,15 @@ if (H5EXAMPLE_BUILD_TESTING)
                 -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_LIB_DIRECTORY}"
                 -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES DEPENDS ${last_test})
+        set_tests_properties (${EXAMPLE_VARNAME}_H5DUMP-f90_${testname} PROPERTIES
+            DEPENDS ${last_test}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (last_test "${EXAMPLE_VARNAME}_H5DUMP-f90_${testname}")
       endif ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_${testname}-clean
-          COMMAND    ${CMAKE_COMMAND}
+          COMMAND ${CMAKE_COMMAND} -E remove ${testname}.h5
-              -E remove
-              ${testname}.h5
       )
       set_tests_properties (${EXAMPLE_VARNAME}_f90_${testname}-clean PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/FORTRAN/TUTR/CMakeLists.txt

@@ -5,7 +5,7 @@ project (HDF5Examples_FORTRAN_TUTR Fortran)
 # Setup include Directories
 #-----------------------------------------------------------------------------
 set_directory_properties(PROPERTIES INCLUDE_DIRECTORIES
-  "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
+    "${CMAKE_Fortran_MODULE_DIRECTORY}${H5EXAMPLE_MOD_EXT};${HDF5_F90_BINARY_DIR};${PROJECT_BINARY_DIR};${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
 )
 
 #-----------------------------------------------------------------------------
@@ -89,12 +89,11 @@ if (H5EXAMPLE_BUILD_TESTING)
   )
   macro (ADD_H5_TEST testname)
     if (HDF5_USING_ANALYSIS_TOOL)
-      add_test (NAME ${EXAMPLE_VARNAME}_f90_tutr_${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_tutr_${testname}>)
+      add_test (NAME ${EXAMPLE_VARNAME}_f90_tutr_${testname} COMMAND $<TARGET_FILE:${EXAMPLE_VARNAME}_f90_tutr_${testname}>)
     else ()
       add_test (
           NAME ${EXAMPLE_VARNAME}_f90_tutr_${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${EXAMPLE_VARNAME}_f90_tutr_${testname}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -105,7 +104,10 @@ if (H5EXAMPLE_BUILD_TESTING)
               -P "${H5EXAMPLE_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-    set_tests_properties (${EXAMPLE_VARNAME}_f90_tutr_${testname} PROPERTIES FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_f90_tutr)
+    set_tests_properties (${EXAMPLE_VARNAME}_f90_tutr_${testname} PROPERTIES
+        FIXTURES_REQUIRED clear_${EXAMPLE_VARNAME}_f90_tutr
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (last_test)
       set_tests_properties (${EXAMPLE_VARNAME}_f90_tutr_${testname} PROPERTIES DEPENDS ${last_test})
     endif ()

HDF5Examples/PYTHON/CMakeLists.txt

@@ -32,7 +32,7 @@ if (H5EXAMPLE_BUILD_TESTING)
       WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
   )
 
-  add_custom_target(${EXAMPLE_VARNAME}_PY-copy-objects ALL COMMENT "Copying Python source files")
+  add_custom_target (${EXAMPLE_VARNAME}_PY-copy-objects ALL COMMENT "Copying Python source files")
   foreach (example_name ${examples})
     add_custom_command (
         TARGET     ${EXAMPLE_VARNAME}_PY-copy-objects

HDF5Examples/config/toolchain/aarch64.cmake

@@ -1,7 +1,7 @@
 set(TOOLCHAIN_PREFIX aarch64-linux-gnu)
-set(ANDROID_NDK /opt/android-ndk-linux)
+set(CMAKE_SYSTEM_NAME Linux)
-set (CMAKE_SYSTEM_NAME Android)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set (CMAKE_ANDROID_ARCH_ABI x86_64)
+#set (CMAKE_ANDROID_ARCH_ABI x86_64)
 #set (CMAKE_ANDROID_STANDALONE_TOOLCHAIN ${ANDROID_NDK}/build/cmake/android.toolchain.cmake)
 set (CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
 set (CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
@@ -11,7 +11,8 @@ set (CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
 set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set (CMAKE_CROSSCOMPILING_EMULATOR qemu-aarch64)
+set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-aarch64-static;-L;/usr/aarch64-linux-gnu/" CACHE FILEPATH "Path to the emulator for the target system.")
 
 include_directories(/usr/${TOOLCHAIN_PREFIX}/include)
 

HDF5Examples/config/toolchain/clang.cmake

@@ -9,6 +9,7 @@ if(WIN32)
 else()
   set (CMAKE_C_COMPILER clang)
   set (CMAKE_CXX_COMPILER clang++)
+  #set (CMAKE_Fortran_COMPILER flang)
 endif()
 set (CMAKE_EXPORT_COMPILE_COMMANDS ON)
 

HDF5Examples/config/toolchain/crosscompile-readme.cmake

@@ -0,0 +1,43 @@
+# This CMake toolchain file configures cross-compilation settings for building HDF5 on non-native platforms.
+# Copy this file and rename it (e.g., to crosscompile-myplatform.cmake).
+# Replace the placeholder values with actual values for your target system and compilers.
+# Then use this file with CMake by specifying it with the -DCMAKE_TOOLCHAIN_FILE option.
+
+# Set the target system name for cross-compiling
+set (CMAKE_SYSTEM_NAME system_name)
+
+# Specify the compiler vendor and compilers for C, C++, and Fortran
+set (CMAKE_COMPILER_VENDOR "compiler_name")
+set (CMAKE_C_COMPILER compiler_cc)
+set (CMAKE_CXX_COMPILER compiler_c++)
+set (CMAKE_Fortran_COMPILER compiler_fortran)
+
+# Optional: Specify an emulator for running binaries during cross-compilation
+set (CMAKE_CROSSCOMPILING_EMULATOR "")
+
+# Fortran kind and precision settings for cross-compiling
+set (PAC_FC_ALL_INTEGER_KINDS "\{x,y,z\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
+set (PAC_FC_ALL_REAL_KINDS "\{x,y,z\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
+set (${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION X CACHE INTERNAL "Maximum decimal precision for REALs in Fortran")
+set (PAC_FORTRAN_NUM_INTEGER_KINDS "Y" CACHE INTERNAL "Number of valid integer kinds for Fortran")
+set (PAC_FORTRAN_NUM_REAL_KINDS "Z" CACHE INTERNAL "Number of valid real kinds for Fortran")
+
+# Fortran configuration variables for HDF5
+set (${HDF_PREFIX}_H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = Y")
+set (${HDF_PREFIX}_H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/x,y,z/)")
+
+# If using ISO_FORTRAN_ENV, set logical kind variables
+if (${PAC_USE_ISO_FORTRAN_ENV})
+  set (PAC_FORTRAN_NUM_LOGICAL_KINDS "W" CACHE INTERNAL "Find available LOGICAL KINDs for Fortran")
+  set (PAC_FC_ALL_LOGICAL_KINDS "\{x,y,z\}" CACHE INTERNAL "LOGICAL KINDS FOUND for Fortran")
+endif ()
+
+# Native kind and sizeof settings for Fortran types
+set (PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{x,y,z\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
+set (PAC_FC_ALL_REAL_KINDS_SIZEOF "\{x,y,z\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
+set (PAC_FORTRAN_NATIVE_INTEGER_SIZEOF i CACHE INTERNAL "Find sizeof of native kinds sizeof INTEGER")
+set (PAC_FORTRAN_NATIVE_INTEGER_KIND j CACHE INTERNAL "Find sizeof of native kinds kind of INTEGER")
+set (PAC_FORTRAN_NATIVE_REAL_SIZEOF k CACHE INTERNAL "Find sizeof of native kinds sizeof REAL")
+set (PAC_FORTRAN_NATIVE_REAL_KIND m CACHE INTERNAL "Find sizeof of native kinds kind of REAL")
+set (PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF n CACHE INTERNAL "Find sizeof of native kinds sizeof DOUBLE PRECISION")
+set (PAC_FORTRAN_NATIVE_DOUBLE_KIND o CACHE INTERNAL "Find sizeof of native kinds kind of DOUBLE PRECISION")

HDF5Examples/config/toolchain/intel.cmake

@@ -4,7 +4,11 @@
 set(CMAKE_COMPILER_VENDOR "intel")
 
 set(CMAKE_C_COMPILER icx)
-set(CMAKE_CXX_COMPILER icpx)
+if(WIN32)
+ set(CMAKE_CXX_COMPILER icx)
+else()
+  set(CMAKE_CXX_COMPILER icpx)
+endif()
 set(CMAKE_Fortran_COMPILER ifx)
 
 # the following is used if cross-compiling

HDF5Examples/config/toolchain/mingw64.cmake

@@ -1,14 +1,34 @@
-set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
+set (TOOLCHAIN_PREFIX x86_64-w64-mingw32)
 set (CMAKE_SYSTEM_NAME Windows)
-set (CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+set (CMAKE_SYSTEM_PROCESSOR x86_64)
-set (CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+
-set (CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
+# specify the cross compiler
-set (CMAKE_Fortran_COMPILER ${TOOLCHAIN_PREFIX}-gfortran)
+if (NOT DEFINED ENV{CC})
-set (CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
+  set (CMAKE_C_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-gcc)
+endif ()
+if (NOT DEFINED ENV{CXX})
+set (CMAKE_CXX_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-g++)
+endif ()
+if (NOT DEFINED ENV{FC})
+set (CMAKE_Fortran_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-gfortran)
+# set the resource compiler (RHBZ #652435)
+endif ()
+if (NOT DEFINED ENV{RC})
+set (CMAKE_RC_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-windres)
+endif ()
+
+set (CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw)
+
+# search for programs in the build host directories
 set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries, headers and packages in the target directories
 set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
 set (CMAKE_CROSSCOMPILING_EMULATOR wine64)
+set (CROSSCOMPILING_PATH "WINEPATH=/usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/")
 
-include_directories(/usr/${TOOLCHAIN_PREFIX}/include)
 set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS On CACHE BOOL "Export windows symbols")
+
+set (CMAKE_AR:FILEPATH /usr/bin/${TOOLCHAIN_PREFIX}-ar)
+set (CMAKE_RANLIB:FILEPATH /usr/bin/${TOOLCHAIN_PREFIX}-ranlib)

c++/test/CMakeTests.cmake

@@ -9,8 +9,8 @@
 # If you do not have access to either file, you may request a copy from
 # help@hdfgroup.org.
 #
-HDFTEST_COPY_FILE("${HDF5_CPP_TEST_SOURCE_DIR}/th5s.h5" "${PROJECT_BINARY_DIR}/th5s.h5" "cpp_testhdf5_files")
+HDFTEST_COPY_FILE ("${HDF5_CPP_TEST_SOURCE_DIR}/th5s.h5" "${PROJECT_BINARY_DIR}/th5s.h5" "cpp_testhdf5_files")
-add_custom_target(cpp_testhdf5_files ALL COMMENT "Copying files needed by cpp_testhdf5 tests" DEPENDS ${cpp_testhdf5_files_list})
+add_custom_target (cpp_testhdf5_files ALL COMMENT "Copying files needed by cpp_testhdf5 tests" DEPENDS ${cpp_testhdf5_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -18,10 +18,9 @@ add_custom_target(cpp_testhdf5_files ALL COMMENT "Copying files needed by cpp_te
 ##############################################################################
 ##############################################################################
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME CPP_testhdf5 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:cpp_testhdf5>)
+  add_test (NAME CPP_testhdf5 COMMAND $<TARGET_FILE:cpp_testhdf5>)
 else ()
   add_test (NAME CPP_testhdf5 COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:cpp_testhdf5>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -34,6 +33,7 @@ else ()
 endif ()
 set_tests_properties (CPP_testhdf5 PROPERTIES
     WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("CPP_testhdf5" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (CPP_testhdf5 PROPERTIES DISABLED true)

c++/test/CMakeVFDTests.cmake

@@ -15,7 +15,7 @@
 ###           T E S T I N G                                                ###
 ##############################################################################
 ##############################################################################
-H5_CREATE_VFD_DIR()
+H5_CREATE_VFD_DIR ()
 
 ##############################################################################
 ##############################################################################
@@ -27,7 +27,6 @@ macro (ADD_VFD_TEST vfdname resultcode)
     add_test (
         NAME CPP_VFD-${vfdname}-cpp_testhdf5
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:cpp_testhdf5>"
             -D "TEST_ARGS:STRING="
             -D "TEST_VFD:STRING=${vfdname}"
@@ -36,7 +35,10 @@ macro (ADD_VFD_TEST vfdname resultcode)
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
             -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
     )
-    set_tests_properties (CPP_VFD-${vfdname}-cpp_testhdf5 PROPERTIES TIMEOUT ${CTEST_SHORT_TIMEOUT})
+    set_tests_properties (CPP_VFD-${vfdname}-cpp_testhdf5 PROPERTIES
+        TIMEOUT ${CTEST_SHORT_TIMEOUT}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("CPP_VFD-${vfdname}-cpp_testhdf5" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (CPP_VFD-${vfdname}-cpp_testhdf5 PROPERTIES DISABLED true)
     endif ()

config/ConfigureChecks.cmake

@@ -153,12 +153,12 @@ endif ()
 # gcc puts symbols like FLT128_DIG in quadmath.h instead of float.h, so
 # check for that. This is only used by the build system and doesn't need
 # to be exported to H5pubconf.h.
-CHECK_INCLUDE_FILES("quadmath.h" INCLUDE_QUADMATH_H)
+CHECK_INCLUDE_FILES ("quadmath.h" INCLUDE_QUADMATH_H)
 # Convert TRUE/FALSE to 0/1 for preprocessor values in test code, below
 if (${INCLUDE_QUADMATH_H})
-  set(C_INCLUDE_QUADMATH_H 1)
+  set (C_INCLUDE_QUADMATH_H 1)
 else ()
-  set(C_INCLUDE_QUADMATH_H 0)
+  set (C_INCLUDE_QUADMATH_H 0)
 endif ()
 
 if (MINGW OR CYGWIN)
@@ -282,7 +282,7 @@ endif ()
 # MinGW and Cygwin
 if (MINGW OR CYGWIN)
   set (CMAKE_REQUIRED_DEFINITIONS
-    "${CURRENT_TEST_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE"
+      "${CURRENT_TEST_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE"
   )
 endif ()
 
@@ -350,7 +350,11 @@ if (MINGW OR NOT WINDOWS)
   HDF_CHECK_TYPE_SIZE (ptrdiff_t    ${HDF_PREFIX}_SIZEOF_PTRDIFF_T)
 endif ()
 
-HDF_CHECK_TYPE_SIZE (off_t          ${HDF_PREFIX}_SIZEOF_OFF_T)
+if (NOT MINGW)
+  HDF_CHECK_TYPE_SIZE (off_t        ${HDF_PREFIX}_SIZEOF_OFF_T)
+else ()
+  set (${HDF_PREFIX}_SIZEOF_OFF_T   4)
+endif ()
 HDF_CHECK_TYPE_SIZE (time_t         ${HDF_PREFIX}_SIZEOF_TIME_T)
 
 #-----------------------------------------------------------------------------
@@ -371,12 +375,12 @@ if (MINGW OR NOT WINDOWS)
   #-----------------------------------------------------------------------------
   # Check a bunch of time functions
   #-----------------------------------------------------------------------------
-  CHECK_STRUCT_HAS_MEMBER("struct tm" tm_gmtoff "time.h" ${HDF_PREFIX}_HAVE_TM_GMTOFF)
+  CHECK_STRUCT_HAS_MEMBER ("struct tm" tm_gmtoff "time.h" ${HDF_PREFIX}_HAVE_TM_GMTOFF)
-  CHECK_STRUCT_HAS_MEMBER("struct tm" __tm_gmtoff "time.h" ${HDF_PREFIX}_HAVE___TM_GMTOFF)
+  CHECK_STRUCT_HAS_MEMBER ("struct tm" __tm_gmtoff "time.h" ${HDF_PREFIX}_HAVE___TM_GMTOFF)
   if (${HDF_PREFIX}_HAVE_SYS_TIME_H)
-    CHECK_STRUCT_HAS_MEMBER("struct tm" tz_minuteswest "sys/types.h;sys/time.h;time.h" ${HDF_PREFIX}_HAVE_STRUCT_TIMEZONE)
+    CHECK_STRUCT_HAS_MEMBER ("struct tm" tz_minuteswest "sys/types.h;sys/time.h;time.h" ${HDF_PREFIX}_HAVE_STRUCT_TIMEZONE)
   else ()
-    CHECK_STRUCT_HAS_MEMBER("struct tm" tz_minuteswest "sys/types.h;time.h" ${HDF_PREFIX}_HAVE_STRUCT_TIMEZONE)
+    CHECK_STRUCT_HAS_MEMBER ("struct tm" tz_minuteswest "sys/types.h;time.h" ${HDF_PREFIX}_HAVE_STRUCT_TIMEZONE)
   endif ()
   CHECK_FUNCTION_EXISTS (gettimeofday      ${HDF_PREFIX}_HAVE_GETTIMEOFDAY)
   foreach (time_test
@@ -457,7 +461,7 @@ foreach (other_test
     HAVE_BUILTIN_EXPECT
     PTHREAD_BARRIER
     HAVE_SOCKLEN_T
-  )
+)
   HDF_FUNCTION_TEST (${other_test})
 endforeach ()
 
@@ -675,17 +679,17 @@ endif ()
 # ----------------------------------------------------------------------
 option (HDF5_ENABLE_MIRROR_VFD "Build the Mirror Virtual File Driver" OFF)
 if (HDF5_ENABLE_MIRROR_VFD)
-  if ( ${HDF_PREFIX}_HAVE_NETINET_IN_H AND
+  if (${HDF_PREFIX}_HAVE_NETINET_IN_H AND
-       ${HDF_PREFIX}_HAVE_NETDB_H      AND
+      ${HDF_PREFIX}_HAVE_NETDB_H      AND
-       ${HDF_PREFIX}_HAVE_ARPA_INET_H  AND
+      ${HDF_PREFIX}_HAVE_ARPA_INET_H  AND
-       ${HDF_PREFIX}_HAVE_SYS_SOCKET_H AND
+      ${HDF_PREFIX}_HAVE_SYS_SOCKET_H AND
-       ${HDF_PREFIX}_HAVE_FORK)
+      ${HDF_PREFIX}_HAVE_FORK)
-      set (${HDF_PREFIX}_HAVE_MIRROR_VFD 1)
+    set (${HDF_PREFIX}_HAVE_MIRROR_VFD 1)
-  else()
+  else ()
-      set (HDF5_ENABLE_MIRROR_VFD OFF CACHE BOOL "Build the Mirror Virtual File Driver" FORCE)
+    set (HDF5_ENABLE_MIRROR_VFD OFF CACHE BOOL "Build the Mirror Virtual File Driver" FORCE)
-      message(WARNING "The socket-based Mirror VFD was requested but cannot be built. System prerequisites are not met.")
+    message (WARNING "The socket-based Mirror VFD was requested but cannot be built. System prerequisites are not met.")
-  endif()
+  endif ()
-endif()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Check if C has __float128 extension (used for Fortran only)
@@ -740,7 +744,7 @@ if (HDF5_BUILD_FORTRAN)
           set (_RUN_OUTPUT_VARIABLE "RUN_OUTPUT_VARIABLE")
         else ()
           set (_RUN_OUTPUT_VARIABLE  "RUN_OUTPUT_STDOUT_VARIABLE")
-        endif()
+        endif ()
         TRY_RUN (RUN_RESULT_VAR COMPILE_RESULT_VAR
             ${CMAKE_BINARY_DIR}
             ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler1.c
@@ -893,12 +897,12 @@ if (${HDF_PREFIX}_HAVE_COMPLEX_H)
     # If using MSVC, the _Complex types (if available) are _Fcomplex, _Dcomplex and _Lcomplex.
     # The standard types are checked for first in case MSVC uses them in the future or in case
     # the compiler used is simulating MSVC and uses the standard types.
-    cmake_push_check_state()
+    cmake_push_check_state ()
     list (APPEND CMAKE_EXTRA_INCLUDE_FILES complex.h)
     HDF_CHECK_TYPE_SIZE ("_Fcomplex" ${HDF_PREFIX}_SIZEOF__FCOMPLEX)
     HDF_CHECK_TYPE_SIZE ("_Dcomplex" ${HDF_PREFIX}_SIZEOF__DCOMPLEX)
     HDF_CHECK_TYPE_SIZE ("_Lcomplex" ${HDF_PREFIX}_SIZEOF__LCOMPLEX)
-    cmake_pop_check_state()
+    cmake_pop_check_state ()
     if (${HDF_PREFIX}_SIZEOF__FCOMPLEX AND ${HDF_PREFIX}_SIZEOF__DCOMPLEX AND
         ${HDF_PREFIX}_SIZEOF__FCOMPLEX)
       set (${HDF_PREFIX}_SIZEOF_FLOAT_COMPLEX ${${HDF_PREFIX}_SIZEOF__FCOMPLEX}
@@ -1119,7 +1123,7 @@ endif ()
 
 #-----------------------------------------------------------------------------
 # Check if the platform has pkg-config support
-find_package(PkgConfig)
+find_package (PkgConfig)
 if (PKG_CONFIG_FOUND)
   set (${HDF_PREFIX}_HAVE_PKGCONFIG 1)
 else ()

config/HDF5UseFortran.cmake

@@ -38,7 +38,7 @@ include (CheckFortranFunctionExists)
 
 # Force lowercase Fortran module file names
 if (CMAKE_Fortran_COMPILER_ID STREQUAL "Cray")
-  set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -ef")
+  set (CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -ef")
 endif ()
 
 set (RUN_OUTPUT_PATH_DEFAULT ${CMAKE_BINARY_DIR})
@@ -55,11 +55,11 @@ macro (FORTRAN_RUN FUNCTION_NAME SOURCE_CODE RUN_RESULT_VAR1 COMPILE_RESULT_VAR1
       set (_RUN_OUTPUT_VARIABLE "RUN_OUTPUT_VARIABLE")
     else ()
       set (_RUN_OUTPUT_VARIABLE  "RUN_OUTPUT_STDOUT_VARIABLE")
-    endif()
+    endif ()
     if (${FUNCTION_NAME} STREQUAL "SIZEOF NATIVE KINDs")
-        set(TMP_CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}")
+        set (TMP_CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS}")
     else ()
-        set(TMP_CMAKE_Fortran_FLAGS "")
+        set (TMP_CMAKE_Fortran_FLAGS "")
     endif ()
     TRY_RUN (RUN_RESULT_VAR COMPILE_RESULT_VAR
         ${CMAKE_BINARY_DIR}
@@ -71,7 +71,7 @@ macro (FORTRAN_RUN FUNCTION_NAME SOURCE_CODE RUN_RESULT_VAR1 COMPILE_RESULT_VAR1
     set (${RETURN_OUTPUT_VAR} ${OUTPUT_VAR})
 
     if (${COMPILE_RESULT_VAR})
-      set(${RETURN_VAR} ${RUN_RESULT_VAR})
+      set (${RETURN_VAR} ${RUN_RESULT_VAR})
       if (${RUN_RESULT_VAR} MATCHES 0)
         message (VERBOSE "Testing Fortran ${FUNCTION_NAME} - OK")
         file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
@@ -88,13 +88,13 @@ macro (FORTRAN_RUN FUNCTION_NAME SOURCE_CODE RUN_RESULT_VAR1 COMPILE_RESULT_VAR1
         file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
             "Determining if the Fortran ${FUNCTION_NAME} compiles failed: ${COMPILE_RESULT_VAR}\n"
         )
-        set(${RETURN_VAR} ${COMPILE_RESULT_VAR})
+        set (${RETURN_VAR} ${COMPILE_RESULT_VAR})
     endif ()
 endmacro ()
 #-----------------------------------------------------------------------------
 #  Check to see C_LONG_DOUBLE is available
 
-READ_SOURCE("PROGRAM PROG_FC_HAVE_C_LONG_DOUBLE" "END PROGRAM PROG_FC_HAVE_C_LONG_DOUBLE" SOURCE_CODE)
+READ_SOURCE ("PROGRAM PROG_FC_HAVE_C_LONG_DOUBLE" "END PROGRAM PROG_FC_HAVE_C_LONG_DOUBLE" SOURCE_CODE)
 check_fortran_source_compiles (${SOURCE_CODE} FORTRAN_HAVE_C_LONG_DOUBLE SRC_EXT f90)
 
 if (${FORTRAN_HAVE_C_LONG_DOUBLE})
@@ -158,92 +158,112 @@ endif ()
 #-----------------------------------------------------------------------------
 # Determine the available KINDs for REALs and INTEGERs
 #-----------------------------------------------------------------------------
-if (${HAVE_ISO_FORTRAN_ENV})
+if (NOT CMAKE_CROSSCOMPILING)
-  READ_SOURCE ("PROGRAM FC08_AVAIL_KINDS" "END PROGRAM FC08_AVAIL_KINDS" SOURCE_CODE)
+  if (${HAVE_ISO_FORTRAN_ENV})
-else ()
+    READ_SOURCE ("PROGRAM FC08_AVAIL_KINDS" "END PROGRAM FC08_AVAIL_KINDS" SOURCE_CODE)
-  READ_SOURCE ("PROGRAM FC_AVAIL_KINDS" "END PROGRAM FC_AVAIL_KINDS" SOURCE_CODE)
+  else ()
-endif ()
+    READ_SOURCE ("PROGRAM FC_AVAIL_KINDS" "END PROGRAM FC_AVAIL_KINDS" SOURCE_CODE)
+  endif ()
 
-FORTRAN_RUN ("REAL and INTEGER KINDs"
+  FORTRAN_RUN ("REAL and INTEGER KINDs"
-    "${SOURCE_CODE}"
+      "${SOURCE_CODE}"
-    XX
+      XX
-    YY
+      YY
-    FC_AVAIL_KINDS_RESULT
+      FC_AVAIL_KINDS_RESULT
-    PROG_OUTPUT
+      PROG_OUTPUT
-)
+  )
-# dnl The output from the above program will be:
+  # dnl The output from the above program will be:
-# dnl    -- LINE 1 --  valid integer kinds (comma separated list)
+  # dnl    -- LINE 1 --  valid integer kinds (comma separated list)
-# dnl    -- LINE 2 --  valid real kinds (comma separated list)
+  # dnl    -- LINE 2 --  valid real kinds (comma separated list)
-# dnl    -- LINE 3 --  max decimal precision for reals
+  # dnl    -- LINE 3 --  max decimal precision for reals
-# dnl    -- LINE 4 --  number of valid integer kinds
+  # dnl    -- LINE 4 --  number of valid integer kinds
-# dnl    -- LINE 5 --  number of valid real kinds
+  # dnl    -- LINE 5 --  number of valid real kinds
-# dnl    -- LINE 6 --  number of valid logical kinds
+  # dnl    -- LINE 6 --  number of valid logical kinds
-# dnl    -- LINE 7 --  valid logical kinds (comma separated list)
+  # dnl    -- LINE 7 --  valid logical kinds (comma separated list)
 
-#
+  #
-# Convert the string to a list of strings by replacing the carriage return with a semicolon
+  # Convert the string to a list of strings by replacing the carriage return with a semicolon
-string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT "${PROG_OUTPUT}")
+  string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT "${PROG_OUTPUT}")
 
-list (GET PROG_OUTPUT 0 pac_validIntKinds)
+  list (GET PROG_OUTPUT 0 pac_validIntKinds)
-list (GET PROG_OUTPUT 1 pac_validRealKinds)
+  list (GET PROG_OUTPUT 1 pac_validRealKinds)
-list (GET PROG_OUTPUT 2 pac_fc_max_real_precision)
+  list (GET PROG_OUTPUT 2 pac_fc_max_real_precision)
 
-# If the lists are empty then something went wrong.
+  # If the lists are empty then something went wrong.
-if (NOT pac_validIntKinds)
+  if (NOT pac_validIntKinds)
     message (FATAL_ERROR "Failed to find available INTEGER KINDs for Fortran")
-endif ()
+  endif ()
-if (NOT pac_validRealKinds)
+  if (NOT pac_validRealKinds)
     message (FATAL_ERROR "Failed to find available REAL KINDs for Fortran")
-endif ()
+  endif ()
-if (NOT pac_fc_max_real_precision)
+  if (NOT pac_fc_max_real_precision)
     message (FATAL_ERROR "No output from Fortran decimal precision program")
+  endif ()
+  set (${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION ${pac_fc_max_real_precision} CACHE INTERNAL "Maximum decimal precision for REALs in Fortran")
+
+  set (PAC_FC_ALL_INTEGER_KINDS "\{${pac_validIntKinds}\}")
+  set (PAC_FC_ALL_REAL_KINDS "\{${pac_validRealKinds}\}")
+
+  list (GET PROG_OUTPUT 3 NUM_IKIND)
+  list (GET PROG_OUTPUT 4 NUM_RKIND)
+
+  set (PAC_FORTRAN_NUM_INTEGER_KINDS "${NUM_IKIND}")
+  set (PAC_FORTRAN_NUM_REAL_KINDS "${NUM_RKIND}")
+
+  set (${HDF_PREFIX}_H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = ${NUM_IKIND}")
+  set (${HDF_PREFIX}_H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/${pac_validIntKinds}/)")
+
+  if (${HAVE_ISO_FORTRAN_ENV})
+    list (GET PROG_OUTPUT 5 NUM_LKIND)
+    set (PAC_FORTRAN_NUM_LOGICAL_KINDS "${NUM_LKIND}")
+
+    list (GET PROG_OUTPUT 6 pac_validLogicalKinds)
+    # If the list is empty then something went wrong.
+    if (NOT pac_validLogicalKinds)
+      message (FATAL_ERROR "Failed to find available LOGICAL KINDs for Fortran")
+    endif ()
+
+    set (PAC_FC_ALL_LOGICAL_KINDS "\{${pac_validLogicalKinds}\}")
+    message (STATUS "....LOGICAL KINDS FOUND ${PAC_FC_ALL_LOGICAL_KINDS}")
+  endif ()
+else ()
+  # Use the default if there's no cache variable and cross-compiling
+  message (VERBOSE "Find available INTEGER KINDs for Fortran... yes (cross-compile gfortran default)")
+  set (PAC_FC_ALL_INTEGER_KINDS "\{1,2,4,8,16\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
+  set (PAC_FC_ALL_REAL_KINDS "\{4,8,10,16\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
+  set (${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION 33 CACHE INTERNAL "Maximum decimal precision for REALs in Fortran")
+  set (PAC_FORTRAN_NUM_INTEGER_KINDS "5" CACHE INTERNAL "Number of valid integer kinds for Fortran")
+  set (PAC_FORTRAN_NUM_REAL_KINDS "4" CACHE INTERNAL "Number of valid real kinds for Fortran")
+
+  set (${HDF_PREFIX}_H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = 5")
+  set (${HDF_PREFIX}_H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/1,2,4,8,16/)")
+
+  if (${HAVE_ISO_FORTRAN_ENV})
+    set (PAC_FORTRAN_NUM_LOGICAL_KINDS "5" CACHE INTERNAL "Find available LOGICAL KINDs for Fortran")
+    set (PAC_FC_ALL_LOGICAL_KINDS "\{1,2,4,8,16\}" CACHE INTERNAL "LOGICAL KINDS FOUND for Fortran")
+  endif ()
 endif ()
-set (${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION ${pac_fc_max_real_precision} CACHE INTERNAL "Maximum decimal precision for REALs in Fortran")
-
-set (PAC_FC_ALL_INTEGER_KINDS "\{${pac_validIntKinds}\}")
-set (PAC_FC_ALL_REAL_KINDS "\{${pac_validRealKinds}\}")
-
-list (GET PROG_OUTPUT 3 NUM_IKIND)
-list (GET PROG_OUTPUT 4 NUM_RKIND)
-
-set (PAC_FORTRAN_NUM_INTEGER_KINDS "${NUM_IKIND}")
-
-set (${HDF_PREFIX}_H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = ${NUM_IKIND}")
-set (${HDF_PREFIX}_H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/${pac_validIntKinds}/)")
 
 message (STATUS "....NUMBER OF INTEGER KINDS FOUND ${PAC_FORTRAN_NUM_INTEGER_KINDS}")
 message (STATUS "....REAL KINDS FOUND ${PAC_FC_ALL_REAL_KINDS}")
 message (STATUS "....INTEGER KINDS FOUND ${PAC_FC_ALL_INTEGER_KINDS}")
-message (STATUS "....MAX DECIMAL PRECISION ${pac_fc_max_real_precision}")
+message (STATUS "....MAX DECIMAL PRECISION ${${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION}")
 
 if (${HAVE_ISO_FORTRAN_ENV})
-
-  list (GET PROG_OUTPUT 5 NUM_LKIND)
-  set (PAC_FORTRAN_NUM_LOGICAL_KINDS "${NUM_LKIND}")
-
-  list (GET PROG_OUTPUT 6 pac_validLogicalKinds)
-  # If the list is empty then something went wrong.
-  if (NOT pac_validLogicalKinds)
-      message (FATAL_ERROR "Failed to find available LOGICAL KINDs for Fortran")
-  endif ()
-
-  set (PAC_FC_ALL_LOGICAL_KINDS "\{${pac_validLogicalKinds}\}")
-  message (STATUS "....LOGICAL KINDS FOUND ${PAC_FC_ALL_LOGICAL_KINDS}")
-
 # ********************
 # LOGICAL KIND FOR MPI
 # ********************
   if (HDF5_ENABLE_PARALLEL AND BUILD_TESTING)
-    string (REGEX REPLACE "," ";" VAR "${pac_validLogicalKinds}")
+    string (REGEX REPLACE "," ";" VAR "${PAC_FC_ALL_LOGICAL_KINDS}")
 
-    set(CMAKE_REQUIRED_QUIET TRUE)
+    set (CMAKE_REQUIRED_QUIET TRUE)
-    set(save_CMAKE_Fortran_FLAGS ${CMAKE_Fortran_FLAGS})
+    set (save_CMAKE_Fortran_FLAGS ${CMAKE_Fortran_FLAGS})
     if (CMAKE_Fortran_COMPILER_ID MATCHES "Intel")
-       set(CMAKE_Fortran_FLAGS "-warn error")
+       set (CMAKE_Fortran_FLAGS "-warn error")
     endif ()
 
     foreach (KIND ${VAR})
-      unset(MPI_LOGICAL_KIND CACHE)
+      unset (MPI_LOGICAL_KIND CACHE)
       set (PROG_SRC
       "
           PROGRAM main
@@ -266,10 +286,10 @@ if (${HAVE_ISO_FORTRAN_ENV})
     if (${HDF_PREFIX}_MPI_LOGICAL_KIND STREQUAL "")
        message (FATAL_ERROR "Failed to determine LOGICAL KIND for MPI")
     endif ()
-    set(CMAKE_REQUIRED_QUIET FALSE)
+    set (CMAKE_REQUIRED_QUIET FALSE)
-    set(CMAKE_Fortran_FLAGS ${save_CMAKE_Fortran_FLAGS})
+    set (CMAKE_Fortran_FLAGS ${save_CMAKE_Fortran_FLAGS})
-  endif()
+  endif ()
-endif()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Determine the available KINDs for REALs and INTEGERs
@@ -277,85 +297,104 @@ endif()
 # **********
 # INTEGERS
 # **********
-string (REGEX REPLACE "," ";" VAR "${pac_validIntKinds}")
+if (NOT CMAKE_CROSSCOMPILING)
+  string (REGEX REPLACE "," ";" VAR "${pac_validIntKinds}")
 
-foreach (KIND ${VAR})
+  foreach (KIND ${VAR})
-  set (PROG_SRC_${KIND}
+    set (PROG_SRC_${KIND}
-  "
+    "
-       PROGRAM main
+         PROGRAM main
-          USE ISO_C_BINDING
+            USE ISO_C_BINDING
-          USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
+            USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
-          IMPLICIT NONE
+            IMPLICIT NONE
-          INTEGER (KIND=${KIND}) a
+            INTEGER (KIND=${KIND}) a
-          WRITE(stdout,'(I0)') ${FC_SIZEOF_A}
+            WRITE(stdout,'(I0)') ${FC_SIZEOF_A}
-       END
+         END
-   "
+     "
-  )
+    )
-  FORTRAN_RUN("INTEGER KIND SIZEOF" ${PROG_SRC_${KIND}} XX YY VALIDINTKINDS_RESULT_${KIND} PROG_OUTPUT1)
+    FORTRAN_RUN("INTEGER KIND SIZEOF" ${PROG_SRC_${KIND}} XX YY VALIDINTKINDS_RESULT_${KIND} PROG_OUTPUT1)
-  string (REGEX REPLACE "[\r\n]+" "" PROG_OUTPUT1 "${PROG_OUTPUT1}")
+    string (REGEX REPLACE "[\r\n]+" "" PROG_OUTPUT1 "${PROG_OUTPUT1}")
-  set (pack_int_sizeof "${pack_int_sizeof} ${PROG_OUTPUT1},")
+    set (pack_int_sizeof "${pack_int_sizeof} ${PROG_OUTPUT1},")
-endforeach ()
+  endforeach ()
 
-if (pack_int_sizeof STREQUAL "")
+  if (pack_int_sizeof STREQUAL "")
-   message (FATAL_ERROR "Failed to find available INTEGER KINDs for Fortran")
+     message (FATAL_ERROR "Failed to find available INTEGER KINDs for Fortran")
+  endif ()
+
+  string (STRIP ${pack_int_sizeof} pack_int_sizeof)
+
+  #Remove trailing comma
+  string (REGEX REPLACE ",$" "" pack_int_sizeof "${pack_int_sizeof}")
+  #Remove spaces
+  string (REGEX REPLACE " " "" pack_int_sizeof "${pack_int_sizeof}")
+
+  set (PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{${pack_int_sizeof}\}")
+else ()
+  # Use the default if there's no cache variable and cross-compiling
+  message (VERBOSE "Find available INTEGER KINDs for Fortran... yes (cross-compile gfortran default)")
+  set (PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{1,2,4,8,16\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
 endif ()
 
-string (STRIP ${pack_int_sizeof} pack_int_sizeof)
+if (PAC_FC_ALL_INTEGER_KINDS_SIZEOF STREQUAL "")
-
+   message (FATAL_ERROR "Failed to find available INTEGER KINDs for Fortran")
-#Remove trailing comma
+endif ()
-string (REGEX REPLACE ",$" "" pack_int_sizeof "${pack_int_sizeof}")
-#Remove spaces
-string (REGEX REPLACE " " "" pack_int_sizeof "${pack_int_sizeof}")
-
-set (PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{${pack_int_sizeof}\}")
 
 message (VERBOSE "....FOUND SIZEOF for INTEGER KINDs ${PAC_FC_ALL_INTEGER_KINDS_SIZEOF}")
 # **********
 # REALS
 # **********
-string (REGEX REPLACE "," ";" VAR "${pac_validRealKinds}")
+if (NOT CMAKE_CROSSCOMPILING)
+  string (REGEX REPLACE "," ";" VAR "${pac_validRealKinds}")
 
-#find the maximum kind of the real
+  #find the maximum kind of the real
-list (LENGTH VAR LEN_VAR)
+  list (LENGTH VAR LEN_VAR)
-math (EXPR _LEN "${LEN_VAR}-1")
+  math (EXPR _LEN "${LEN_VAR}-1")
-list (GET VAR ${_LEN} max_real_fortran_kind)
+  list (GET VAR ${_LEN} max_real_fortran_kind)
 
-foreach (KIND ${VAR} )
+  foreach (KIND ${VAR} )
-  set (PROG_SRC2_${KIND}
+    set (PROG_SRC2_${KIND}
-  "
+    "
-       PROGRAM main
+         PROGRAM main
-          USE ISO_C_BINDING
+            USE ISO_C_BINDING
-          USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
+            USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
-          IMPLICIT NONE
+            IMPLICIT NONE
-          REAL (KIND=${KIND}) a
+            REAL (KIND=${KIND}) a
-          WRITE(stdout,'(I0)') ${FC_SIZEOF_A}
+            WRITE(stdout,'(I0)') ${FC_SIZEOF_A}
-       END
+         END
-  "
+    "
-  )
+    )
-  FORTRAN_RUN ("REAL KIND SIZEOF" ${PROG_SRC2_${KIND}} XX YY VALIDREALKINDS_RESULT_${KIND} PROG_OUTPUT2)
+    FORTRAN_RUN ("REAL KIND SIZEOF" ${PROG_SRC2_${KIND}} XX YY VALIDREALKINDS_RESULT_${KIND} PROG_OUTPUT2)
-  string (REGEX REPLACE "[\r\n]+" "" PROG_OUTPUT2 "${PROG_OUTPUT2}")
+    string (REGEX REPLACE "[\r\n]+" "" PROG_OUTPUT2 "${PROG_OUTPUT2}")
-  set (pack_real_sizeof "${pack_real_sizeof} ${PROG_OUTPUT2},")
+    set (pack_real_sizeof "${pack_real_sizeof} ${PROG_OUTPUT2},")
-endforeach ()
+  endforeach ()
 
-if (pack_real_sizeof STREQUAL "")
+  if (pack_real_sizeof STREQUAL "")
-   message (FATAL_ERROR "Failed to find available REAL KINDs for Fortran")
+    message (FATAL_ERROR "Failed to find available REAL KINDs for Fortran")
+  endif ()
+
+  string(STRIP ${pack_real_sizeof} pack_real_sizeof)
+
+  #Remove trailing comma
+  string (REGEX REPLACE ",$" "" pack_real_sizeof "${pack_real_sizeof}")
+  #Remove spaces
+  string (REGEX REPLACE " " "" pack_real_sizeof "${pack_real_sizeof}")
+
+  set (PAC_FC_ALL_REAL_KINDS_SIZEOF "\{${pack_real_sizeof}\}")
+else ()
+  # Use the default if there's no cache variable and cross-compiling
+  message (VERBOSE "Find available REAL KINDs for Fortran... yes (cross-compile gfortran default)")
+  set (PAC_FC_ALL_REAL_KINDS_SIZEOF "\{4,8,16,16\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
 endif ()
 
-string(STRIP ${pack_real_sizeof} pack_real_sizeof)
+if (PAC_FC_ALL_REAL_KINDS_SIZEOF STREQUAL "")
+  message (FATAL_ERROR "Failed to find available REAL KINDs for Fortran")
+endif ()
 
-#Remove trailing comma
+set (${HDF_PREFIX}_H5CONFIG_F_RKIND_SIZEOF "INTEGER, DIMENSION(1:num_rkinds) :: rkind_sizeof = (/${PAC_FC_ALL_REAL_KINDS_SIZEOF}/)")
-string (REGEX REPLACE ",$" "" pack_real_sizeof "${pack_real_sizeof}")
+message (STATUS "....FOUND SIZEOF for REAL KINDs \{${PAC_FC_ALL_REAL_KINDS_SIZEOF}\}")
-#Remove spaces
-string (REGEX REPLACE " " "" pack_real_sizeof "${pack_real_sizeof}")
-
-set (${HDF_PREFIX}_H5CONFIG_F_RKIND_SIZEOF "INTEGER, DIMENSION(1:num_rkinds) :: rkind_sizeof = (/${pack_real_sizeof}/)")
-
-message (STATUS "....FOUND SIZEOF for REAL KINDs \{${pack_real_sizeof}\}")
-
-set (PAC_FC_ALL_REAL_KINDS_SIZEOF "\{${pack_real_sizeof}\}")
 
 #find the maximum kind of the real
-string (REGEX REPLACE "," ";" VAR "${pack_real_sizeof}")
+string (REGEX REPLACE "," ";" VAR "${PAC_FC_ALL_REAL_KINDS_SIZEOF}")
 list (LENGTH VAR LEN_VAR)
 math (EXPR _LEN "${LEN_VAR}-1")
 list (GET VAR ${_LEN} max_real_fortran_sizeof)
@@ -363,42 +402,58 @@ list (GET VAR ${_LEN} max_real_fortran_sizeof)
 #-----------------------------------------------------------------------------
 # Find sizeof of native kinds
 #-----------------------------------------------------------------------------
-set (PROG_SRC3
+if (NOT CMAKE_CROSSCOMPILING)
-  "
+  set (PROG_SRC3
-       PROGRAM main
+    "
-          USE ISO_C_BINDING
+         PROGRAM main
-          USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
+            USE ISO_C_BINDING
-          IMPLICIT NONE
+            USE, INTRINSIC :: ISO_FORTRAN_ENV, ONLY : stdout=>OUTPUT_UNIT
-          INTEGER a
+            IMPLICIT NONE
-          REAL b
+            INTEGER a
-          DOUBLE PRECISION c
+            REAL b
-          WRITE(stdout,*) ${FC_SIZEOF_A}
+            DOUBLE PRECISION c
-          WRITE(stdout,*) kind(a)
+            WRITE(stdout,*) ${FC_SIZEOF_A}
-          WRITE(stdout,*) ${FC_SIZEOF_B}
+            WRITE(stdout,*) kind(a)
-          WRITE(stdout,*) kind(b)
+            WRITE(stdout,*) ${FC_SIZEOF_B}
-          WRITE(stdout,*) ${FC_SIZEOF_C}
+            WRITE(stdout,*) kind(b)
-          WRITE(stdout,*) kind(c)
+            WRITE(stdout,*) ${FC_SIZEOF_C}
-       END
+            WRITE(stdout,*) kind(c)
-  "
+         END
-)
+    "
-FORTRAN_RUN ("SIZEOF NATIVE KINDs" ${PROG_SRC3} XX YY PAC_SIZEOF_NATIVE_KINDS_RESULT PROG_OUTPUT3)
+  )
-# The output from the above program will be:
+  FORTRAN_RUN ("SIZEOF NATIVE KINDs" ${PROG_SRC3} XX YY PAC_SIZEOF_NATIVE_KINDS_RESULT PROG_OUTPUT3)
-#    -- LINE 1 --  sizeof INTEGER
+  # The output from the above program will be:
-#    -- LINE 2 --  kind of INTEGER
+  #    -- LINE 1 --  sizeof INTEGER
-#    -- LINE 3 --  sizeof REAL
+  #    -- LINE 2 --  kind of INTEGER
-#    -- LINE 4 --  kind of REAL
+  #    -- LINE 3 --  sizeof REAL
-#    -- LINE 5 --  sizeof DOUBLE PRECISION
+  #    -- LINE 4 --  kind of REAL
-#    -- LINE 6 --  kind of DOUBLE PRECISION
+  #    -- LINE 5 --  sizeof DOUBLE PRECISION
-#
+  #    -- LINE 6 --  kind of DOUBLE PRECISION
-# Convert the string to a list of strings by replacing the carriage return with a semicolon
+  #
-string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT3 "${PROG_OUTPUT3}")
+  # Convert the string to a list of strings by replacing the carriage return with a semicolon
+  string (REGEX REPLACE "[\r\n]+" ";" PROG_OUTPUT3 "${PROG_OUTPUT3}")
 
-list (GET PROG_OUTPUT3 0 PAC_FORTRAN_NATIVE_INTEGER_SIZEOF)
+  list (GET PROG_OUTPUT3 0 PAC_FORTRAN_NATIVE_INTEGER_SIZEOF)
-list (GET PROG_OUTPUT3 1 PAC_FORTRAN_NATIVE_INTEGER_KIND)
+  list (GET PROG_OUTPUT3 1 PAC_FORTRAN_NATIVE_INTEGER_KIND)
-list (GET PROG_OUTPUT3 2 PAC_FORTRAN_NATIVE_REAL_SIZEOF)
+  list (GET PROG_OUTPUT3 2 PAC_FORTRAN_NATIVE_REAL_SIZEOF)
-list (GET PROG_OUTPUT3 3 PAC_FORTRAN_NATIVE_REAL_KIND)
+  list (GET PROG_OUTPUT3 3 PAC_FORTRAN_NATIVE_REAL_KIND)
-list (GET PROG_OUTPUT3 4 PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF)
+  list (GET PROG_OUTPUT3 4 PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF)
-list (GET PROG_OUTPUT3 5 PAC_FORTRAN_NATIVE_DOUBLE_KIND)
+  list (GET PROG_OUTPUT3 5 PAC_FORTRAN_NATIVE_DOUBLE_KIND)
+else ()
+  # Use the default if there's no cache variable and cross-compiling
+  message (VERBOSE "Find sizeof of native kinds sizeof INTEGER... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_INTEGER_SIZEOF 4 CACHE INTERNAL "Find sizeof of native kinds sizeof INTEGER")
+  message (VERBOSE "Find sizeof of native kinds kind of INTEGER... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_INTEGER_KIND 4 CACHE INTERNAL "Find sizeof of native kinds kind of INTEGER")
+  message (VERBOSE "Find sizeof of native kinds sizeof REAL... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_REAL_SIZEOF 4 CACHE INTERNAL "Find sizeof of native kinds sizeof REAL")
+  message (VERBOSE "Find sizeof of native kinds kind of REAL... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_REAL_KIND 4 CACHE INTERNAL "Find sizeof of native kinds kind of REAL")
+  message (VERBOSE "Find sizeof of native kinds sizeof DOUBLE PRECISION... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF 8 CACHE INTERNAL "Find sizeof of native kinds sizeof DOUBLE PRECISION")
+  message (VERBOSE "Find sizeof of native kinds kind of DOUBLE PRECISION... yes (cross-compile gfortran default)")
+  set (PAC_FORTRAN_NATIVE_DOUBLE_KIND 8 CACHE INTERNAL "Find sizeof of native kinds kind of DOUBLE PRECISION")
+endif ()
 
 if (NOT PAC_FORTRAN_NATIVE_INTEGER_SIZEOF)
    message (FATAL_ERROR "Failed to find SIZEOF NATIVE INTEGER KINDs for Fortran")
@@ -432,11 +487,11 @@ if (${${HDF_PREFIX}_HAVE_FLOAT128})
                                            !!! Fortran interfaces will not be generated for REAL(KIND=${max_real_fortran_kind}) !!!")
      string (REGEX REPLACE ",[0-9]+}" "}" PAC_FC_ALL_REAL_KINDS ${PAC_FC_ALL_REAL_KINDS})
      string (REGEX REPLACE ",[0-9]+}" "}" PAC_FC_ALL_REAL_KINDS_SIZEOF ${PAC_FC_ALL_REAL_KINDS_SIZEOF})
-     math (EXPR NUM_RKIND "${NUM_RKIND} - 1")
+     math (EXPR PAC_FORTRAN_NUM_REAL_KINDS "${PAC_FORTRAN_NUM_REAL_KINDS} - 1")
    endif ()
 endif ()
 
-set (${HDF_PREFIX}_H5CONFIG_F_NUM_RKIND "INTEGER, PARAMETER :: num_rkinds = ${NUM_RKIND}")
+set (${HDF_PREFIX}_H5CONFIG_F_NUM_RKIND "INTEGER, PARAMETER :: num_rkinds = ${PAC_FORTRAN_NUM_REAL_KINDS}")
 
 string (REGEX REPLACE "{" "" OUT_VAR1 ${PAC_FC_ALL_REAL_KINDS})
 string (REGEX REPLACE "}" "" OUT_VAR1 ${OUT_VAR1})

config/sanitizer/code-coverage.cmake

@@ -141,14 +141,14 @@ if(CODE_COVERAGE AND NOT CODE_COVERAGE_ADDED)
 
     # Targets
     if(${CMAKE_VERSION} VERSION_LESS "3.17.0")
-      add_custom_target(
+      add_custom_target (
         ccov-clean
         COMMAND ${CMAKE_COMMAND} -E remove -f
                 ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/binaries.list
         COMMAND ${CMAKE_COMMAND} -E remove -f
                 ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/profraw.list)
     else()
-      add_custom_target(
+      add_custom_target (
         ccov-clean
         COMMAND ${CMAKE_COMMAND} -E rm -f
                 ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/binaries.list
@@ -158,7 +158,7 @@ if(CODE_COVERAGE AND NOT CODE_COVERAGE_ADDED)
 
     # Used to get the shared object file list before doing the main all-
     # processing
-    add_custom_target(
+    add_custom_target (
       ccov-libs
       COMMAND ;
       COMMENT "libs ready for coverage report.")
@@ -189,7 +189,7 @@ if(CODE_COVERAGE AND NOT CODE_COVERAGE_ADDED)
     endif()
 
     # Targets
-    add_custom_target(ccov-clean COMMAND ${LCOV_PATH} --directory
+    add_custom_target (ccov-clean COMMAND ${LCOV_PATH} --directory
                                          ${CMAKE_BINARY_DIR} --zerocounters)
 
   else()
@@ -291,7 +291,7 @@ function(target_code_coverage TARGET_NAME)
          CMAKE_CXX_COMPILER_ID MATCHES "IntelLLVM" OR 
          CMAKE_C_COMPILER_ID MATCHES "(Apple)?[Cc]lang" OR 
          CMAKE_CXX_COMPILER_ID MATCHES "(Apple)?[Cc]lang")
-        add_custom_target(
+        add_custom_target (
           ccov-run-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${CMAKE_COMMAND} -E echo "-object=$<TARGET_FILE:${TARGET_NAME}>" >>
@@ -332,10 +332,12 @@ function(target_code_coverage TARGET_NAME)
         # Run the executable, generating raw profile data Make the run data
         # available for further processing. Separated to allow Windows to run
         # this target serially.
-        add_custom_target(
+        add_custom_target (
           ccov-run-${target_code_coverage_COVERAGE_TARGET_NAME}
+          COMMAND  ${CMAKE_COMMAND}
+          ARGS     -E env ${CROSSCOMPILING_PATH}
           COMMAND
-            ${CMAKE_COMMAND} -E env ${CMAKE_CROSSCOMPILING_EMULATOR}
+            ${CMAKE_COMMAND} -E env
             ${target_code_coverage_PRE_ARGS}
             LLVM_PROFILE_FILE=${target_code_coverage_COVERAGE_TARGET_NAME}.profraw
             $<TARGET_FILE:${TARGET_NAME}> ${target_code_coverage_ARGS}
@@ -350,7 +352,7 @@ function(target_code_coverage TARGET_NAME)
           DEPENDS ccov-libs ${TARGET_NAME})
 
         # Merge the generated profile data so llvm-cov can process it
-        add_custom_target(
+        add_custom_target (
           ccov-processing-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${LLVM_PROFDATA_PATH} merge -sparse
@@ -367,7 +369,7 @@ function(target_code_coverage TARGET_NAME)
         endif()
 
         # Print out details of the coverage information to the command line
-        add_custom_target(
+        add_custom_target (
           ccov-show-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${LLVM_COV_PATH} show $<TARGET_FILE:${TARGET_NAME}> ${SO_OBJECTS}
@@ -376,7 +378,7 @@ function(target_code_coverage TARGET_NAME)
           DEPENDS ccov-processing-${target_code_coverage_COVERAGE_TARGET_NAME})
 
         # Print out a summary of the coverage information to the command line
-        add_custom_target(
+        add_custom_target (
           ccov-report-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${LLVM_COV_PATH} report $<TARGET_FILE:${TARGET_NAME}> ${SO_OBJECTS}
@@ -386,7 +388,7 @@ function(target_code_coverage TARGET_NAME)
 
         # Export coverage information so continuous integration tools (e.g.
         # Jenkins) can consume it
-        add_custom_target(
+        add_custom_target (
           ccov-export-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${LLVM_COV_PATH} export $<TARGET_FILE:${TARGET_NAME}> ${SO_OBJECTS}
@@ -396,7 +398,7 @@ function(target_code_coverage TARGET_NAME)
           DEPENDS ccov-processing-${target_code_coverage_COVERAGE_TARGET_NAME})
 
         # Generates HTML output of the coverage information for perusal
-        add_custom_target(
+        add_custom_target (
           ccov-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${LLVM_COV_PATH} show $<TARGET_FILE:${TARGET_NAME}> ${SO_OBJECTS}
@@ -413,10 +415,12 @@ function(target_code_coverage TARGET_NAME)
         )
 
         # Run the executable, generating coverage information
-        add_custom_target(
+        add_custom_target (
           ccov-run-${target_code_coverage_COVERAGE_TARGET_NAME}
+          COMMAND  ${CMAKE_COMMAND}
+          ARGS     -E env ${CROSSCOMPILING_PATH}
           COMMAND
-            ${CMAKE_CROSSCOMPILING_EMULATOR} ${target_code_coverage_PRE_ARGS}
+            ${target_code_coverage_PRE_ARGS}
             $<TARGET_FILE:${TARGET_NAME}> ${target_code_coverage_ARGS}
           DEPENDS ${TARGET_NAME})
 
@@ -439,12 +443,14 @@ function(target_code_coverage TARGET_NAME)
 
         # Capture coverage data
         if(${CMAKE_VERSION} VERSION_LESS "3.17.0")
-          add_custom_target(
+          add_custom_target (
             ccov-capture-${target_code_coverage_COVERAGE_TARGET_NAME}
             COMMAND ${CMAKE_COMMAND} -E remove -f ${COVERAGE_INFO}
             COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --zerocounters
+            COMMAND ${CMAKE_COMMAND}
+            ARGS    -E env ${CROSSCOMPILING_PATH}
             COMMAND
-              ${CMAKE_CROSSCOMPILING_EMULATOR} ${target_code_coverage_PRE_ARGS}
+              ${target_code_coverage_PRE_ARGS}
               $<TARGET_FILE:${TARGET_NAME}> ${target_code_coverage_ARGS}
             COMMAND
               ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --base-directory
@@ -453,12 +459,14 @@ function(target_code_coverage TARGET_NAME)
             COMMAND ${EXCLUDE_COMMAND}
             DEPENDS ${TARGET_NAME})
         else()
-          add_custom_target(
+          add_custom_target (
             ccov-capture-${target_code_coverage_COVERAGE_TARGET_NAME}
             COMMAND ${CMAKE_COMMAND} -E rm -f ${COVERAGE_INFO}
             COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --zerocounters
+            COMMAND ${CMAKE_COMMAND}
+            ARGS    -E env ${CROSSCOMPILING_PATH}
             COMMAND
-              ${CMAKE_CROSSCOMPILING_EMULATOR} ${target_code_coverage_PRE_ARGS}
+              ${target_code_coverage_PRE_ARGS}
               $<TARGET_FILE:${TARGET_NAME}> ${target_code_coverage_ARGS}
             COMMAND
               ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --base-directory
@@ -469,7 +477,7 @@ function(target_code_coverage TARGET_NAME)
         endif()
 
         # Generates HTML output of the coverage information for perusal
-        add_custom_target(
+        add_custom_target (
           ccov-${target_code_coverage_COVERAGE_TARGET_NAME}
           COMMAND
             ${GENHTML_PATH} -o
@@ -489,14 +497,14 @@ function(target_code_coverage TARGET_NAME)
       # AUTO
       if(target_code_coverage_AUTO)
         if(NOT TARGET ccov)
-          add_custom_target(ccov)
+          add_custom_target (ccov)
         endif()
         add_dependencies(ccov ccov-${target_code_coverage_COVERAGE_TARGET_NAME})
 
         if(NOT CMAKE_C_COMPILER_ID MATCHES "GNU" AND NOT CMAKE_CXX_COMPILER_ID
                                                      MATCHES "GNU")
           if(NOT TARGET ccov-report)
-            add_custom_target(ccov-report)
+            add_custom_target (ccov-report)
           endif()
           add_dependencies(
             ccov-report
@@ -564,7 +572,7 @@ function(add_code_coverage_all_targets)
 
       # Merge the profile data for all of the run executables
       if(WIN32)
-        add_custom_target(
+        add_custom_target (
           ccov-all-processing
           COMMAND
             powershell -Command $$FILELIST = Get-Content
@@ -572,7 +580,7 @@ function(add_code_coverage_all_targets)
             merge -o ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/all-merged.profdata
             -sparse $$FILELIST)
       else()
-        add_custom_target(
+        add_custom_target (
           ccov-all-processing
           COMMAND
             ${LLVM_PROFDATA_PATH} merge -o
@@ -590,7 +598,7 @@ function(add_code_coverage_all_targets)
 
       # Print summary of the code coverage information to the command line
       if(WIN32)
-        add_custom_target(
+        add_custom_target (
           ccov-all-report
           COMMAND
             powershell -Command $$FILELIST = Get-Content
@@ -600,7 +608,7 @@ function(add_code_coverage_all_targets)
             ${EXCLUDE_REGEX}
           DEPENDS ccov-all-processing)
       else()
-        add_custom_target(
+        add_custom_target (
           ccov-all-report
           COMMAND
             ${LLVM_COV_PATH} report `cat
@@ -613,7 +621,7 @@ function(add_code_coverage_all_targets)
       # Export coverage information so continuous integration tools (e.g.
       # Jenkins) can consume it
       if(WIN32)
-        add_custom_target(
+        add_custom_target (
           ccov-all-export
           COMMAND
             powershell -Command $$FILELIST = Get-Content
@@ -624,7 +632,7 @@ function(add_code_coverage_all_targets)
             ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/coverage.json
           DEPENDS ccov-all-processing)
       else()
-        add_custom_target(
+        add_custom_target (
           ccov-all-export
           COMMAND
             ${LLVM_COV_PATH} export `cat
@@ -637,7 +645,7 @@ function(add_code_coverage_all_targets)
 
       # Generate HTML output of all added targets for perusal
       if(WIN32)
-        add_custom_target(
+        add_custom_target (
           ccov-all
           COMMAND
             powershell -Command $$FILELIST = Get-Content
@@ -649,7 +657,7 @@ function(add_code_coverage_all_targets)
             -format="html" ${EXCLUDE_REGEX}
           DEPENDS ccov-all-processing)
       else()
-        add_custom_target(
+        add_custom_target (
           ccov-all
           COMMAND
             ${LLVM_COV_PATH} show `cat
@@ -665,7 +673,7 @@ function(add_code_coverage_all_targets)
       set(COVERAGE_INFO "${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/all-merged.info")
 
       # Nothing required for gcov
-      add_custom_target(ccov-all-processing COMMAND ;)
+      add_custom_target (ccov-all-processing COMMAND ;)
 
       # Exclusion regex string creation
       set(EXCLUDE_REGEX)
@@ -683,7 +691,7 @@ function(add_code_coverage_all_targets)
 
       # Capture coverage data
       if(${CMAKE_VERSION} VERSION_LESS "3.17.0")
-        add_custom_target(
+        add_custom_target (
           ccov-all-capture
           COMMAND ${CMAKE_COMMAND} -E remove -f ${COVERAGE_INFO}
           COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --capture
@@ -691,7 +699,7 @@ function(add_code_coverage_all_targets)
           COMMAND ${EXCLUDE_COMMAND}
           DEPENDS ccov-all-processing)
       else()
-        add_custom_target(
+        add_custom_target (
           ccov-all-capture
           COMMAND ${CMAKE_COMMAND} -E rm -f ${COVERAGE_INFO}
           COMMAND ${LCOV_PATH} --directory ${CMAKE_BINARY_DIR} --capture
@@ -701,7 +709,7 @@ function(add_code_coverage_all_targets)
       endif()
 
       # Generates HTML output of all targets for perusal
-      add_custom_target(
+      add_custom_target (
         ccov-all
         COMMAND ${GENHTML_PATH} -o ${CMAKE_COVERAGE_OUTPUT_DIRECTORY}/all-merged
                 ${COVERAGE_INFO} -p ${CMAKE_SOURCE_DIR}

config/sanitizer/dependency-graph.cmake

@@ -79,7 +79,7 @@ function(gen_dep_graph OUTPUT_TYPE)
       set(OUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
     endif()
 
-    add_custom_target(
+    add_custom_target (
       ${TARGET_NAME}
       COMMAND ${CMAKE_COMMAND} ${CMAKE_SOURCE_DIR}
               --graphviz=${CMAKE_CURRENT_BINARY_DIR}/graphviz/${TARGET_NAME}.dot
@@ -98,7 +98,7 @@ function(gen_dep_graph OUTPUT_TYPE)
 
     if(gen_dep_graph_ADD_TO_DEP_GRAPH)
       if(NOT TARGET dep-graph)
-        add_custom_target(dep-graph)
+        add_custom_target (dep-graph)
       endif()
 
       add_dependencies(dep-graph ${TARGET_NAME})

config/sanitizer/formatting.cmake

@@ -69,11 +69,11 @@ function(clang_format TARGET_NAME)
 
     # Make the target
     if(FORMAT_FILES)
-      add_custom_target(${TARGET_NAME} COMMAND ${CLANG_FORMAT_EXE} -i
+      add_custom_target (${TARGET_NAME} COMMAND ${CLANG_FORMAT_EXE} -i
                                                -style=file ${FORMAT_FILES})
 
       if(NOT TARGET format)
-        add_custom_target(format)
+        add_custom_target (format)
       endif()
 
       add_dependencies(format ${TARGET_NAME})
@@ -123,11 +123,11 @@ function(cmake_format TARGET_NAME)
           ERROR
           "Cannot create cmake-format target '${TARGET_NAME}', already exists.")
       else()
-        add_custom_target(${TARGET_NAME} COMMAND ${CMAKE_FORMAT_EXE} -i
+        add_custom_target (${TARGET_NAME} COMMAND ${CMAKE_FORMAT_EXE} -i
                                                  ${FORMAT_FILES})
 
         if(NOT TARGET cmake-format)
-          add_custom_target(cmake-format)
+          add_custom_target (cmake-format)
         endif()
         add_dependencies(cmake-format ${TARGET_NAME})
       endif()

config/toolchain/aarch64.cmake

@@ -1,6 +1,6 @@
-set(TOOLCHAIN_PREFIX aarch64-linux-gnu)
+set (TOOLCHAIN_PREFIX aarch64-linux-gnu)
-set(CMAKE_SYSTEM_NAME Linux)
+set (CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set (CMAKE_SYSTEM_PROCESSOR aarch64)
 #set (CMAKE_ANDROID_ARCH_ABI x86_64)
 #set (CMAKE_ANDROID_STANDALONE_TOOLCHAIN ${ANDROID_NDK}/build/cmake/android.toolchain.cmake)
 set (CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
@@ -12,7 +12,7 @@ set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
-set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-aarch64-static;-L;/usr/aarch64-linux-gnu/" CACHE FILEPATH "Path to the emulator for the target system.")
+set (CMAKE_CROSSCOMPILING_EMULATOR "qemu-aarch64-static;-L;/usr/aarch64-linux-gnu/" CACHE FILEPATH "Path to the emulator for the target system.")
 
-include_directories(/usr/${TOOLCHAIN_PREFIX}/include)
+include_directories (/usr/${TOOLCHAIN_PREFIX}/include)
 

config/toolchain/build32.cmake

@@ -1,9 +1,9 @@
 if (WIN32)
   set (CMAKE_SYSTEM_NAME Windows)
   set (CMAKE_GENERATOR_PLATFORM "x86")
-elseif(APPLE)
+elseif (APPLE)
   set (CMAKE_OSX_ARCHITECTURES "i386")
-elseif(MINGW)
+elseif (MINGW)
   set (CMAKE_SYSTEM_NAME Windows)
   set (TOOLCHAIN_PREFIX i686-w64-mingw32)
   set (CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)

config/toolchain/clang.cmake

@@ -10,7 +10,7 @@ else()
   set (CMAKE_C_COMPILER clang)
   set (CMAKE_CXX_COMPILER clang++)
   #set (CMAKE_Fortran_COMPILER flang)
-endif()
+endif ()
 set (CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # the following is used if cross-compiling

config/toolchain/crosscompile-readme.cmake

@@ -0,0 +1,47 @@
+# This CMake toolchain file configures cross-compilation settings for building HDF5 on non-native platforms.
+# Copy this file and rename it (e.g., to crosscompile-myplatform.cmake).
+# Replace the placeholder values with actual values for your target system and compilers.
+# Then use this file with CMake by specifying it with the -DCMAKE_TOOLCHAIN_FILE option.
+
+# Set the target system name for cross-compiling
+set (CMAKE_SYSTEM_NAME system_name)
+
+# Specify the compiler vendor and compilers for C, C++, and Fortran
+set (CMAKE_COMPILER_VENDOR "compiler_name")
+set (CMAKE_C_COMPILER compiler_cc)
+set (CMAKE_CXX_COMPILER compiler_c++)
+set (CMAKE_Fortran_COMPILER compiler_fortran)
+
+# Optional: Specify an emulator for running binaries during cross-compilation
+set (CMAKE_CROSSCOMPILING_EMULATOR "")
+
+# Fortran kind and precision settings for cross-compiling
+set (PAC_FC_ALL_INTEGER_KINDS "\{x,y,z\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
+set (PAC_FC_ALL_REAL_KINDS "\{x,y,z\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
+set (${HDF_PREFIX}_PAC_FC_MAX_REAL_PRECISION X CACHE INTERNAL "Maximum decimal precision for REALs in Fortran")
+set (PAC_FORTRAN_NUM_INTEGER_KINDS "Y" CACHE INTERNAL "Number of valid integer kinds for Fortran")
+set (PAC_FORTRAN_NUM_REAL_KINDS "Z" CACHE INTERNAL "Number of valid real kinds for Fortran")
+
+# Fortran configuration variables for HDF5
+set (${HDF_PREFIX}_H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = Y")
+set (${HDF_PREFIX}_H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/x,y,z/)")
+
+# If using ISO_FORTRAN_ENV, set logical kind variables
+if (${PAC_USE_ISO_FORTRAN_ENV})
+  set (PAC_FORTRAN_NUM_LOGICAL_KINDS "W" CACHE INTERNAL "Find available LOGICAL KINDs for Fortran")
+  set (PAC_FC_ALL_LOGICAL_KINDS "\{x,y,z\}" CACHE INTERNAL "LOGICAL KINDS FOUND for Fortran")
+endif ()
+
+# Native kind and sizeof settings for Fortran types
+set (PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{x,y,z\}" CACHE INTERNAL "Find available INTEGER KINDs for Fortran")
+set (PAC_FC_ALL_REAL_KINDS_SIZEOF "\{x,y,z\}" CACHE INTERNAL "Find available REAL KINDs for Fortran")
+set (PAC_FORTRAN_NATIVE_INTEGER_SIZEOF i CACHE INTERNAL "Find sizeof of native kinds sizeof INTEGER")
+set (PAC_FORTRAN_NATIVE_INTEGER_KIND j CACHE INTERNAL "Find sizeof of native kinds kind of INTEGER")
+set (PAC_FORTRAN_NATIVE_REAL_SIZEOF k CACHE INTERNAL "Find sizeof of native kinds sizeof REAL")
+set (PAC_FORTRAN_NATIVE_REAL_KIND m CACHE INTERNAL "Find sizeof of native kinds kind of REAL")
+set (PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF n CACHE INTERNAL "Find sizeof of native kinds sizeof DOUBLE PRECISION")
+set (PAC_FORTRAN_NATIVE_DOUBLE_KIND o CACHE INTERNAL "Find sizeof of native kinds kind of DOUBLE PRECISION")
+
+# Optional set the path to a pregenerated Fortran directory that contains pregenerated files
+set (HDF5_USE_PREGEN_DIR "${CMAKE_CURRENT_LIST_DIR}/path/to/pregenerated/fortran/files" CACHE PATH "Path to pregenerated Fortran files")
+

config/toolchain/fortpregen/gfortran/H5TBff_gen.F90

@@ -0,0 +1,465 @@
+!****h* ROBODoc/H5TBff_gen.F90
+!
+! NAME
+!  H5TBff_gen
+! 
+! PURPOSE
+!  This module is generated at build by H5HL_buildiface.F90 to handle all the
+!  detected REAL/INTEGER KINDs for APIs being passed those KINDs. Currently these 
+!  are H5LT and H5TB APIs
+!
+! COPYRIGHT
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+!   Copyright by The HDF Group.                                               *
+!   All rights reserved.                                                      *
+!                                                                             *
+!   This file is part of HDF5.  The full HDF5 copyright notice, including     *
+!   terms governing use, modification, and redistribution, is contained in    *
+!   the LICENSE file, which can be found at the root of the source code       *
+!   distribution tree, or in https://www.hdfgroup.org/licenses.               *
+!   If you do not have access to either file, you may request a copy from     *
+!   help@hdfgroup.org.                                                        *
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+!
+! AUTHOR
+!   H5HL_buildiface.F90
+!
+!*****
+
+MODULE H5TB
+  USE, INTRINSIC :: ISO_C_BINDING
+  USE h5fortran_types
+  USE H5TB_CONST
+  IMPLICIT NONE
+  INTERFACE h5tbwrite_field_name_f
+     MODULE PROCEDURE h5tbwrite_field_name_kind_4_rank_1
+     MODULE PROCEDURE h5tbwrite_field_name_kind_8_rank_1
+     MODULE PROCEDURE h5tbwrite_field_name_kind_10_rank_1
+     MODULE PROCEDURE h5tbwrite_field_name_kind_16_rank_1
+  END INTERFACE
+  INTERFACE h5tbread_field_name_f
+     MODULE PROCEDURE h5tbread_field_name_kind_4_rank_1
+     MODULE PROCEDURE h5tbread_field_name_kind_8_rank_1
+     MODULE PROCEDURE h5tbread_field_name_kind_10_rank_1
+     MODULE PROCEDURE h5tbread_field_name_kind_16_rank_1
+  END INTERFACE
+  INTERFACE h5tbwrite_field_index_f
+     MODULE PROCEDURE h5tbwrite_field_index_kind_4_rank_1
+     MODULE PROCEDURE h5tbwrite_field_index_kind_8_rank_1
+     MODULE PROCEDURE h5tbwrite_field_index_kind_10_rank_1
+     MODULE PROCEDURE h5tbwrite_field_index_kind_16_rank_1
+  END INTERFACE
+  INTERFACE h5tbread_field_index_f
+     MODULE PROCEDURE h5tbread_field_index_kind_4_rank_1
+     MODULE PROCEDURE h5tbread_field_index_kind_8_rank_1
+     MODULE PROCEDURE h5tbread_field_index_kind_10_rank_1
+     MODULE PROCEDURE h5tbread_field_index_kind_16_rank_1
+  END INTERFACE
+  INTERFACE h5tbinsert_field_f
+     MODULE PROCEDURE h5tbinsert_field_kind_4_rank_1
+     MODULE PROCEDURE h5tbinsert_field_kind_8_rank_1
+     MODULE PROCEDURE h5tbinsert_field_kind_10_rank_1
+     MODULE PROCEDURE h5tbinsert_field_kind_16_rank_1
+  END INTERFACE
+CONTAINS
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_name_kind_4_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_name_kind_4_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=4),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbwrite_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_name_kind_4_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_name_kind_8_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_name_kind_8_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=8),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbwrite_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_name_kind_8_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_name_kind_10_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_name_kind_10_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=10),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbwrite_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_name_kind_10_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_name_kind_16_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_name_kind_16_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=16),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbwrite_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_name_kind_16_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_name_kind_4_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_name_kind_4_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=4),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbread_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_name_kind_4_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_name_kind_8_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_name_kind_8_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=8),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbread_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_name_kind_8_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_name_kind_10_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_name_kind_10_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=10),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbread_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_name_kind_10_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_name_kind_16_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_name_kind_16_rank_1(loc_id,dset_name,field_name,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    CHARACTER(LEN=*), INTENT(in) :: field_name
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=16),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    INTEGER(size_t) :: namelen1
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbread_field_name_c(loc_id,namelen,dset_name,namelen1,field_name,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_name_kind_16_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_index_kind_4_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_index_kind_4_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=4),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbwrite_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_index_kind_4_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_index_kind_8_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_index_kind_8_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=8),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbwrite_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_index_kind_8_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_index_kind_10_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_index_kind_10_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=10),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbwrite_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_index_kind_10_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbwrite_field_index_kind_16_rank_1
+!DEC$endif
+  SUBROUTINE h5tbwrite_field_index_kind_16_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=16),INTENT(IN), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbwrite_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbwrite_field_index_kind_16_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_index_kind_4_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_index_kind_4_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=4),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbread_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_index_kind_4_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_index_kind_8_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_index_kind_8_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=8),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbread_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_index_kind_8_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_index_kind_10_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_index_kind_10_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=10),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbread_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_index_kind_10_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbread_field_index_kind_16_rank_1
+!DEC$endif
+  SUBROUTINE h5tbread_field_index_kind_16_rank_1(loc_id,dset_name,field_index,start, nrecords,type_size,buf,errcode)
+    IMPLICIT NONE
+    INTEGER(hid_t)  , INTENT(IN) :: loc_id
+    CHARACTER(LEN=*), INTENT(IN) :: dset_name
+    INTEGER, INTENT(in) :: field_index
+    INTEGER(hsize_t), INTENT(in) :: start
+    INTEGER(hsize_t), INTENT(in) :: nrecords
+    INTEGER(size_t),  INTENT(in) :: type_size
+    REAL(KIND=16),INTENT(INOUT), DIMENSION(*), TARGET :: buf
+    INTEGER :: errcode 
+    INTEGER(size_t) :: namelen
+    TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    errcode = h5tbread_field_index_c(loc_id,namelen,dset_name,field_index,start,nrecords,type_size,f_ptr)
+  END SUBROUTINE h5tbread_field_index_kind_16_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbinsert_field_kind_4_rank_1
+!DEC$endif
+  SUBROUTINE h5tbinsert_field_kind_4_rank_1(loc_id,dset_name,field_name,field_type,field_index,buf,errcode)
+    IMPLICIT NONE
+        INTEGER(hid_t),   INTENT(in) :: loc_id
+        CHARACTER(LEN=*), INTENT(in) :: dset_name
+        CHARACTER(LEN=*), INTENT(in) :: field_name
+        INTEGER(hid_t), INTENT(in)   :: field_type
+        INTEGER, INTENT(in) :: field_index
+        REAL(KIND=4), INTENT(IN), DIMENSION(*), TARGET :: buf
+        INTEGER(size_t) :: namelen
+        INTEGER(size_t) :: namelen1
+        INTEGER :: errcode
+        TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbinsert_field_c(loc_id,namelen,dset_name,namelen1,field_name,field_type,field_index,f_ptr)
+  END SUBROUTINE h5tbinsert_field_kind_4_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbinsert_field_kind_8_rank_1
+!DEC$endif
+  SUBROUTINE h5tbinsert_field_kind_8_rank_1(loc_id,dset_name,field_name,field_type,field_index,buf,errcode)
+    IMPLICIT NONE
+        INTEGER(hid_t),   INTENT(in) :: loc_id
+        CHARACTER(LEN=*), INTENT(in) :: dset_name
+        CHARACTER(LEN=*), INTENT(in) :: field_name
+        INTEGER(hid_t), INTENT(in)   :: field_type
+        INTEGER, INTENT(in) :: field_index
+        REAL(KIND=8), INTENT(IN), DIMENSION(*), TARGET :: buf
+        INTEGER(size_t) :: namelen
+        INTEGER(size_t) :: namelen1
+        INTEGER :: errcode
+        TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbinsert_field_c(loc_id,namelen,dset_name,namelen1,field_name,field_type,field_index,f_ptr)
+  END SUBROUTINE h5tbinsert_field_kind_8_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbinsert_field_kind_10_rank_1
+!DEC$endif
+  SUBROUTINE h5tbinsert_field_kind_10_rank_1(loc_id,dset_name,field_name,field_type,field_index,buf,errcode)
+    IMPLICIT NONE
+        INTEGER(hid_t),   INTENT(in) :: loc_id
+        CHARACTER(LEN=*), INTENT(in) :: dset_name
+        CHARACTER(LEN=*), INTENT(in) :: field_name
+        INTEGER(hid_t), INTENT(in)   :: field_type
+        INTEGER, INTENT(in) :: field_index
+        REAL(KIND=10), INTENT(IN), DIMENSION(*), TARGET :: buf
+        INTEGER(size_t) :: namelen
+        INTEGER(size_t) :: namelen1
+        INTEGER :: errcode
+        TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbinsert_field_c(loc_id,namelen,dset_name,namelen1,field_name,field_type,field_index,f_ptr)
+  END SUBROUTINE h5tbinsert_field_kind_10_rank_1
+!DEC$if defined(BUILD_HDF5_HL_DLL)
+!DEC$attributes dllexport :: h5tbinsert_field_kind_16_rank_1
+!DEC$endif
+  SUBROUTINE h5tbinsert_field_kind_16_rank_1(loc_id,dset_name,field_name,field_type,field_index,buf,errcode)
+    IMPLICIT NONE
+        INTEGER(hid_t),   INTENT(in) :: loc_id
+        CHARACTER(LEN=*), INTENT(in) :: dset_name
+        CHARACTER(LEN=*), INTENT(in) :: field_name
+        INTEGER(hid_t), INTENT(in)   :: field_type
+        INTEGER, INTENT(in) :: field_index
+        REAL(KIND=16), INTENT(IN), DIMENSION(*), TARGET :: buf
+        INTEGER(size_t) :: namelen
+        INTEGER(size_t) :: namelen1
+        INTEGER :: errcode
+        TYPE(C_PTR) :: f_ptr
+    f_ptr = C_LOC(buf(1)            )
+    namelen = LEN(dset_name)
+    namelen1 = LEN(field_name)
+    errcode = h5tbinsert_field_c(loc_id,namelen,dset_name,namelen1,field_name,field_type,field_index,f_ptr)
+  END SUBROUTINE h5tbinsert_field_kind_16_rank_1
+END MODULE H5TB

config/toolchain/fortpregen/gfortran/H5f90i_gen.h

@@ -0,0 +1,49 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the LICENSE file, which can be found at the root of the source code       *
+ * distribution tree, or in https://www.hdfgroup.org/licenses.               *
+ * If you do not have access to either file, you may request a copy from     *
+ * help@hdfgroup.org.                                                        *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+#ifndef H5f90i_gen_H
+#define H5f90i_gen_H
+
+/* This file is automatically generated by H5match_types.c at build time. */
+
+#include "H5public.h"
+
+#define c_int_1 char
+#define c_int_2 short
+#define c_int_4 int
+#define c_int_8 long long
+#define c_size_t_8 size_t
+#define c_time_t_8 time_t
+#define c_hsize_t_8 hsize_t
+typedef struct {c_int_8 a; c_int_8 b;} c_int_16;
+#define c_float_4 float
+#define c_float_8 double
+#define c_float_10 long double
+#define c_float_16 __float128
+
+typedef c_int_8 haddr_t_f;
+typedef c_hsize_t_8 hsize_t_f;
+typedef c_int_8 hssize_t_f;
+typedef c_int_8 off_t_f;
+typedef c_size_t_8 size_t_f;
+typedef c_time_t_8 time_t_f;
+typedef c_int_4 int_f;
+typedef c_float_4 real_C_FLOAT_f;
+typedef c_float_8 real_C_DOUBLE_f;
+typedef c_float_10 real_C_LONG_DOUBLE_f;
+typedef c_float_16 real_C_FLOAT128_f;
+typedef c_int_8 hid_t_f;
+typedef c_float_4 real_f;
+typedef c_float_8 double_f;
+
+#endif /* _H5f90i_gen_H */

config/toolchain/fortpregen/gfortran/H5fortran_types.F90

@@ -0,0 +1,42 @@
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
+!   Copyright by The HDF Group.                                               *
+!   All rights reserved.                                                      *
+!                                                                             *
+!   This file is part of HDF5.  The full HDF5 copyright notice, including     *
+!   terms governing use, modification, and redistribution, is contained in    *
+!   the LICENSE file, which can be found at the root of the source code       *
+!   distribution tree, or in https://www.hdfgroup.org/licenses.               *
+!   If you do not have access to either file, you may request a copy from     *
+!   help@hdfgroup.org.                                                        *
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+!
+!
+! This file is automatically generated by H5match_types.c and contains HDF5 Fortran90 type definitions.
+!
+       MODULE H5FORTRAN_TYPES
+         USE ISO_C_BINDING
+         !
+         !  HDF5 integers
+         !
+        INTEGER, PARAMETER :: H5_FORTRAN_NUM_INTEGER_KINDS = 5
+        INTEGER, PARAMETER :: HADDR_T = 8
+        INTEGER, PARAMETER :: HSIZE_T = 8
+        INTEGER, PARAMETER :: HSSIZE_T = 8
+        INTEGER, PARAMETER :: OFF_T = 8
+        INTEGER, PARAMETER :: SIZE_T = 8
+        INTEGER, PARAMETER :: TIME_T = 8
+        INTEGER, PARAMETER :: Fortran_INTEGER = 4
+        INTEGER, DIMENSION(1:5), PARAMETER :: Fortran_INTEGER_AVAIL_KINDS = (/1,2,4,8,16/)
+        INTEGER, PARAMETER :: Fortran_REAL_C_FLOAT = 4
+        INTEGER, PARAMETER :: Fortran_REAL_C_DOUBLE = 8
+        INTEGER, PARAMETER :: Fortran_REAL_C_LONG_DOUBLE = 10
+        INTEGER, PARAMETER :: Fortran_REAL_C_FLOAT128 = 16
+        INTEGER, PARAMETER :: HID_T = 8
+        INTEGER, PARAMETER :: Fortran_REAL = C_FLOAT
+        INTEGER, PARAMETER :: Fortran_DOUBLE = C_DOUBLE
+        INTEGER, PARAMETER :: H5R_DSET_REG_REF_BUF_SIZE_F = 12
+        INTEGER, PARAMETER :: H5O_MAX_TOKEN_SIZE_F = 16
+
+        INTEGER(SIZE_T), PARAMETER :: OBJECT_NAMELEN_DEFAULT_F = -1
+
+        END MODULE H5FORTRAN_TYPES

config/toolchain/fortpregen/gfortran/tf_gen.F90

@@ -0,0 +1,387 @@
+!****h* ROBODoc/TH5_MISC_gen.F90
+!
+! NAME
+!  TH5_MISC_gen
+! 
+! PURPOSE
+!  This module is generated at build by H5_test_buildiface.F90 to handle checking 
+!  in the tests all the detected KINDs.
+!
+! COPYRIGHT
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+!   Copyright by The HDF Group.                                               *
+!   All rights reserved.                                                      *
+!                                                                             *
+!   This file is part of HDF5.  The full HDF5 copyright notice, including     *
+!   terms governing use, modification, and redistribution, is contained in    *
+!   the LICENSE file, which can be found at the root of the source code       *
+!   distribution tree, or in https://www.hdfgroup.org/licenses.               *
+!   If you do not have access to either file, you may request a copy from     *
+!   help@hdfgroup.org.                                                        *
+! * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+!
+! AUTHOR
+!  H5_test_buildiface.F90
+!
+!*****
+
+MODULE TH5_MISC_gen
+  USE, INTRINSIC :: ISO_C_BINDING
+  INTERFACE verify
+     MODULE PROCEDURE verify_real_kind_4
+     MODULE PROCEDURE verify_real_kind_8
+     MODULE PROCEDURE verify_real_kind_10
+     MODULE PROCEDURE verify_real_kind_16
+     MODULE PROCEDURE verify_integer_kind_1
+     MODULE PROCEDURE verify_integer_kind_2
+     MODULE PROCEDURE verify_integer_kind_4
+     MODULE PROCEDURE verify_integer_kind_8
+     MODULE PROCEDURE verify_integer_kind_16
+     MODULE PROCEDURE verify_character
+     MODULE PROCEDURE verify_logical
+     MODULE PROCEDURE verify_c_bool
+  END INTERFACE
+  INTERFACE check_real_eq
+     MODULE PROCEDURE real_eq_kind_4
+     MODULE PROCEDURE real_eq_kind_8
+     MODULE PROCEDURE real_eq_kind_10
+     MODULE PROCEDURE real_eq_kind_16
+  END INTERFACE
+CONTAINS
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_integer_kind_1
+!DEC$endif
+  SUBROUTINE verify_integer_kind_1(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    INTEGER(KIND=1) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NE. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQ. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_integer_kind_1
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_integer_kind_2
+!DEC$endif
+  SUBROUTINE verify_integer_kind_2(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    INTEGER(KIND=2) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NE. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQ. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_integer_kind_2
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_integer_kind_4
+!DEC$endif
+  SUBROUTINE verify_integer_kind_4(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    INTEGER(KIND=4) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NE. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQ. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_integer_kind_4
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_integer_kind_8
+!DEC$endif
+  SUBROUTINE verify_integer_kind_8(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    INTEGER(KIND=8) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NE. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQ. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_integer_kind_8
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_integer_kind_16
+!DEC$endif
+  SUBROUTINE verify_integer_kind_16(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    INTEGER(KIND=16) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NE. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQ. correct_value) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT INTEGER VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_integer_kind_16
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_real_kind_4
+!DEC$endif
+  SUBROUTINE verify_real_kind_4(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    REAL(KIND=4) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (.NOT.real_eq_kind_4( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (real_eq_kind_4( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_real_kind_4
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: real_eq_kind_4
+!DEC$endif
+  LOGICAL FUNCTION real_eq_kind_4(a,b,ulp)
+    IMPLICIT NONE
+    REAL(KIND=4), INTENT (in):: a,b
+    REAL(KIND=4) :: Rel
+    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
+    IF ( PRESENT( ulp ) )  Rel = REAL( ABS(ulp), 4)
+    Rel = 1.0_4
+    real_eq_kind_4 = ABS( a - b ) < ( Rel * SPACING( MAX(ABS(a),ABS(b)) ) )
+  END FUNCTION real_eq_kind_4
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_real_kind_8
+!DEC$endif
+  SUBROUTINE verify_real_kind_8(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    REAL(KIND=8) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (.NOT.real_eq_kind_8( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (real_eq_kind_8( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_real_kind_8
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: real_eq_kind_8
+!DEC$endif
+  LOGICAL FUNCTION real_eq_kind_8(a,b,ulp)
+    IMPLICIT NONE
+    REAL(KIND=8), INTENT (in):: a,b
+    REAL(KIND=8) :: Rel
+    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
+    IF ( PRESENT( ulp ) )  Rel = REAL( ABS(ulp), 8)
+    Rel = 1.0_8
+    real_eq_kind_8 = ABS( a - b ) < ( Rel * SPACING( MAX(ABS(a),ABS(b)) ) )
+  END FUNCTION real_eq_kind_8
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_real_kind_10
+!DEC$endif
+  SUBROUTINE verify_real_kind_10(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    REAL(KIND=10) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (.NOT.real_eq_kind_10( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (real_eq_kind_10( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_real_kind_10
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: real_eq_kind_10
+!DEC$endif
+  LOGICAL FUNCTION real_eq_kind_10(a,b,ulp)
+    IMPLICIT NONE
+    REAL(KIND=10), INTENT (in):: a,b
+    REAL(KIND=10) :: Rel
+    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
+    IF ( PRESENT( ulp ) )  Rel = REAL( ABS(ulp), 10)
+    Rel = 1.0_10
+    real_eq_kind_10 = ABS( a - b ) < ( Rel * SPACING( MAX(ABS(a),ABS(b)) ) )
+  END FUNCTION real_eq_kind_10
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_real_kind_16
+!DEC$endif
+  SUBROUTINE verify_real_kind_16(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    REAL(KIND=16) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (.NOT.real_eq_kind_16( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (real_eq_kind_16( value, correct_value) ) THEN
+         total_error=total_error+1
+         WRITE(*,*) "ERROR: INCORRECT REAL VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_real_kind_16
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: real_eq_kind_16
+!DEC$endif
+  LOGICAL FUNCTION real_eq_kind_16(a,b,ulp)
+    IMPLICIT NONE
+    REAL(KIND=16), INTENT (in):: a,b
+    REAL(KIND=16) :: Rel
+    INTEGER,        OPTIONAL, INTENT( IN )  :: ulp
+    IF ( PRESENT( ulp ) )  Rel = REAL( ABS(ulp), 16)
+    Rel = 1.0_16
+    real_eq_kind_16 = ABS( a - b ) < ( Rel * SPACING( MAX(ABS(a),ABS(b)) ) )
+  END FUNCTION real_eq_kind_16
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_character
+!DEC$endif
+  SUBROUTINE verify_character(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER*(*) :: string
+    CHARACTER*(*) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (TRIM(value) .NE. TRIM(correct_value)) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (TRIM(value) .EQ. TRIM(correct_value)) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_character
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_logical
+!DEC$endif
+  SUBROUTINE verify_logical(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    LOGICAL :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NEQV. correct_value) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQV. correct_value) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_logical
+!DEC$if defined(BUILD_HDF5_TEST_DLL)
+!DEC$attributes dllexport :: verify_c_bool
+!DEC$endif
+  SUBROUTINE verify_c_bool(string,value,correct_value,total_error,chck_eq)
+    IMPLICIT NONE
+    CHARACTER(LEN=*) :: string
+    LOGICAL(C_BOOL) :: value, correct_value
+    INTEGER :: total_error
+    LOGICAL, OPTIONAL :: chck_eq
+    LOGICAL :: chck_eq_opt
+    chck_eq_opt = .TRUE.
+    IF(PRESENT(chck_eq)) chck_eq_opt = chck_eq
+    IF(chck_eq_opt .EQV. .TRUE.)THEN
+      IF (value .NEQV. correct_value) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ELSE
+      IF (value .EQV. correct_value) THEN
+         total_error = total_error + 1
+         WRITE(*,*) "ERROR: INCORRECT VALIDATION ", string
+      ENDIF
+    ENDIF
+  END SUBROUTINE verify_c_bool
+END MODULE TH5_MISC_gen

config/toolchain/fortpregen/gfortran/version.txt

@@ -0,0 +1,4 @@
+HDF5_VERSION=2.0.0
+COMPILER=gfortran
+PLATFORM=x86_64-w64-mingw32
+TOOLCHAIN=mingw64.cmake

config/toolchain/intel.cmake

@@ -1,15 +1,15 @@
 # Uncomment the following to use cross-compiling
-#set(CMAKE_SYSTEM_NAME Linux)
+#set (CMAKE_SYSTEM_NAME Linux)
 
-set(CMAKE_COMPILER_VENDOR "intel")
+set (CMAKE_COMPILER_VENDOR "intel")
 
-set(CMAKE_C_COMPILER icx)
+set (CMAKE_C_COMPILER icx)
-if(WIN32)
+if (WIN32)
- set(CMAKE_CXX_COMPILER icx)
+ set (CMAKE_CXX_COMPILER icx)
-else()
+else ()
-  set(CMAKE_CXX_COMPILER icpx)
+  set (CMAKE_CXX_COMPILER icpx)
-endif()
+endif ()
-set(CMAKE_Fortran_COMPILER ifx)
+set (CMAKE_Fortran_COMPILER ifx)
 
 # the following is used if cross-compiling
-set(CMAKE_CROSSCOMPILING_EMULATOR "")
+set (CMAKE_CROSSCOMPILING_EMULATOR "")

config/toolchain/mingw64.cmake

@@ -1,14 +1,37 @@
 set (TOOLCHAIN_PREFIX x86_64-w64-mingw32)
 set (CMAKE_SYSTEM_NAME Windows)
-set (CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+set (CMAKE_SYSTEM_PROCESSOR x86_64)
-set (CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
+
-set (CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)
+# specify the cross compiler
-set (CMAKE_Fortran_COMPILER ${TOOLCHAIN_PREFIX}-gfortran)
+if (NOT DEFINED ENV{CC})
-set (CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})
+  set (CMAKE_C_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-gcc)
+endif ()
+if (NOT DEFINED ENV{CXX})
+set (CMAKE_CXX_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-g++)
+endif ()
+if (NOT DEFINED ENV{FC})
+set (CMAKE_Fortran_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-gfortran)
+# set the resource compiler (RHBZ #652435)
+endif ()
+if (NOT DEFINED ENV{RC})
+set (CMAKE_RC_COMPILER /usr/bin/${TOOLCHAIN_PREFIX}-windres)
+endif ()
+
+set (CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw)
+
+# search for programs in the build host directories
 set (CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+# for libraries, headers and packages in the target directories
 set (CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set (CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set (CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
 set (CMAKE_CROSSCOMPILING_EMULATOR wine64)
+set (CROSSCOMPILING_PATH "WINEPATH=/usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/")
 
-include_directories(/usr/${TOOLCHAIN_PREFIX}/include)
 set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS On CACHE BOOL "Export windows symbols")
+
+set (CMAKE_AR:FILEPATH /usr/bin/${TOOLCHAIN_PREFIX}-ar)
+set (CMAKE_RANLIB:FILEPATH /usr/bin/${TOOLCHAIN_PREFIX}-ranlib)
+
+set (HDF5_USE_PREGEN_DIR "${CMAKE_CURRENT_LIST_DIR}/fortpregen/gfortran" CACHE PATH "Path to pregenerated Fortran files")
+

fortran/src/CMakeLists.txt

@@ -99,6 +99,12 @@ configure_file (${HDF5_F90_SRC_SOURCE_DIR}/H5fort_type_defines.h.cmake ${HDF5_F9
 
 set (Fortran_COMPILER_ID CMAKE_Fortran_COMPILER_ID)
 
+if (HDF5_USE_PREGEN)
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_USE_PREGEN_DIR})
+else ()
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_F90_BINARY_DIR})
+endif ()
+
 #-----------------------------------------------------------------------------
 # Setup the Fortran auto-detection utilities
 # H5_buildiface.F90      used to generate various KIND interfaces
@@ -110,13 +116,11 @@ target_include_directories (H5_buildiface PRIVATE "${HDF5_SRC_BINARY_DIR};${HDF5
 #if (BUILD_SHARED_LIBS)
 #  target_compile_definitions(H5_buildiface PRIVATE "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/MT>")
 #endif ()
-if(MSVC)
+if (MSVC)
-  set_property(TARGET H5_buildiface PROPERTY COMPILE_FLAGS "/MT")
+  set_property (TARGET H5_buildiface PROPERTY COMPILE_FLAGS "/MT")
-endif()
+  #set_property (TARGET H5_buildiface APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET H5_buildiface APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+  set_property (TARGET H5_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
-if(MSVC)
+endif ()
-  set_property(TARGET H5_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
-endif()
 
 set_target_properties (H5_buildiface PROPERTIES
     LINKER_LANGUAGE Fortran
@@ -138,20 +142,62 @@ add_executable (H5match_types
     ${HDF5_F90_SRC_SOURCE_DIR}/H5match_types.c
 )
 target_include_directories (H5match_types PRIVATE "${HDF5_SRC_BINARY_DIR};${HDF5_SRC_INCLUDE_DIRS};${HDF5_F90_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")
-
+# check if a pre-generated H5fortran_types.F90 file is present
-add_custom_command (TARGET H5match_types POST_BUILD
+if (NOT EXISTS "${HDF5_GENERATED_SOURCE_DIR}/H5fortran_types.F90")
-    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90
+  message (STATUS "No pre-generated H5fortran_types.F90 file found - generating one")
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5match_types>
+  # execute the H5match_types program
-    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+  if (CMAKE_CROSSCOMPILING)
-)
+    add_custom_command (TARGET H5match_types POST_BUILD
+        BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E env ${CROSSCOMPILING_PATH}
+        COMMAND    $<TARGET_FILE:H5match_types>
+        WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+        COMMENT "Generating the H5fortran_types.F90 and H5f90i_gen.h files"
+    )
+  else ()
+    add_custom_command (TARGET H5match_types POST_BUILD
+        BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90
+        COMMAND    $<TARGET_FILE:H5match_types>
+        WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+        COMMENT "Generating the H5fortran_types.F90 and H5f90i_gen.h files"
+    )
+  endif ()
+else ()
+  message (STATUS "Using existing pre-generated H5fortran_types.F90 file")
+  add_custom_command (
+      OUTPUT     gen_SRCS.stamp1
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E touch gen_SRCS.stamp1
+      DEPENDS    H5f90i_gen.h H5fortran_types.F90
+      WORKING_DIRECTORY ${HDF5_GENERATED_SOURCE_DIR}
+      COMMENT    "Touch existing H5f90i_gen.h H5fortran_types.F90"
+  )
+  set_source_files_properties (${HDF5_GENERATED_SOURCE_DIR}/H5fortran_types.F90 PROPERTIES GENERATED TRUE)
+  if (BUILD_SHARED_LIBS)
+    add_custom_command (
+        OUTPUT     shared/shared_gen_SRCS.stamp1
+        BYPRODUCTS shared/H5f90i_gen.h shared/H5fortran_types.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E copy_if_different H5f90i_gen.h shared/H5f90i_gen.h
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E copy_if_different H5fortran_types.F90 shared/H5fortran_types.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E touch shared/shared_gen_SRCS.stamp1
+        DEPENDS H5f90i_gen.h H5fortran_types.F90 gen_SRCS.stamp1
+        WORKING_DIRECTORY ${HDF5_GENERATED_SOURCE_DIR}
+        COMMENT    "Copy existing H5f90i_gen.h H5fortran_types.F90 to shared folder"
+    )
+  endif ()
+endif ()
 
 if (BUILD_STATIC_LIBS)
   add_custom_command (TARGET H5match_types POST_BUILD
       BYPRODUCTS ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/static/H5fortran_types.F90
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/static/H5fortran_types.F90
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/static/H5fortran_types.F90
       WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/static
   )
   set_source_files_properties (${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h PROPERTIES GENERATED TRUE)
@@ -161,9 +207,9 @@ if (BUILD_SHARED_LIBS)
   add_custom_command (TARGET H5match_types POST_BUILD
       BYPRODUCTS ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/shared/H5fortran_types.F90
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5f90i_gen.h ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/shared/H5fortran_types.F90
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5fortran_types.F90 ${HDF5_F90_BINARY_DIR}/shared/H5fortran_types.F90
       WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/shared
   )
   set_source_files_properties (${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h PROPERTIES GENERATED TRUE)
@@ -225,7 +271,7 @@ if (BUILD_STATIC_LIBS)
       PRIVATE "${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static;$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
   )
-  target_compile_options(${HDF5_F90_C_LIB_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
+  target_compile_options (${HDF5_F90_C_LIB_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
   TARGET_C_PROPERTIES (${HDF5_F90_C_LIB_TARGET} STATIC)
   target_link_libraries (${HDF5_F90_C_LIB_TARGET} PUBLIC ${HDF5_LIB_TARGET})
   set_global_variable (HDF5_LIBRARIES_TO_EXPORT "${HDF5_LIBRARIES_TO_EXPORT};${HDF5_F90_C_LIB_TARGET}")
@@ -244,8 +290,8 @@ if (BUILD_SHARED_LIBS)
       PRIVATE "${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/shared;$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
   )
-  target_compile_options(${HDF5_F90_C_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
+  target_compile_options (${HDF5_F90_C_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
-  target_compile_definitions(${HDF5_F90_C_LIBSH_TARGET} PUBLIC "H5_BUILT_AS_DYNAMIC_LIB")
+  target_compile_definitions (${HDF5_F90_C_LIBSH_TARGET} PUBLIC "H5_BUILT_AS_DYNAMIC_LIB")
   TARGET_C_PROPERTIES (${HDF5_F90_C_LIBSH_TARGET} SHARED)
   target_link_libraries (${HDF5_F90_C_LIBSH_TARGET} PUBLIC ${HDF5_LIBSH_TARGET})
   set_global_variable (HDF5_LIBRARIES_TO_EXPORT "${HDF5_LIBRARIES_TO_EXPORT};${HDF5_F90_C_LIBSH_TARGET}")
@@ -289,22 +335,54 @@ set (f90_F_GEN_SOURCES
     ${HDF5_F90_SRC_SOURCE_DIR}/H5Dff.F90
     ${HDF5_F90_SRC_SOURCE_DIR}/H5Pff.F90
 )
-add_custom_command (TARGET H5_buildiface POST_BUILD
+# check if a pre-generated H5fortran_types.F90 file is present
-    BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5_gen.F90
+if (NOT EXISTS "${HDF5_GENERATED_SOURCE_DIR}/H5_gen.F90")
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_buildiface>
+  message (STATUS "No pre-generated H5_gen.F90 file found - generating one")
-    WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+  if (CMAKE_CROSSCOMPILING)
-    COMMENT "Generating the H5_gen.F90 file"
+    add_custom_command (TARGET H5_buildiface POST_BUILD
-)
+        BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5_gen.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E env ${CROSSCOMPILING_PATH}
+        COMMAND    $<TARGET_FILE:H5_buildiface>
+        WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+        COMMENT "Generating the H5_gen.F90 file"
+    )
+  else ()
+    add_custom_command (TARGET H5_buildiface POST_BUILD
+        BYPRODUCTS ${HDF5_F90_BINARY_DIR}/H5_gen.F90
+        COMMAND    $<TARGET_FILE:H5_buildiface>
+        WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}
+        COMMENT "Generating the H5_gen.F90 file"
+    )
+  endif ()
+else ()
+  message (STATUS "Using existing pre-generated H5_gen.F90 file")
+  add_custom_command (
+      OUTPUT     gen_SRCS.stamp3
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E touch gen_SRCS.stamp3
+      DEPENDS    H5_gen.F90
+      WORKING_DIRECTORY ${HDF5_GENERATED_SOURCE_DIR}
+      COMMENT    "Touch existing H5_gen.F90"
+  )
+  set_source_files_properties (${HDF5_GENERATED_SOURCE_DIR}/H5_gen.F90 PROPERTIES GENERATED TRUE)
+endif ()
+
+set (f90_gen_deps "")
+if (NOT HDF5_USE_PREGEN)
+  set (f90_gen_deps H5_buildiface)
+endif ()
+
 if (BUILD_STATIC_LIBS)
   add_custom_command (TARGET H5_buildiface POST_BUILD
       BYPRODUCTS ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
       WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/static
       COMMENT "Generating the H5_gen.F90 file"
   )
   add_custom_target (H5gen ALL
-      DEPENDS H5_buildiface ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
+      DEPENDS ${f90_gen_deps} ${HDF5_F90_BINARY_DIR}/static/H5_gen.F90
   )
   set_source_files_properties (${HDF5_F90_BINARY_DIR}/static/H5_gen.F90 PROPERTIES GENERATED TRUE)
 endif ()
@@ -313,12 +391,12 @@ if (BUILD_SHARED_LIBS)
   add_custom_command (TARGET H5_buildiface POST_BUILD
       BYPRODUCTS ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
       COMMAND    ${CMAKE_COMMAND}
-      ARGS       -E copy_if_different ${HDF5_F90_BINARY_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5_gen.F90 ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
       WORKING_DIRECTORY ${HDF5_F90_BINARY_DIR}/shared
       COMMENT "Generating the H5_gen.F90 shared file"
   )
   add_custom_target (H5genSH ALL
-      DEPENDS H5_buildiface ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
+      DEPENDS ${f90_gen_deps} ${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90
   )
   set_source_files_properties (${HDF5_F90_BINARY_DIR}/shared/H5_gen.F90 PROPERTIES GENERATED TRUE)
 endif ()
@@ -384,8 +462,8 @@ if (BUILD_STATIC_LIBS)
       PRIVATE "${HDF5_F90_SRC_SOURCE_DIR};${CMAKE_Fortran_MODULE_DIRECTORY}/static;${HDF5_F90_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_Fortran_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${HDF5_INSTALL_MODULE_DIR}/static>"
   )
-  target_compile_options(${HDF5_F90_LIB_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
+  target_compile_options (${HDF5_F90_LIB_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
-  target_compile_definitions(${HDF5_F90_LIB_TARGET}
+  target_compile_definitions (${HDF5_F90_LIB_TARGET}
       PRIVATE
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:HDF5F90_WINDOWS>"
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
@@ -396,9 +474,9 @@ if (BUILD_STATIC_LIBS)
           ${LINK_Fortran_LIBS}
           "$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_Fortran_LIBRARIES}>"
   )
-  if(MSVC)
+  if (MSVC)
-    set_property(TARGET ${HDF5_F90_LIB_TARGET} PROPERTY LINK_FLAGS "${WIN_LINK_FLAGS}")
+    set_property (TARGET ${HDF5_F90_LIB_TARGET} PROPERTY LINK_FLAGS "${WIN_LINK_FLAGS}")
-  endif()
+  endif ()
   set_target_properties (${HDF5_F90_LIB_TARGET} PROPERTIES
       FOLDER libraries/fortran
       LINKER_LANGUAGE Fortran
@@ -407,22 +485,22 @@ if (BUILD_STATIC_LIBS)
   H5_SET_LIB_OPTIONS (${HDF5_F90_LIB_TARGET} ${HDF5_F90_LIB_NAME} STATIC 0)
   set_global_variable (HDF5_LIBRARIES_TO_EXPORT "${HDF5_LIBRARIES_TO_EXPORT};${HDF5_F90_LIB_TARGET}")
   set (install_targets ${install_targets} ${HDF5_F90_LIB_TARGET})
-  add_dependencies(${HDF5_F90_LIB_TARGET} H5gen)
+  add_dependencies (${HDF5_F90_LIB_TARGET} H5gen)
 endif ()
 
 if (BUILD_SHARED_LIBS)
-  if(MSVC)
+  if (MSVC)
-      set(DLLDEF ${HDF5_F90_SRC_BINARY_DIR}/hdf5_fortrandll.def)
+      set (DLLDEF ${HDF5_F90_SRC_BINARY_DIR}/hdf5_fortrandll.def)
-  else()
+  else ()
-      set(DLLDEF "")
+      set (DLLDEF "")
-  endif()
+  endif ()
   add_library (${HDF5_F90_LIBSH_TARGET} SHARED ${DLLDEF} ${f90_F_SOURCES_SHARED})
   target_include_directories (${HDF5_F90_LIBSH_TARGET}
       PRIVATE "${HDF5_F90_SRC_SOURCE_DIR};${CMAKE_Fortran_MODULE_DIRECTORY}/shared;${HDF5_F90_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_Fortran_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${HDF5_INSTALL_MODULE_DIR}/shared>"
   )
-  target_compile_options(${HDF5_F90_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
+  target_compile_options (${HDF5_F90_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
-  target_compile_definitions(${HDF5_F90_LIBSH_TARGET}
+  target_compile_definitions (${HDF5_F90_LIBSH_TARGET}
       PUBLIC "H5_BUILT_AS_DYNAMIC_LIB"
       PRIVATE
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:BUILD_HDF5_DLL;HDF5F90_WINDOWS>"
@@ -432,9 +510,9 @@ if (BUILD_SHARED_LIBS)
       PUBLIC ${HDF5_F90_C_LIBSH_TARGET}
       PRIVATE ${LINK_Fortran_LIBS} "$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_Fortran_LIBRARIES}>"
   )
-  if(MSVC)
+  if (MSVC)
     target_link_options (${HDF5_F90_LIBSH_TARGET} PRIVATE "${WIN_LINK_FLAGS}")
-  endif()
+  endif ()
   set_target_properties (${HDF5_F90_LIBSH_TARGET} PROPERTIES
       FOLDER libraries/fortran
       LINKER_LANGUAGE Fortran
@@ -454,30 +532,24 @@ install (
         ${HDF5_F90_SRC_SOURCE_DIR}/H5f90.h
         ${HDF5_F90_SRC_SOURCE_DIR}/H5f90i.h
         ${HDF5_F90_SRC_SOURCE_DIR}/H5f90proto.h
-    DESTINATION
+    DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-        ${HDF5_INSTALL_INCLUDE_DIR}
+    COMPONENT fortheaders
-    COMPONENT
-        fortheaders
 )
 if (BUILD_STATIC_LIBS)
   install (
       FILES
           ${HDF5_F90_BINARY_DIR}/static/H5f90i_gen.h
           ${HDF5_F90_BINARY_DIR}/H5config_f.inc
-      DESTINATION
+      DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-          ${HDF5_INSTALL_INCLUDE_DIR}
+      COMPONENT fortheaders
-      COMPONENT
-          fortheaders
   )
 else ()
   install (
       FILES
           ${HDF5_F90_BINARY_DIR}/shared/H5f90i_gen.h
           ${HDF5_F90_BINARY_DIR}/H5config_f.inc
-      DESTINATION
+      DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-          ${HDF5_INSTALL_INCLUDE_DIR}
+      COMPONENT fortheaders
-      COMPONENT
-          fortheaders
   )
 endif ()
 
@@ -511,21 +583,15 @@ if (BUILD_STATIC_LIBS)
     set (mod_files ${mod_files} ${MOD_BUILD_DIR}/${mod_file})
   endforeach ()
   install (
-      FILES
+      FILES ${mod_files}
-          ${mod_files}
+      DESTINATION ${HDF5_INSTALL_MODULE_DIR}/static
-      DESTINATION
+      COMPONENT fortheaders
-          ${HDF5_INSTALL_MODULE_DIR}/static
-      COMPONENT
-          fortheaders
   )
   if (HDF5_INSTALL_MOD_FORTRAN MATCHES "STATIC")
     install (
-        FILES
+        FILES ${mod_files}
-            ${mod_files}
+        DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-        DESTINATION
+        COMPONENT fortheaders
-            ${HDF5_INSTALL_INCLUDE_DIR}
-        COMPONENT
-            fortheaders
     )
   endif ()
 endif ()
@@ -535,21 +601,15 @@ if (BUILD_SHARED_LIBS)
     set (modsh_files ${modsh_files} ${MODSH_BUILD_DIR}/${mod_file})
   endforeach ()
   install (
-      FILES
+      FILES ${modsh_files}
-          ${modsh_files}
+      DESTINATION ${HDF5_INSTALL_MODULE_DIR}/shared
-      DESTINATION
+      COMPONENT fortheaders
-          ${HDF5_INSTALL_MODULE_DIR}/shared
-      COMPONENT
-          fortheaders
   )
   if (HDF5_INSTALL_MOD_FORTRAN MATCHES "SHARED")
     install (
-        FILES
+        FILES ${modsh_files}
-            ${modsh_files}
+        DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-        DESTINATION
+        COMPONENT  fortheaders
-            ${HDF5_INSTALL_INCLUDE_DIR}
-        COMPONENT
-            fortheaders
     )
   endif ()
 endif ()
@@ -568,10 +628,8 @@ if (HDF5_EXPORTED_TARGETS)
   endif ()
 
   install (
-      TARGETS
+      TARGETS ${install_targets}
-          ${install_targets}
+      EXPORT ${HDF5_EXPORTED_TARGETS}
-      EXPORT
-          ${HDF5_EXPORTED_TARGETS}
       LIBRARY DESTINATION ${HDF5_INSTALL_LIB_DIR} COMPONENT fortlibraries
       ARCHIVE DESTINATION ${HDF5_INSTALL_LIB_DIR} COMPONENT fortlibraries
       RUNTIME DESTINATION ${HDF5_INSTALL_BIN_DIR} COMPONENT fortlibraries

fortran/test/CMakeLists.txt

@@ -7,6 +7,12 @@
 cmake_minimum_required (VERSION 3.26)
 project (HDF5_FORTRAN_TESTS C Fortran)
 
+if (HDF5_USE_PREGEN)
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_USE_PREGEN_DIR})
+else ()
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_FORTRAN_TESTS_BINARY_DIR})
+endif ()
+
 #-----------------------------------------------------------------------------
 # Setup the Fortran auto-detection utilities
 # H5_test_buildiface.F90         used to generate various KIND test interfaces
@@ -18,19 +24,19 @@ target_include_directories (H5_test_buildiface
         ${HDF5_SRC_BINARY_DIR} ${HDF5_F90_BINARY_DIR}
 )
 #if (BUILD_SHARED_LIBS)
-#  target_compile_definitions(H5_test_buildiface
+#  target_compile_definitions (H5_test_buildiface
 #      PRIVATE "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/MT>"
 #  )
 #endif ()
-if(MSVC)
+if (MSVC)
-  set_property(TARGET H5_test_buildiface PROPERTY COMPILE_FLAGS "/MT")
+  set_property (TARGET H5_test_buildiface PROPERTY COMPILE_FLAGS "/MT")
-endif()
+endif ()
-#set_property(TARGET H5_test_buildiface APPEND PROPERTY
+#set_property (TARGET H5_test_buildiface APPEND PROPERTY
 #    LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>"
 #)
-if(MSVC)
+if (MSVC)
-  set_property(TARGET H5_test_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
+  set_property (TARGET H5_test_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
-endif()
+endif ()
 set_target_properties (H5_test_buildiface PROPERTIES
     LINKER_LANGUAGE Fortran
     Fortran_MODULE_DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}
@@ -54,7 +60,7 @@ if (NOT BUILD_SHARED_LIBS)
       PRIVATE "${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static;$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
   )
-  target_compile_options(${HDF5_F90_C_TEST_LIB_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
+  target_compile_options (${HDF5_F90_C_TEST_LIB_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
   TARGET_C_PROPERTIES (${HDF5_F90_C_TEST_LIB_TARGET} STATIC)
   target_link_libraries (${HDF5_F90_C_TEST_LIB_TARGET}
       PRIVATE ${HDF5_F90_C_LIB_TARGET}
@@ -71,8 +77,8 @@ else ()
       PRIVATE "${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/shared;$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
   )
-  target_compile_options(${HDF5_F90_C_TEST_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
+  target_compile_options (${HDF5_F90_C_TEST_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_C_FLAGS}")
-  target_compile_definitions(${HDF5_F90_C_TEST_LIBSH_TARGET} PUBLIC "H5_BUILT_AS_DYNAMIC_LIB")
+  target_compile_definitions (${HDF5_F90_C_TEST_LIBSH_TARGET} PUBLIC "H5_BUILT_AS_DYNAMIC_LIB")
   TARGET_C_PROPERTIES (${HDF5_F90_C_TEST_LIBSH_TARGET} SHARED)
   target_link_libraries (${HDF5_F90_C_TEST_LIBSH_TARGET}
       PRIVATE ${HDF5_F90_C_LIBSH_TARGET}
@@ -96,26 +102,63 @@ if (HDF5_ENABLE_FORMATTERS)
   endif ()
 endif ()
 
-if (NOT BUILD_SHARED_LIBS)
+if (NOT EXISTS "${HDF5_GENERATED_SOURCE_DIR}/tf_gen.F90")
-  add_custom_command (TARGET H5_test_buildiface POST_BUILD
+  message (STATUS "No pre-generated tf_gen.F90 file found - generating one")
-      BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
+  if (CMAKE_CROSSCOMPILING)
-      COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_test_buildiface>
+    add_custom_command (TARGET H5_test_buildiface POST_BUILD
-      WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static
+        BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/tf_gen.F90
-      COMMENT "Generating the tf_gen.F90 static file"
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E env ${CROSSCOMPILING_PATH}
+        COMMAND    $<TARGET_FILE:H5_test_buildiface>
+        WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}
+        COMMENT "Generating the tf_gen.F90 static file"
+    )
+  else ()
+    add_custom_command (TARGET H5_test_buildiface POST_BUILD
+        BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/tf_gen.F90
+        COMMAND    $<TARGET_FILE:H5_test_buildiface>
+        WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}
+        COMMENT "Generating the tf_gen.F90 static file"
+    )
+  endif ()
+else ()
+  message (STATUS "Using existing pre-generated tf_gen.F90 file")
+  add_custom_command (
+      OUTPUT     gen_SRCS.stamp4
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E touch gen_SRCS.stamp4
+      DEPENDS    tf_gen.F90
+      WORKING_DIRECTORY ${HDF5_GENERATED_SOURCE_DIR}
+      COMMENT    "Touch existing tf_gen.F90"
   )
+  set_source_files_properties (${HDF5_FORTRAN_TESTS_BINARY_DIR}/tf_gen.F90 PROPERTIES GENERATED TRUE)
+endif ()
+
+set (test_f90_gen_deps "")
+if (NOT HDF5_USE_PREGEN)
+  set (test_f90_gen_deps H5_test_buildiface)
+endif ()
+
+if (NOT BUILD_SHARED_LIBS)
+    add_custom_command (TARGET H5_test_buildiface POST_BUILD
+        BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/tf_gen.F90 ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
+        WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static
+    )
   add_custom_target (H5testgen ALL
-      DEPENDS H5_test_buildiface ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
+      DEPENDS ${test_f90_gen_deps} ${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90
   )
   set_source_files_properties (${HDF5_FORTRAN_TESTS_BINARY_DIR}/static/tf_gen.F90 PROPERTIES GENERATED TRUE)
 else ()
   add_custom_command (TARGET H5_test_buildiface POST_BUILD
       BYPRODUCTS ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90
-      COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5_test_buildiface>
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/tf_gen.F90 ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90
       WORKING_DIRECTORY ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared
-      COMMENT "Generating the tf_gen.F90 shared file"
   )
   add_custom_target (H5testgenSH ALL
-      DEPENDS H5_test_buildiface ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90
+      DEPENDS ${test_f90_gen_deps} ${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90
   )
   set_source_files_properties (${HDF5_FORTRAN_TESTS_BINARY_DIR}/shared/tf_gen.F90 PROPERTIES GENERATED TRUE)
 endif ()
@@ -146,50 +189,50 @@ if (NOT BUILD_SHARED_LIBS)
       PRIVATE "${CMAKE_Fortran_MODULE_DIRECTORY}/static;${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include/static>"
   )
-  target_compile_options(${HDF5_F90_TEST_LIB_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
+  target_compile_options (${HDF5_F90_TEST_LIB_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
-  target_compile_definitions(${HDF5_F90_TEST_LIB_TARGET}
+  target_compile_definitions (${HDF5_F90_TEST_LIB_TARGET}
       PRIVATE
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:HDF5F90_WINDOWS>"
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
   )
   target_link_libraries (${HDF5_F90_TEST_LIB_TARGET} PUBLIC ${HDF5_F90_C_TEST_LIB_TARGET} ${HDF5_F90_LIB_TARGET} ${HDF5_LIB_TARGET})
-#  set_property(TARGET ${HDF5_F90_TEST_LIB_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#  set_property (TARGET ${HDF5_F90_TEST_LIB_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-  if(MSVC)
+  if (MSVC)
-    set_property(TARGET ${HDF5_F90_TEST_LIB_TARGET} PROPERTY LINK_FLAGS "${WIN_LINK_FLAGS}")
+    set_property (TARGET ${HDF5_F90_TEST_LIB_TARGET} PROPERTY LINK_FLAGS "${WIN_LINK_FLAGS}")
-  endif()
+  endif ()
   set_target_properties (${HDF5_F90_TEST_LIB_TARGET} PROPERTIES
       FOLDER libraries/test/fortran
       LINKER_LANGUAGE Fortran
       Fortran_MODULE_DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}/static
   )
   H5_SET_LIB_OPTIONS (${HDF5_F90_TEST_LIB_TARGET} ${HDF5_F90_TEST_LIB_NAME} STATIC 0)
-  add_dependencies(${HDF5_F90_TEST_LIB_TARGET} H5testgen)
+  add_dependencies (${HDF5_F90_TEST_LIB_TARGET} H5testgen)
 else ()
   add_library (${HDF5_F90_TEST_LIBSH_TARGET} SHARED ${HDF5_F90_TF_SOURCES_SHARED})
   target_include_directories (${HDF5_F90_TEST_LIBSH_TARGET}
       PRIVATE "${CMAKE_Fortran_MODULE_DIRECTORY}/shared;${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/shared"
       INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include/shared>"
   )
-  target_compile_options(${HDF5_F90_TEST_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
+  target_compile_options (${HDF5_F90_TEST_LIBSH_TARGET} PRIVATE "${HDF5_CMAKE_Fortran_FLAGS}")
-  target_compile_definitions(${HDF5_F90_TEST_LIBSH_TARGET}
+  target_compile_definitions (${HDF5_F90_TEST_LIBSH_TARGET}
       PUBLIC "H5_BUILT_AS_DYNAMIC_LIB"
       PRIVATE
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:BUILD_HDF5_TEST_DLL;HDF5F90_WINDOWS>"
           "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
   )
   target_link_libraries (${HDF5_F90_TEST_LIBSH_TARGET} PUBLIC ${HDF5_F90_C_TEST_LIBSH_TARGET} ${HDF5_F90_LIBSH_TARGET} ${HDF5_LIBSH_TARGET})
-#  set_property(TARGET ${HDF5_F90_TEST_LIBSH_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#  set_property (TARGET ${HDF5_F90_TEST_LIBSH_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-#  set_property(TARGET ${HDF5_F90_TEST_LIBSH_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/DLL>")
+#  set_property (TARGET ${HDF5_F90_TEST_LIBSH_TARGET} APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/DLL>")
-#  if(MSVC)
+#  if (MSVC)
 #    target_link_options (${HDF5_F90_TEST_LIBSH_TARGET} PRIVATE "${WIN_LINK_FLAGS} /DLL")
-#  endif()
+#  endif ()
   set_target_properties (${HDF5_F90_TEST_LIBSH_TARGET} PROPERTIES
       FOLDER libraries/test/fortran
       LINKER_LANGUAGE Fortran
       Fortran_MODULE_DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}/shared
   )
   H5_SET_LIB_OPTIONS (${HDF5_F90_TEST_LIBSH_TARGET} ${HDF5_F90_TEST_LIB_NAME} SHARED "F")
-  add_dependencies(${HDF5_F90_TEST_LIBSH_TARGET} H5testgenSH)
+  add_dependencies (${HDF5_F90_TEST_LIBSH_TARGET} H5testgenSH)
 endif ()
 
 #-----------------------------------------------------------------------------
@@ -214,16 +257,16 @@ add_executable (testhdf5_fortran
     tH5Z.F90
     tHDF5.F90
 )
-target_compile_options(testhdf5_fortran
+target_compile_options (testhdf5_fortran
     PRIVATE
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET testhdf5_fortran APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET testhdf5_fortran APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET testhdf5_fortran APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET testhdf5_fortran APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET testhdf5_fortran  PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET testhdf5_fortran  PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (testhdf5_fortran PRIVATE "${CMAKE_Fortran_MODULE_DIRECTORY}/static;${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static")
   target_link_libraries (testhdf5_fortran PRIVATE ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_F90_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")
@@ -253,16 +296,16 @@ add_executable (testhdf5_fortran_1_8
     tH5MISC_1_8.F90
     tHDF5_1_8.F90
 )
-target_compile_options(testhdf5_fortran_1_8
+target_compile_options (testhdf5_fortran_1_8
     PRIVATE
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET testhdf5_fortran_1_8 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET testhdf5_fortran_1_8 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET testhdf5_fortran_1_8 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET testhdf5_fortran_1_8 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET testhdf5_fortran_1_8 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET testhdf5_fortran_1_8 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (testhdf5_fortran_1_8 PRIVATE "${CMAKE_Fortran_MODULE_DIRECTORY}/static;${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static")
   target_link_libraries (testhdf5_fortran_1_8 PRIVATE ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_F90_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")
@@ -293,16 +336,16 @@ add_executable (fortranlib_test_F03
     tH5T_F03.F90
     tHDF5_F03.F90
 )
-target_compile_options(fortranlib_test_F03
+target_compile_options (fortranlib_test_F03
     PRIVATE
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET fortranlib_test_F03 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET fortranlib_test_F03 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET fortranlib_test_F03 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET fortranlib_test_F03 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET fortranlib_test_F03 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET fortranlib_test_F03 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (fortranlib_test_F03 PRIVATE "${CMAKE_Fortran_MODULE_DIRECTORY}/static;${HDF5_F90_BINARY_DIR};${HDF5_F90_BINARY_DIR}/static")
   target_link_libraries (fortranlib_test_F03 PRIVATE ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_F90_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")
@@ -325,16 +368,16 @@ endif ()
 
 #-- Adding test for fflush1
 add_executable (fflush1 fflush1.F90)
-target_compile_options(fflush1
+target_compile_options (fflush1
     PRIVATE
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET fflush1 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET fflush1 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET fflush1 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET fflush1 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET fflush1 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET fflush1 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (fflush1 PRIVATE ${CMAKE_Fortran_MODULE_DIRECTORY}/static)
   target_link_libraries (fflush1 PRIVATE ${HDF5_F90_LIB_TARGET} ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")
@@ -362,11 +405,11 @@ target_compile_options (fflush2
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET fflush2 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET fflush2 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET fflush2 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET fflush2 APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET fflush2 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET fflush2 PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (fflush2 PRIVATE ${CMAKE_Fortran_MODULE_DIRECTORY}/static)
   target_link_libraries (fflush2 PRIVATE ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_F90_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")
@@ -389,16 +432,16 @@ endif ()
 
 #-- Adding test for vol_connector
 add_executable (vol_connector vol_connector.F90)
-target_compile_options(vol_connector
+target_compile_options (vol_connector
     PRIVATE
         "${HDF5_CMAKE_Fortran_FLAGS}"
         "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_COMPILE_FLAGS}>"
 )
-#set_property(TARGET vol_connector APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
+#set_property (TARGET vol_connector APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:/SUBSYSTEM:CONSOLE>")
-#set_property(TARGET vol_connector APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
+#set_property (TARGET vol_connector APPEND PROPERTY LINK_FLAGS "$<$<STREQUAL:x${CMAKE_Fortran_SIMULATE_ID},xMSVC>:${WIN_LINK_FLAGS}>")
-if(MSVC)
+if (MSVC)
-  set_property(TARGET vol_connector PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
+  set_property (TARGET vol_connector PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE ${WIN_LINK_FLAGS}")
-endif()
+endif ()
 if (NOT BUILD_SHARED_LIBS)
   target_include_directories (vol_connector PRIVATE ${CMAKE_Fortran_MODULE_DIRECTORY}/static)
   target_link_libraries (vol_connector PRIVATE ${HDF5_F90_LIB_TARGET} ${HDF5_F90_TEST_LIB_TARGET} ${HDF5_LIB_TARGET} "$<$<PLATFORM_ID:Windows>:ws2_32.lib>")

fortran/test/CMakeTests.cmake

@@ -74,10 +74,9 @@ set_tests_properties (FORTRAN_testhdf5-clean-objects PROPERTIES
 )
 
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME FORTRAN_testhdf5_fortran COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testhdf5_fortran>)
+  add_test (NAME FORTRAN_testhdf5_fortran COMMAND $<TARGET_FILE:testhdf5_fortran>)
 else ()
   add_test (NAME FORTRAN_testhdf5_fortran COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:testhdf5_fortran>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -93,6 +92,7 @@ endif ()
 #set_tests_properties (FORTRAN_testhdf5_fortran PROPERTIES PASS_REGULAR_EXPRESSION "[ ]*0 error.s")
 set_tests_properties (FORTRAN_testhdf5_fortran PROPERTIES
     FIXTURES_REQUIRED clear_testhdf5_fortran
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("FORTRAN_testhdf5_fortran" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (FORTRAN_testhdf5_fortran PROPERTIES DISABLED true)
@@ -100,10 +100,9 @@ endif ()
 
 #-- Adding test for testhdf5_fortran_1_8
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME FORTRAN_testhdf5_fortran_1_8 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testhdf5_fortran_1_8>)
+  add_test (NAME FORTRAN_testhdf5_fortran_1_8 COMMAND $<TARGET_FILE:testhdf5_fortran_1_8>)
 else ()
   add_test (NAME FORTRAN_testhdf5_fortran_1_8 COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:testhdf5_fortran_1_8>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -120,6 +119,7 @@ endif ()
 set_tests_properties (FORTRAN_testhdf5_fortran_1_8 PROPERTIES
     DEPENDS FORTRAN_testhdf5_fortran
     FIXTURES_REQUIRED clear_testhdf5_fortran
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("FORTRAN_testhdf5_fortran_1_8" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (FORTRAN_testhdf5_fortran_1_8 PROPERTIES DISABLED true)
@@ -127,10 +127,9 @@ endif ()
 
 #-- Adding test for fortranlib_test_F03
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME FORTRAN_fortranlib_test_F03 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:fortranlib_test_F03>)
+  add_test (NAME FORTRAN_fortranlib_test_F03 COMMAND $<TARGET_FILE:fortranlib_test_F03>)
 else ()
   add_test (NAME FORTRAN_fortranlib_test_F03 COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:fortranlib_test_F03>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -147,6 +146,7 @@ endif ()
 set_tests_properties (FORTRAN_fortranlib_test_F03 PROPERTIES
     DEPENDS FORTRAN_testhdf5_fortran_1_8
     FIXTURES_REQUIRED clear_testhdf5_fortran
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("FORTRAN_fortranlib_test_F03" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (FORTRAN_fortranlib_test_F03 PROPERTIES DISABLED true)
@@ -154,10 +154,9 @@ endif ()
 
 #-- Adding test for vol_connector
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME FORTRAN_vol_connector COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:vol_connector>)
+  add_test (NAME FORTRAN_vol_connector COMMAND $<TARGET_FILE:vol_connector>)
 else ()
   add_test (NAME FORTRAN_vol_connector COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:vol_connector>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -172,6 +171,7 @@ else ()
 endif ()
 set_tests_properties (FORTRAN_vol_connector PROPERTIES
     FIXTURES_REQUIRED clear_testhdf5_fortran
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("FORTRAN_vol_connector" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (FORTRAN_vol_connector PROPERTIES DISABLED true)
@@ -184,10 +184,11 @@ add_test (
 )
 add_test (
     NAME FORTRAN_fflush1
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:fflush1>
+    COMMAND $<TARGET_FILE:fflush1>
 )
 set_tests_properties (FORTRAN_fflush1 PROPERTIES
     DEPENDS FORTRAN_flush1-clear-objects
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("FORTRAN_fflush1" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (FORTRAN_fflush1 PROPERTIES DISABLED true)
@@ -196,9 +197,10 @@ endif ()
 #-- Adding test for fflush2
 add_test (
     NAME FORTRAN_fflush2
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:fflush2>
+    COMMAND $<TARGET_FILE:fflush2>
 )
 set_tests_properties (FORTRAN_fflush2 PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     DEPENDS FORTRAN_fflush1
 )
 if ("FORTRAN_fflush2" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

hl/c++/test/CMakeTests.cmake

@@ -29,10 +29,9 @@ set_tests_properties (HL_CPP_ptableTest-clear-objects PROPERTIES
 )
 
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME HL_CPP_ptableTest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:hl_ptableTest>)
+  add_test (NAME HL_CPP_ptableTest COMMAND $<TARGET_FILE:hl_ptableTest>)
 else ()
   add_test (NAME HL_CPP_ptableTest COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:hl_ptableTest>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -43,7 +42,10 @@ else ()
       -P "${HDF_RESOURCES_DIR}/runTest.cmake"
   )
 endif ()
-set_tests_properties (HL_CPP_ptableTest PROPERTIES DEPENDS HL_CPP_ptableTest-clear-objects)
+set_tests_properties (HL_CPP_ptableTest PROPERTIES
+    DEPENDS HL_CPP_ptableTest-clear-objects
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
+)
 if ("HL_CPP_ptableTest" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (HL_CPP_ptableTest PROPERTIES DISABLED true)
 endif ()

hl/fortran/src/CMakeLists.txt

@@ -6,6 +6,12 @@
 cmake_minimum_required (VERSION 3.26)
 project (HDF5_HL_F90_SRC C Fortran)
 
+if (HDF5_USE_PREGEN)
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_USE_PREGEN_DIR})
+else ()
+  set (HDF5_GENERATED_SOURCE_DIR ${HDF5_HL_F90_BINARY_DIR})
+endif ()
+
 #-----------------------------------------------------------------------------
 # configure def file for shared libs on windows
 if (WIN32)
@@ -27,9 +33,9 @@ if (WIN32 AND MSVC)
     set_target_properties (H5HL_buildiface PROPERTIES COMPILE_FLAGS "/MT")
   endif ()
 endif ()
-if(MSVC)
+if (MSVC)
-  set_property(TARGET H5HL_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
+  set_property (TARGET H5HL_buildiface PROPERTY LINK_FLAGS "/SUBSYSTEM:CONSOLE")
-endif()
+endif ()
 set_target_properties (H5HL_buildiface PROPERTIES
     LINKER_LANGUAGE Fortran
     Fortran_MODULE_DIRECTORY ${CMAKE_Fortran_MODULE_DIRECTORY}
@@ -116,15 +122,53 @@ set (HDF5_HL_F90_F_BASE_SOURCES
     ${HDF5_HL_F90_SRC_SOURCE_DIR}/H5DOff.F90
 )
 
+if (NOT EXISTS "${HDF5_GENERATED_SOURCE_DIR}/H5LTff_gen.F90")
+  message (STATUS "No pre-generated H5LTff_gen.F90 H5TBff_gen.F90 file found - generating one")
+  if (CMAKE_CROSSCOMPILING)
+    add_custom_command (TARGET H5HL_buildiface POST_BUILD
+        BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/H5TBff_gen.F90
+        COMMAND    ${CMAKE_COMMAND}
+        ARGS       -E env ${CROSSCOMPILING_PATH}
+        COMMAND    $<TARGET_FILE:H5HL_buildiface>
+        WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}
+        COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 files"
+    )
+  else ()
+    add_custom_command (TARGET H5HL_buildiface POST_BUILD
+        BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/H5TBff_gen.F90
+        COMMAND    $<TARGET_FILE:H5HL_buildiface>
+        WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}
+        COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 files"
+    )
+  endif ()
+else ()
+  message (STATUS "Using existing pre-generated H5LTff_gen.F90 H5TBff_gen.F90 file")
+  add_custom_command (
+      OUTPUT     gen_SRCS.stamp5
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E touch gen_SRCS.stamp5
+      DEPENDS    H5LTff_gen.F90 H5TBff_gen.F90
+      WORKING_DIRECTORY ${HDF5_GENERATED_SOURCE_DIR}
+      COMMENT    "Touch existing H5LTff_gen.F90 H5TBff_gen.F90"
+  )
+endif ()
+
+set (hl_f90_gen_deps "")
+if (NOT HDF5_USE_PREGEN)
+  set (hl_f90_gen_deps H5HL_buildiface)
+endif ()
+
 if (BUILD_STATIC_LIBS)
   add_custom_command (TARGET H5HL_buildiface POST_BUILD
       BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5TBff_gen.F90
-      COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5HL_buildiface>
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5TBff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5TBff_gen.F90
       WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}/static
-      COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 files"
   )
   add_custom_target (H5HLgen ALL
-      DEPENDS H5HL_buildiface ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5TBff_gen.F90
+      DEPENDS ${hl_f90_gen_deps} ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/static/H5TBff_gen.F90
   )
   set_source_files_properties (
       ${HDF5_HL_F90_BINARY_DIR}/static/H5LTff_gen.F90
@@ -135,12 +179,14 @@ endif ()
 if (BUILD_SHARED_LIBS)
   add_custom_command (TARGET H5HL_buildiface POST_BUILD
       BYPRODUCTS ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5TBff_gen.F90
-      COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:H5HL_buildiface>
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90
+      COMMAND    ${CMAKE_COMMAND}
+      ARGS       -E copy_if_different ${HDF5_GENERATED_SOURCE_DIR}/H5TBff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5TBff_gen.F90
       WORKING_DIRECTORY ${HDF5_HL_F90_BINARY_DIR}/shared
-      COMMENT "Generating the H5LTff_gen.F90, H5TBff_gen.F90 shared files"
   )
   add_custom_target (H5HLgenSH ALL
-      DEPENDS H5HL_buildiface ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5TBff_gen.F90
+      DEPENDS ${hl_f90_gen_deps} ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90 ${HDF5_HL_F90_BINARY_DIR}/shared/H5TBff_gen.F90
   )
   set_source_files_properties (
       ${HDF5_HL_F90_BINARY_DIR}/shared/H5LTff_gen.F90
@@ -258,21 +304,15 @@ if (BUILD_STATIC_LIBS)
     set (mod_files ${mod_files} ${MOD_BUILD_DIR}/${mod_file})
   endforeach ()
   install (
-      FILES
+      FILES ${mod_files}
-          ${mod_files}
+      DESTINATION ${HDF5_INSTALL_MODULE_DIR}/static
-      DESTINATION
+      COMPONENT fortheaders
-          ${HDF5_INSTALL_MODULE_DIR}/static
-      COMPONENT
-          fortheaders
   )
   if (HDF5_INSTALL_MOD_FORTRAN MATCHES "STATIC")
     install (
-        FILES
+        FILES ${mod_files}
-            ${mod_files}
+        DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-        DESTINATION
+        COMPONENT fortheaders
-            ${HDF5_INSTALL_INCLUDE_DIR}
-        COMPONENT
-            fortheaders
     )
   endif ()
 endif ()
@@ -281,21 +321,15 @@ if (BUILD_SHARED_LIBS)
     set (modsh_files ${modsh_files} ${MODSH_BUILD_DIR}/${mod_file})
   endforeach ()
   install (
-      FILES
+      FILES ${modsh_files}
-          ${modsh_files}
+      DESTINATION ${HDF5_INSTALL_MODULE_DIR}/shared
-      DESTINATION
+      COMPONENT fortheaders
-          ${HDF5_INSTALL_MODULE_DIR}/shared
-      COMPONENT
-          fortheaders
   )
   if (HDF5_INSTALL_MOD_FORTRAN MATCHES "SHARED")
     install (
-        FILES
+        FILES ${modsh_files}
-            ${modsh_files}
+        DESTINATION ${HDF5_INSTALL_INCLUDE_DIR}
-        DESTINATION
+        COMPONENT fortheaders
-            ${HDF5_INSTALL_INCLUDE_DIR}
-        COMPONENT
-            fortheaders
     )
   endif ()
 endif ()
@@ -314,10 +348,8 @@ if (HDF5_EXPORTED_TARGETS)
   endif ()
 
   install (
-      TARGETS
+      TARGETS ${install_targets}
-          ${install_targets}
+      EXPORT ${HDF5_EXPORTED_TARGETS}
-      EXPORT
-          ${HDF5_EXPORTED_TARGETS}
       LIBRARY DESTINATION ${HDF5_INSTALL_LIB_DIR} COMPONENT hlfortlibraries
       ARCHIVE DESTINATION ${HDF5_INSTALL_LIB_DIR} COMPONENT hlfortlibraries
       RUNTIME DESTINATION ${HDF5_INSTALL_BIN_DIR} COMPONENT hlfortlibraries

hl/fortran/test/CMakeTests.cmake

@@ -50,10 +50,9 @@ set_tests_properties (HL_FORTRAN_test-clean-objects PROPERTIES
 
 macro (ADD_H5_FORTRAN_TEST file)
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME HL_FORTRAN_f90_${file} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:hl_f90_${file}>)
+    add_test (NAME HL_FORTRAN_f90_${file} COMMAND $<TARGET_FILE:hl_f90_${file}>)
   else ()
     add_test (NAME HL_FORTRAN_f90_${file} COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:hl_f90_${file}>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -67,6 +66,7 @@ macro (ADD_H5_FORTRAN_TEST file)
   set_tests_properties (HL_FORTRAN_f90_${file} PROPERTIES
       FIXTURES_REQUIRED clear_HL_FORTRAN_test
       WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
   )
   if ("HL_FORTRAN_f90_${file}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (HL_FORTRAN_f90_${file} PROPERTIES DISABLED true)

hl/test/CMakeTests.cmake

@@ -42,9 +42,9 @@ set (HL_REFERENCE_TEST_FILES
 #-- Copy the necessary files.
 # --------------------------------------------------------------------
 foreach (h5_file ${HL_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_HL_TEST_BINARY_DIR}/testfiles/${h5_file}" "hl_test_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_HL_TEST_BINARY_DIR}/testfiles/${h5_file}" "hl_test_files")
 endforeach ()
-add_custom_target(hl_test_files ALL COMMENT "Copying files needed by hl_test tests" DEPENDS ${hl_test_files_list})
+add_custom_target (hl_test_files ALL COMMENT "Copying files needed by hl_test tests" DEPENDS ${hl_test_files_list})
 
 # Remove any output file left over from previous test run
 set (test_hl_CLEANFILES
@@ -101,10 +101,9 @@ set_tests_properties (HL_test-clean-objects PROPERTIES
 macro (HL_ADD_TEST hl_name)
   set (current_test_name "HL_${hl_name}")
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME HL_${hl_name} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:hl_${hl_name}>)
+    add_test (NAME HL_${hl_name} COMMAND $<TARGET_FILE:hl_${hl_name}>)
   else ()
     add_test (NAME HL_${hl_name} COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:hl_${hl_name}>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -118,7 +117,6 @@ macro (HL_ADD_TEST hl_name)
       add_test (
           NAME H5DUMP-HL_${hl_name}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=--enable-error-stack;${hl_name}.h5"
               -D "TEST_FOLDER=${HDF5_HL_TEST_BINARY_DIR}"
@@ -135,7 +133,7 @@ macro (HL_ADD_TEST hl_name)
   endif ()
   set_tests_properties (${current_test_name} PROPERTIES
       FIXTURES_REQUIRED clear_test_hl
-      ENVIRONMENT "srcdir=${HDF5_HL_TEST_BINARY_DIR}"
+      ENVIRONMENT "srcdir=${HDF5_HL_TEST_BINARY_DIR};${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_HL_TEST_BINARY_DIR}
   )
   if ("HL_${hl_name}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

hl/tools/h5watch/CMakeTests.cmake

@@ -58,9 +58,9 @@ set (H5WATCH_TEST_FILES
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 
 foreach (h5watch_file ${H5WATCH_TEST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5watch_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5watch_file}" "H5WATCH_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5watch_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5watch_file}" "H5WATCH_files")
 endforeach ()
-add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tests" DEPENDS ${H5WATCH_files_list})
+add_custom_target (H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tests" DEPENDS ${H5WATCH_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -73,7 +73,6 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       add_test (
           NAME H5WATCH_ARGS-h5watch-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5watch>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -85,6 +84,7 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       set_tests_properties (H5WATCH_ARGS-h5watch-${resultfile} PROPERTIES
           DEPENDS ${last_test}
           FIXTURES_REQUIRED gen_test_watch
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
       if ("H5WATCH_ARGS-h5watch-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (H5WATCH_ARGS-h5watch-${resultfile} PROPERTIES DISABLED true)
@@ -98,7 +98,6 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       add_test (
           NAME H5WATCH_ARGS-h5watch-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5watch>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -112,6 +111,7 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       set_tests_properties (H5WATCH_ARGS-h5watch-${resultfile} PROPERTIES
           DEPENDS ${last_test}
           FIXTURES_REQUIRED gen_test_watch
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
       if ("H5WATCH_ARGS-h5watch-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (H5WATCH_ARGS-h5watch-${resultfile} PROPERTIES DISABLED true)
@@ -125,7 +125,6 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       add_test (
           NAME H5WATCH-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5watch>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -137,6 +136,7 @@ add_custom_target(H5WATCH_files ALL COMMENT "Copying files needed by H5WATCH tes
       set_tests_properties (H5WATCH-${resultfile} PROPERTIES
           DEPENDS ${last_test}
           FIXTURES_REQUIRED gen_test_watch
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
       if ("H5WATCH-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (H5WATCH-${resultfile} PROPERTIES DISABLED true)
@@ -157,12 +157,15 @@ add_test (
     NAME H5WATCH-SWMR_INCOMPAT
     COMMAND swmr_check_compat_vfd
 )
-set_tests_properties (H5WATCH-SWMR_INCOMPAT PROPERTIES FIXTURES_SETUP swmr_vfd_check_compat)
+set_tests_properties (H5WATCH-SWMR_INCOMPAT PROPERTIES
+    FIXTURES_SETUP swmr_vfd_check_compat
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
+)
 
 # Remove any output file left over from previous test run
 add_test (
-  NAME H5WATCH-clearall-objects
+    NAME H5WATCH-clearall-objects
-  COMMAND ${CMAKE_COMMAND} -E remove WATCH.h5
+   COMMAND ${CMAKE_COMMAND} -E remove WATCH.h5
 )
 set_tests_properties (H5WATCH-clearall-objects PROPERTIES FIXTURES_REQUIRED swmr_vfd_check_compat)
 if (last_test)
@@ -170,8 +173,8 @@ if (last_test)
 endif ()
 set (last_test "H5WATCH-cleanall-objects")
 add_test (
-  NAME H5WATCH-cleanall-objects
+    NAME H5WATCH-cleanall-objects
-  COMMAND ${CMAKE_COMMAND} -E remove WATCH.h5
+    COMMAND ${CMAKE_COMMAND} -E remove WATCH.h5
 )
 set_tests_properties (H5WATCH-cleanall-objects PROPERTIES FIXTURES_CLEANUP swmr_vfd_check_compat)
 
@@ -195,10 +198,11 @@ set_tests_properties (H5WATCH-cleanall-objects PROPERTIES FIXTURES_CLEANUP swmr_
 #                                               #
 #################################################################################################
 # create the output files to be used.
-add_test (NAME H5WATCH-h5watchgentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5watchgentest>)
+add_test (NAME H5WATCH-h5watchgentest COMMAND $<TARGET_FILE:h5watchgentest>)
 set_tests_properties (H5WATCH-h5watchgentest PROPERTIES
     WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
     DEPENDS H5WATCH-clearall-objects
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 set_tests_properties (H5WATCH-h5watchgentest PROPERTIES FIXTURES_SETUP gen_test_watch)
 set_tests_properties (H5WATCH-h5watchgentest PROPERTIES FIXTURES_REQUIRED swmr_vfd_check_compat)

java/test/CMakeLists.txt

@@ -103,22 +103,22 @@ foreach (test_file ${HDF5_JAVA_TEST_SOURCES})
 endforeach ()
 
 foreach (h5_file ${HDF5_JAVA_TEST_SOURCES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/JUnit-${h5_file}.txt" "${PROJECT_BINARY_DIR}/JUnit-${h5_file}.txt" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/JUnit-${h5_file}.txt" "${PROJECT_BINARY_DIR}/JUnit-${h5_file}.txt" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
 endforeach ()
 
-HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterate.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterate.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateL1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateL1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateL2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateL2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateO1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateO1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateO2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/h5ex_g_iterateO2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_reg.h5" "${PROJECT_BINARY_DIR}/trefer_reg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_reg.h5" "${PROJECT_BINARY_DIR}/trefer_reg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_attr.h5" "${PROJECT_BINARY_DIR}/trefer_attr.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_attr.h5" "${PROJECT_BINARY_DIR}/trefer_attr.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tdatareg.h5" "${PROJECT_BINARY_DIR}/tdatareg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tdatareg.h5" "${PROJECT_BINARY_DIR}/tdatareg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tattrreg.h5" "${PROJECT_BINARY_DIR}/tattrreg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tattrreg.h5" "${PROJECT_BINARY_DIR}/tattrreg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tintsattrs.h5" "${PROJECT_BINARY_DIR}/tintsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tintsattrs.h5" "${PROJECT_BINARY_DIR}/tintsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tfloatsattrs.h5" "${PROJECT_BINARY_DIR}/tfloatsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tfloatsattrs.h5" "${PROJECT_BINARY_DIR}/tfloatsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_files")
 
-add_custom_target(${HDF5_JAVA_TEST_LIB_TARGET}_files ALL COMMENT "Copying files needed by ${HDF5_JAVA_TEST_LIB_TARGET} tests" DEPENDS ${${HDF5_JAVA_TEST_LIB_TARGET}_files_list})
+add_custom_target (${HDF5_JAVA_TEST_LIB_TARGET}_files ALL COMMENT "Copying files needed by ${HDF5_JAVA_TEST_LIB_TARGET} tests" DEPENDS ${${HDF5_JAVA_TEST_LIB_TARGET}_files_list})
 
 if (WIN32)
   set (CMAKE_JAVA_INCLUDE_FLAG_SEP ";")
@@ -251,22 +251,22 @@ if (HDF5_TEST_JAVA AND HDF5_TEST_SERIAL)
     foreach (voltest ${VOL_LIST})
       file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${voltest}")
         foreach (h5_file ${HDF5_JAVA_TEST_SOURCES})
-          HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/JUnit-${h5_file}.txt" "${PROJECT_BINARY_DIR}/${voltest}/JUnit-${h5_file}.txt" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+          HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/JUnit-${h5_file}.txt" "${PROJECT_BINARY_DIR}/${voltest}/JUnit-${h5_file}.txt" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
         endforeach ()
 
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterate.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterate.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateL1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateL1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateL2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateL2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateO1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateO1.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateO2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/h5ex_g_iterate.orig" "${PROJECT_BINARY_DIR}/${voltest}/h5ex_g_iterateO2.hdf" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_reg.h5" "${PROJECT_BINARY_DIR}/${voltest}/trefer_reg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_reg.h5" "${PROJECT_BINARY_DIR}/${voltest}/trefer_reg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_attr.h5" "${PROJECT_BINARY_DIR}/${voltest}/trefer_attr.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/trefer_attr.h5" "${PROJECT_BINARY_DIR}/${voltest}/trefer_attr.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tdatareg.h5" "${PROJECT_BINARY_DIR}/${voltest}/tdatareg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tdatareg.h5" "${PROJECT_BINARY_DIR}/${voltest}/tdatareg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tattrreg.h5" "${PROJECT_BINARY_DIR}/${voltest}/tattrreg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tattrreg.h5" "${PROJECT_BINARY_DIR}/${voltest}/tattrreg.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tintsattrs.h5" "${PROJECT_BINARY_DIR}/${voltest}/tintsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tintsattrs.h5" "${PROJECT_BINARY_DIR}/${voltest}/tintsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
-        HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tfloatsattrs.h5" "${PROJECT_BINARY_DIR}/${voltest}/tfloatsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
+        HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tfloatsattrs.h5" "${PROJECT_BINARY_DIR}/${voltest}/tfloatsattrs.h5" "${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files")
 
-        add_custom_target(${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files ALL COMMENT "Copying files needed by ${HDF5_JAVA_TEST_LIB_TARGET} tests" DEPENDS ${${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files_list})
+        add_custom_target (${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files ALL COMMENT "Copying files needed by ${HDF5_JAVA_TEST_LIB_TARGET} tests" DEPENDS ${${HDF5_JAVA_TEST_LIB_TARGET}_${voltest}_files_list})
 
         foreach (volinfo IN LISTS ${voltest})
           foreach (h5_file ${HDF5_JAVA_TEST_SOURCES})

release_docs/CHANGELOG.md

@@ -63,6 +63,14 @@ For releases prior to version 2.0.0, please see the release.txt file and for mor
 
 ## Configuration
 
+### Improved the cross-compile support in the build system
+
+   The CMake build system has been improved to better support cross-compiling. This includes the following changes:
+   - The CMake option, `CMAKE_CROSS_COMPILING`, indicates that the library is being cross-compiled. This option, usually in a toolchain file, can be set to ON when cross-compiling.
+   - Removed the `CMAKE_CROSSCOMPILING_EMULATOR` when cross-compiling, CMake will automatically insert it in the command.
+   - Added an option `HDF5_USE_PREGEN` to supply pre-generated files located in `HDF5_USE_PREGEN_DIR` directory, to bypass running feature detection programs when cross-compiling.
+   - Added a variable `CROSSCOMPILING_PATH` to specify a path to search for programs when cross-compiling. This is useful when the build system needs to run programs that were built for the host system.
+
 ### Refactored `HDF5_BUILD/ENABLE_{feature}` variable in hdf5-config.cmake file
 
    The variables used in hdf5-config.cmake to indicate what options were used to build the installed library have been renamed. All `HDF5_BUILD/ENABLE_{feature}` variables are now `HDF5_PROVIDES_{feature}`. This more clearly indicates that these variables reflect whether the feature is supported by the installed library, instead of whether the feature is an option that can be changed when building an application with the library.
@@ -133,7 +141,7 @@ For releases prior to version 2.0.0, please see the release.txt file and for mor
 
 Changed the zlib-ng CMake logic to prefer the native zlib-ng library. Added `#ifdef` around the compression function calls. Added including the correct header file with the same `#ifdef`.
 
-### Renamed HDF5Examples build options from `H5EX_<option>` to `H5EXAMPLE_<option>`
+### Renamed HDF5Examples build options from `H5EXAMPLE_<option>` to `H5EXAMPLE_<option>`
 
 Changed the prefix to better distinguish the examples build options from the library options when building the examples along with the library.
 

test/CMakePassthroughVOLTests.cmake

@@ -37,30 +37,30 @@ endforeach ()
 
 foreach (voltest ${VOL_LIST})
   foreach (h5_tfile ${HDF5_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${h5_tfile}" "HDF5_VOLTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${h5_tfile}" "HDF5_VOLTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (voltest ${VOL_LIST})
   foreach (ref_file ${HDF5_REFERENCE_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${ref_file}" "HDF5_VOLTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${ref_file}" "HDF5_VOLTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (voltest ${VOL_LIST})
   foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${h5_file}" "HDF5_VOLTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/${h5_file}" "HDF5_VOLTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (voltest ${VOL_LIST})
   foreach (plistfile ${HDF5_REFERENCE_PLIST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/plist_files/${plistfile}" "HDF5_VOLTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/plist_files/${plistfile}" "HDF5_VOLTEST_LIB_files")
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/plist_files/def_${plistfile}" "HDF5_VOLTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/${voltest}/testfiles/plist_files/def_${plistfile}" "HDF5_VOLTEST_LIB_files")
   endforeach ()
 endforeach ()
 
-add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HDF5_VOLTEST_LIB tests" DEPENDS ${HDF5_VOLTEST_LIB_files_list})
+add_custom_target (HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HDF5_VOLTEST_LIB tests" DEPENDS ${HDF5_VOLTEST_LIB_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -94,7 +94,6 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
         if (NOT BUILD_SHARED_LIBS AND NOT ${HDF_CFG_NAME} MATCHES "Debug")
           add_test (NAME VOL-${volname}-${voltest}
               COMMAND "${CMAKE_COMMAND}"
-                  -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                   -D "TEST_PROGRAM=$<TARGET_FILE:${voltest}>"
                   -D "TEST_ARGS:STRING="
                   -D "TEST_VOL:STRING=${volinfo}"
@@ -104,7 +103,7 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
                   -P "${HDF_RESOURCES_DIR}/volTest.cmake"
           )
           set_tests_properties (VOL-${volname}-${voltest} PROPERTIES
-              ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname}"
+              ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname};${CROSSCOMPILING_PATH}"
               WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${volname}
           )
           if ("VOL-${volname}-${voltest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -119,7 +118,6 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
       else ()
         add_test (NAME VOL-${volname}-${voltest}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:${voltest}>"
                 -D "TEST_ARGS:STRING="
                 -D "TEST_VOL:STRING=${volinfo}"
@@ -129,7 +127,7 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
                 -P "${HDF_RESOURCES_DIR}/volTest.cmake"
         )
         set_tests_properties (VOL-${volname}-${voltest} PROPERTIES
-            ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname}"
+            ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname};${CROSSCOMPILING_PATH}"
             WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${volname}
         )
         if ("VOL-${volname}-${voltest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -139,7 +137,6 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
     else ()
       add_test (NAME VOL-${volname}-${voltest}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${voltest}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VOL:STRING=${volinfo}"
@@ -149,7 +146,7 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
               -P "${HDF_RESOURCES_DIR}/volTest.cmake"
       )
       set_tests_properties (VOL-${volname}-${voltest} PROPERTIES
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname}"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname};${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${volname}
       )
       if ("VOL-${volname}-${voltest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -162,13 +159,12 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
       #message(STATUS "${voltest}-${volname} with ${volinfo}")
       add_test (NAME VOL-${volname}-${voltest}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${voltest}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VOL:STRING=${volinfo}"
               -D "TEST_EXPECT=${resultcode}"
               -D "TEST_OUTPUT=${volname}-${voltest}.out"
-              -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${volname}"
+              -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${volname};${CROSSCOMPILING_PATH}"
               -P "${HDF_RESOURCES_DIR}/volTest.cmake"
       )
       set_tests_properties (VOL-${volname}-${voltest} PROPERTIES
@@ -210,7 +206,6 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
     if (HDF5_TEST_FHEAP_PASSTHROUGH_VOL)
       add_test (NAME VOL-${volname}-fheap
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:fheap>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VOL:STRING=${volinfo}"
@@ -221,7 +216,7 @@ add_custom_target(HDF5_VOLTEST_LIB_files ALL COMMENT "Copying files needed by HD
       )
       set_tests_properties (VOL-${volname}-fheap PROPERTIES
           TIMEOUT ${CTEST_VERY_LONG_TIMEOUT}
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname}"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${volname};${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${volname}
       )
       if ("VOL-${volname}-fheap" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

test/CMakeTests.cmake

@@ -36,7 +36,7 @@ add_custom_command (
 )
 
 foreach (h5_tfile ${HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/${h5_tfile}" "HDF5_TEST_LIB_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/${h5_tfile}" "HDF5_TEST_LIB_files")
 endforeach ()
 
 set (HDF5_REFERENCE_FILES
@@ -48,7 +48,7 @@ set (HDF5_REFERENCE_FILES
 )
 
 foreach (ref_file ${HDF5_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/${ref_file}" "HDF5_TEST_LIB_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/${ref_file}" "HDF5_TEST_LIB_files")
 endforeach ()
 
 # --------------------------------------------------------------------
@@ -106,8 +106,8 @@ set (HDF5_REFERENCE_PLIST_FILES
 )
 
 foreach (plistfile ${HDF5_REFERENCE_PLIST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files/${plistfile}" "HDF5_TEST_LIB_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files/${plistfile}" "HDF5_TEST_LIB_files")
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files/def_${plistfile}" "HDF5_TEST_LIB_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/H5TEST/testfiles/plist_files/def_${plistfile}" "HDF5_TEST_LIB_files")
 endforeach ()
 
 # --------------------------------------------------------------------
@@ -171,10 +171,10 @@ set (HDF5_REFERENCE_TEST_FILES
 )
 
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/H5TEST/testfiles/${h5_file}" "HDF5_TEST_LIB_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/H5TEST/testfiles/${h5_file}" "HDF5_TEST_LIB_files")
 endforeach ()
 
-add_custom_target(HDF5_TEST_LIB_files ALL COMMENT "Copying files needed by HDF5_TEST_LIB tests" DEPENDS ${HDF5_TEST_LIB_files_list})
+add_custom_target (HDF5_TEST_LIB_files ALL COMMENT "Copying files needed by HDF5_TEST_LIB tests" DEPENDS ${HDF5_TEST_LIB_files_list})
 
 set (HDF5_S3PROXY_TEST_FILES
     t8.shakespeare.txt
@@ -183,10 +183,10 @@ set (HDF5_S3PROXY_TEST_FILES
 )
 
 foreach (h5_file ${HDF5_S3PROXY_TEST_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/H5TEST/testfiles/${h5_file}" "HDF5_S3PROXY_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/H5TEST/testfiles/${h5_file}" "HDF5_S3PROXY_files")
 endforeach ()
 
-add_custom_target(HDF5_S3PROXY_files ALL COMMENT "Copying files needed by HDF5_S3PROXY tests" DEPENDS ${HDF5_S3PROXY_files_list})
+add_custom_target (HDF5_S3PROXY_files ALL COMMENT "Copying files needed by HDF5_S3PROXY tests" DEPENDS ${HDF5_S3PROXY_files_list})
 
 set (testhdf5_CLEANFILES
     coord.h5
@@ -223,28 +223,28 @@ add_test (
 )
 set_tests_properties (H5TEST-testhdf5-clean-objects PROPERTIES FIXTURES_CLEANUP clear_testhdf5)
 
-add_test (NAME H5TEST-testhdf5-base COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testhdf5> -x file -x select)
+add_test (NAME H5TEST-testhdf5-base COMMAND $<TARGET_FILE:testhdf5> -x file -x select)
 set_tests_properties (H5TEST-testhdf5-base PROPERTIES
     FIXTURES_REQUIRED clear_testhdf5
-    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-testhdf5-base" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-testhdf5-base PROPERTIES DISABLED true)
 endif ()
-add_test (NAME H5TEST-testhdf5-file COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testhdf5> -o file)
+add_test (NAME H5TEST-testhdf5-file COMMAND $<TARGET_FILE:testhdf5> -o file)
 set_tests_properties (H5TEST-testhdf5-file PROPERTIES
     FIXTURES_REQUIRED clear_testhdf5
-    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-testhdf5-file" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-testhdf5-file PROPERTIES DISABLED true)
 endif ()
-add_test (NAME H5TEST-testhdf5-select COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testhdf5> -o select)
+add_test (NAME H5TEST-testhdf5-select COMMAND $<TARGET_FILE:testhdf5> -o select)
 set_tests_properties (H5TEST-testhdf5-select PROPERTIES
     FIXTURES_REQUIRED clear_testhdf5
-    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "HDF5_ALARM_SECONDS=3600;srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-testhdf5-select" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -359,15 +359,14 @@ set (H5TEST_SEPARATE_TESTS
 foreach (h5_test ${H5_EXPRESS_TESTS})
   if (NOT h5_test IN_LIST H5TEST_SEPARATE_TESTS)
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME H5TESTXPR-${h5_test} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${h5_test}>)
+      add_test (NAME H5TESTXPR-${h5_test} COMMAND $<TARGET_FILE:${h5_test}>)
       set_tests_properties (H5TESTXPR-${h5_test} PROPERTIES
           FIXTURES_REQUIRED clear_H5TEST
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
       )
     else ()
       add_test (NAME H5TESTXPR-${h5_test} COMMAND "${CMAKE_COMMAND}"
-          -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
           -D "TEST_PROGRAM=$<TARGET_FILE:${h5_test}>"
           -D "TEST_ARGS:STRING="
           -D "TEST_EXPECT=0"
@@ -380,7 +379,7 @@ foreach (h5_test ${H5_EXPRESS_TESTS})
       )
       set_tests_properties (H5TESTXPR-${h5_test} PROPERTIES
           FIXTURES_REQUIRED clear_H5TEST
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
       )
     endif ()
@@ -392,10 +391,10 @@ endforeach ()
 foreach (h5_test ${H5_TESTS})
   if (NOT h5_test IN_LIST H5TEST_SEPARATE_TESTS)
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME H5TEST-${h5_test} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${h5_test}>)
+      add_test (NAME H5TEST-${h5_test} COMMAND $<TARGET_FILE:${h5_test}>)
       set_tests_properties (H5TEST-${h5_test} PROPERTIES
           FIXTURES_REQUIRED clear_H5TEST
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
       )
     else ()
@@ -405,7 +404,6 @@ foreach (h5_test ${H5_TESTS})
         )
       else ()
         add_test (NAME H5TEST-${h5_test} COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:${h5_test}>"
             -D "TEST_ARGS:STRING="
             -D "TEST_EXPECT=0"
@@ -419,7 +417,7 @@ foreach (h5_test ${H5_TESTS})
       endif ()
       set_tests_properties (H5TEST-${h5_test} PROPERTIES
           FIXTURES_REQUIRED clear_H5TEST
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
       )
     endif ()
@@ -451,10 +449,9 @@ if (NOT CYGWIN)
   )
   set_tests_properties (H5TEST-cache-clean-objects PROPERTIES FIXTURES_CLEANUP clear_cache)
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5TEST-cache COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:cache>)
+    add_test (NAME H5TEST-cache COMMAND $<TARGET_FILE:cache>)
   else ()
     add_test (NAME H5TEST-cache COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:cache>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -467,7 +464,7 @@ if (NOT CYGWIN)
   endif ()
   set_tests_properties (H5TEST-cache PROPERTIES
       FIXTURES_REQUIRED clear_cache
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
   set_tests_properties (H5TEST-cache PROPERTIES TIMEOUT ${CTEST_VERY_LONG_TIMEOUT})
@@ -490,10 +487,10 @@ if (TEST_CACHE_IMAGE)
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
   set_tests_properties (H5TEST-cache_image-clean-objects PROPERTIES FIXTURES_CLEANUP clear_cache_image)
-  add_test (NAME H5TEST-cache_image COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:cache_image>)
+  add_test (NAME H5TEST-cache_image COMMAND $<TARGET_FILE:cache_image>)
   set_tests_properties (H5TEST-cache_image PROPERTIES
       FIXTURES_REQUIRED clear_cache_image
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
   if ("H5TEST-cache_image" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -525,10 +522,9 @@ add_test (
 )
 set_tests_properties (H5TEST-external_env-clean-objects PROPERTIES FIXTURES_CLEANUP clear_external_env)
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME H5TEST-external_env COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:external_env>)
+  add_test (NAME H5TEST-external_env COMMAND $<TARGET_FILE:external_env>)
 else ()
   add_test (NAME H5TEST-external_env COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:external_env>"
         -D "TEST_ARGS:STRING="
         -D "TEST_ENV_VAR:STRING=HDF5_EXTFILE_PREFIX"
@@ -543,7 +539,7 @@ else ()
 endif ()
 set_tests_properties (H5TEST-external_env PROPERTIES
     FIXTURES_REQUIRED clear_external_env
-    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-external_env" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -560,10 +556,9 @@ add_test (
 )
 set_tests_properties (H5TEST-vds_env-clean-objects PROPERTIES FIXTURES_CLEANUP clear_vds_env)
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME H5TEST-vds_env COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:vds_env>)
+  add_test (NAME H5TEST-vds_env COMMAND $<TARGET_FILE:vds_env>)
 else ()
   add_test (NAME H5TEST-vds_env COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:vds_env>"
         -D "TEST_ARGS:STRING="
         -D "TEST_ENV_VAR:STRING=HDF5_VDS_PREFIX"
@@ -578,7 +573,7 @@ else ()
 endif ()
 set_tests_properties (H5TEST-vds_env PROPERTIES
     FIXTURES_REQUIRED clear_vds_env
-    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-vds_env" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -607,10 +602,9 @@ add_test (NAME H5TEST-flush-clean-objects
 )
 set_tests_properties (H5TEST-flush-clean-objects PROPERTIES FIXTURES_CLEANUP clear_flush)
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME H5TEST-flush1 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:flush1>)
+  add_test (NAME H5TEST-flush1 COMMAND $<TARGET_FILE:flush1>)
 else ()
   add_test (NAME H5TEST-flush1 COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:flush1>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -622,17 +616,16 @@ else ()
 endif ()
 set_tests_properties (H5TEST-flush1 PROPERTIES
     FIXTURES_REQUIRED clear_flush
-    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-flush1" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-flush1 PROPERTIES DISABLED true)
 endif ()
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME H5TEST-flush2 COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:flush2>)
+  add_test (NAME H5TEST-flush2 COMMAND $<TARGET_FILE:flush2>)
 else ()
   add_test (NAME H5TEST-flush2 COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:flush2>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -645,32 +638,36 @@ endif ()
 set_tests_properties (H5TEST-flush2 PROPERTIES
     FIXTURES_REQUIRED clear_flush
     DEPENDS H5TEST-flush1
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
 if ("H5TEST-flush2" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-flush2 PROPERTIES DISABLED true)
 endif ()
 
 #-- Adding test for tcheck_version
-add_test (NAME H5TEST-tcheck_version-major COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:tcheck_version> "-tM")
+add_test (NAME H5TEST-tcheck_version-major COMMAND $<TARGET_FILE:tcheck_version> "-tM")
 set_tests_properties (H5TEST-tcheck_version-major PROPERTIES
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     WILL_FAIL "true"
 )
 if ("H5TEST-tcheck_version-major" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-tcheck_version-major PROPERTIES DISABLED true)
 endif ()
-add_test (NAME H5TEST-tcheck_version-minor COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:tcheck_version> "-tm")
+add_test (NAME H5TEST-tcheck_version-minor COMMAND $<TARGET_FILE:tcheck_version> "-tm")
 set_tests_properties (H5TEST-tcheck_version-minor PROPERTIES
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     WILL_FAIL "true"
 )
 if ("H5TEST-tcheck_version-minor" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
   set_tests_properties (H5TEST-tcheck_version-minor PROPERTIES DISABLED true)
 endif ()
 # release + 1 should pass on non-develop branches
-add_test (NAME H5TEST-tcheck_version-release COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:tcheck_version> "-tr")
+add_test (NAME H5TEST-tcheck_version-release COMMAND $<TARGET_FILE:tcheck_version> "-tr")
 set_tests_properties (H5TEST-tcheck_version-release PROPERTIES
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     WILL_FAIL "true"
 )
 if ("H5TEST-tcheck_version-release" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -697,11 +694,11 @@ if (HDF5_ENABLE_ROS3_VFD_DOCKER_PROXY)
   # AWS_PROFILE is set in order to use the correct testing
   # credentials created in CMakeTests.cmake
   set (h5test_s3tests_env
-    "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+      "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
-    "HDF5_ROS3_TEST_BUCKET_URL=http://localhost:${h5test_s3tests_port}/hdf5ros3"
+      "HDF5_ROS3_TEST_BUCKET_URL=http://localhost:${h5test_s3tests_port}/hdf5ros3"
-    "AWS_ENDPOINT_URL=http://localhost:${h5test_s3tests_port}"
+      "AWS_ENDPOINT_URL=http://localhost:${h5test_s3tests_port}"
-    "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
+      "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
-    "AWS_PROFILE=ros3_vfd_test"
+      "AWS_PROFILE=ros3_vfd_test"
   )
 
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/H5TEST/buckets")
@@ -735,10 +732,9 @@ if (HDF5_ENABLE_ROS3_VFD_DOCKER_PROXY)
 
   foreach (h5_test ${H5_S3TESTS})
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME H5TEST_S3TESTS-${h5_test} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:${h5_test}>)
+      add_test (NAME H5TEST_S3TESTS-${h5_test} COMMAND $<TARGET_FILE:${h5_test}>)
     else ()
       add_test (NAME H5TEST_S3TESTS-${h5_test} COMMAND "${CMAKE_COMMAND}"
-          -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
           -D "TEST_PROGRAM=$<TARGET_FILE:${h5_test}>"
           -D "TEST_ARGS:STRING="
           -D "TEST_EXPECT=0"
@@ -753,7 +749,7 @@ if (HDF5_ENABLE_ROS3_VFD_DOCKER_PROXY)
     endif ()
     set_tests_properties (H5TEST_S3TESTS-${h5_test} PROPERTIES
         FIXTURES_REQUIRED s3_proxy
-        ENVIRONMENT "${h5test_s3tests_env}"
+        ENVIRONMENT "${h5test_s3tests_env};${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
     )
     if ("H5TEST_S3TESTS-${h5_test}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -807,7 +803,7 @@ add_test (
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 set_tests_properties (H5TEST-filenotclosed-clean-objects PROPERTIES FIXTURES_CLEANUP clear_filenotclosed)
-add_test (NAME H5TEST-filenotclosed COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:filenotclosed>)
+add_test (NAME H5TEST-filenotclosed COMMAND $<TARGET_FILE:filenotclosed>)
 set_tests_properties (H5TEST-filenotclosed PROPERTIES
     FIXTURES_REQUIRED clear_filenotclosed
     ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
@@ -830,10 +826,10 @@ add_test (
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 set_tests_properties (H5TEST-del_many_dense_attrs-clean-objects PROPERTIES FIXTURES_CLEANUP clear_del_many_dense_attrs)
-add_test (NAME H5TEST-del_many_dense_attrs COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:del_many_dense_attrs>)
+add_test (NAME H5TEST-del_many_dense_attrs COMMAND $<TARGET_FILE:del_many_dense_attrs>)
 set_tests_properties (H5TEST-del_many_dense_attrs PROPERTIES
     FIXTURES_REQUIRED clear_del_many_dense_attrs
-    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-del_many_dense_attrs" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -843,7 +839,6 @@ endif ()
 #-- Adding test for err_compat
 if (HDF5_ENABLE_DEPRECATED_SYMBOLS AND NOT MINGW)
   add_test (NAME H5TEST-err_compat COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:err_compat>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -855,12 +850,11 @@ if (HDF5_ENABLE_DEPRECATED_SYMBOLS AND NOT MINGW)
       -P "${HDF_RESOURCES_DIR}/runTest.cmake"
   )
   set_tests_properties (H5TEST-err_compat PROPERTIES
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
 else ()
   add_test (NAME H5TEST-err_compat COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:err_compat>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -872,7 +866,7 @@ else ()
       -P "${HDF_RESOURCES_DIR}/runTest.cmake"
   )
   set_tests_properties (H5TEST-err_compat PROPERTIES
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
 endif ()
@@ -883,7 +877,6 @@ endif ()
 #-- Adding test for error_test
 if (HDF5_DEFAULT_API_VERSION MATCHES "v16" OR MINGW)
   add_test (NAME H5TEST-error_test COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:error_test>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -895,12 +888,11 @@ if (HDF5_DEFAULT_API_VERSION MATCHES "v16" OR MINGW)
       -P "${HDF_RESOURCES_DIR}/runTest.cmake"
   )
   set_tests_properties (H5TEST-error_test PROPERTIES
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_PLUGIN_PRELOAD=::"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_PLUGIN_PRELOAD=::;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
 else ()
   add_test (NAME H5TEST-error_test COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:error_test>"
       -D "TEST_ARGS:STRING="
       -D "TEST_EXPECT=0"
@@ -912,7 +904,7 @@ else ()
       -P "${HDF_RESOURCES_DIR}/runTest.cmake"
   )
   set_tests_properties (H5TEST-error_test PROPERTIES
-      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_PLUGIN_PRELOAD=::"
+      ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_PLUGIN_PRELOAD=::;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
   )
   add_test (
@@ -948,10 +940,9 @@ add_test (NAME H5TEST-links_env-clean-objects
 )
 set_tests_properties (H5TEST-links_env-clean-objects PROPERTIES FIXTURES_CLEANUP clear_links_env)
 if (HDF5_ENABLE_USING_MEMCHECKER)
-  add_test (NAME H5TEST-links_env COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:links_env>)
+  add_test (NAME H5TEST-links_env COMMAND $<TARGET_FILE:links_env>)
 else ()
   add_test (NAME H5TEST-links_env COMMAND "${CMAKE_COMMAND}"
-      -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
       -D "TEST_PROGRAM=$<TARGET_FILE:links_env>"
       -D "TEST_ARGS:STRING="
       #-D "TEST_ENV_VAR:STRING=HDF5_EXT_PREFIX"
@@ -965,7 +956,7 @@ else ()
 endif ()
 set_tests_properties (H5TEST-links_env PROPERTIES
     FIXTURES_REQUIRED clear_links_env
-    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_EXT_PREFIX=.:tmp_links_env"
+    ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST;HDF5_EXT_PREFIX=.:tmp_links_env;${CROSSCOMPILING_PATH}"
     WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST
 )
 if ("H5TEST-links_env" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1001,9 +992,9 @@ if (BUILD_SHARED_LIBS)
     set (BIN_REL_PATH "../")
   endif ()
 
-  add_test (NAME H5PLUGIN-filter_plugin COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:filter_plugin>)
+  add_test (NAME H5PLUGIN-filter_plugin COMMAND $<TARGET_FILE:filter_plugin>)
   set_tests_properties (H5PLUGIN-filter_plugin PROPERTIES
-      ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/filter_plugin_dir1${CMAKE_SEP}${CMAKE_BINARY_DIR}/filter_plugin_dir2${CMAKE_SEP};HDF5_VOL_CONNECTOR=;srcdir=${HDF5_TEST_BINARY_DIR}"
+      ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/filter_plugin_dir1${CMAKE_SEP}${CMAKE_BINARY_DIR}/filter_plugin_dir2${CMAKE_SEP};HDF5_VOL_CONNECTOR=;srcdir=${HDF5_TEST_BINARY_DIR};${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}
   )
   if ("H5PLUGIN-filter_plugin" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1046,7 +1037,6 @@ if (ENABLE_EXTENDED_TESTS)
     )
     set_tests_properties (H5TEST-testflushrefresh-clean-objects PROPERTIES FIXTURES_CLEANUP clear_testflushrefresh)
     add_test (NAME H5TEST-testflushrefresh COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:flushrefresh>"
         -D "TEST_ARGS1:STRING=flushrefresh_VERIFICATION_START"
         -D "TEST_ARGS2:STRING=flushrefresh_VERIFICATION_DONE"
@@ -1061,7 +1051,7 @@ if (ENABLE_EXTENDED_TESTS)
     )
     set_tests_properties (H5TEST-testflushrefresh PROPERTIES
         FIXTURES_REQUIRED clear_testflushrefresh
-        ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST/flushrefresh_test"
+        ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/H5TEST/flushrefresh_test;${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/H5TEST/flushrefresh_test
     )
     if ("H5TEST-testflushrefresh" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1100,9 +1090,9 @@ if (BUILD_SHARED_LIBS)
     set (BIN_REL_PATH "../")
   endif ()
 
-  add_test (NAME H5PLUGIN-vol_plugin COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:vol_plugin>)
+  add_test (NAME H5PLUGIN-vol_plugin COMMAND $<TARGET_FILE:vol_plugin>)
   set_tests_properties (H5PLUGIN-vol_plugin PROPERTIES
-      ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/null_vol_plugin_dir;srcdir=${HDF5_TEST_BINARY_DIR};HDF5_VOL_CONNECTOR="
+      ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/null_vol_plugin_dir;srcdir=${HDF5_TEST_BINARY_DIR};HDF5_VOL_CONNECTOR=;${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}
   )
   if ("H5PLUGIN-vol_plugin" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

test/CMakeVFDTests.cmake

@@ -16,7 +16,7 @@
 ##############################################################################
 ##############################################################################
 # included from CMakeTests.cmake
-H5_CREATE_VFD_DIR()
+H5_CREATE_VFD_DIR ()
 
 # create more test folders for each VFD
 foreach (vfdtest ${VFD_LIST})
@@ -26,30 +26,30 @@ endforeach ()
 
 foreach (vfdtest ${VFD_LIST})
   foreach (h5_tfile ${HDF5_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/${h5_tfile}" "HDF5_VFDTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_tfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/${h5_tfile}" "HDF5_VFDTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (vfdtest ${VFD_LIST})
   foreach (ref_file ${HDF5_REFERENCE_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/${ref_file}" "HDF5_VFDTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${ref_file}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/${ref_file}" "HDF5_VFDTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (vfdtest ${VFD_LIST})
   foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/${vfdtest}/testfiles/${h5_file}" "HDF5_VFDTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/${h5_file}" "${HDF5_TEST_BINARY_DIR}/${vfdtest}/testfiles/${h5_file}" "HDF5_VFDTEST_LIB_files")
   endforeach ()
 endforeach ()
 
 foreach (vfdtest ${VFD_LIST})
   foreach (plistfile ${HDF5_REFERENCE_PLIST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/plist_files/${plistfile}" "HDF5_VFDTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/${plistfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/plist_files/${plistfile}" "HDF5_VFDTEST_LIB_files")
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/plist_files/def_${plistfile}" "HDF5_VFDTEST_LIB_files")
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/testfiles/plist_files/def_${plistfile}" "${PROJECT_BINARY_DIR}/${vfdtest}/testfiles/plist_files/def_${plistfile}" "HDF5_VFDTEST_LIB_files")
   endforeach ()
 endforeach ()
 
-add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HDF5_VFDTEST_LIB tests" DEPENDS ${HDF5_VFDTEST_LIB_files_list})
+add_custom_target (HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HDF5_VFDTEST_LIB tests" DEPENDS ${HDF5_VFDTEST_LIB_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -79,29 +79,29 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
   # Skip several tests with subfiling VFD, mostly due
   # to no support for collective I/O
   set (H5_VFD_subfiling_SKIP_TESTS
-    cache_api
+      cache_api
-    chunk_info
+      chunk_info
-    cmpd_dset
+      cmpd_dset
-    cork
+      cork
-    dangle
+      dangle
-    direct_chunk
+      direct_chunk
-    dsets
+      dsets
-    dt_arith
+      dt_arith
-    dtransform
+      dtransform
-    extend
+      extend
-    fillval
+      fillval
-    filter_fail
+      filter_fail
-    istore
+      istore
-    links
+      links
-    mf
+      mf
-    objcopy
+      objcopy
-    objcopy_ref
+      objcopy_ref
-    ohdr
+      ohdr
-    set_extent
+      set_extent
-    testhdf5
+      testhdf5
-    unlink
+      unlink
-    unregister
+      unregister
-    vol
+      vol
   )
 
   if (NOT CYGWIN)
@@ -115,7 +115,6 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
         if (NOT BUILD_SHARED_LIBS AND NOT HDF_CFG_NAME MATCHES "Debug")
           add_test (NAME VFD-${vfdname}-${vfdtest}
               COMMAND "${CMAKE_COMMAND}"
-                  -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                   -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}>"
                   -D "TEST_ARGS:STRING="
                   -D "TEST_VFD:STRING=${vfdname}"
@@ -125,7 +124,7 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
                   -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
           )
           set_tests_properties (VFD-${vfdname}-${vfdtest} PROPERTIES
-              ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+              ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
               WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
           )
           if ("VFD-${vfdname}-${vfdtest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -140,7 +139,6 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
       else ()
         add_test (NAME VFD-${vfdname}-${vfdtest}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}>"
                 -D "TEST_ARGS:STRING="
                 -D "TEST_VFD:STRING=${vfdname}"
@@ -150,7 +148,7 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
                 -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
         )
         set_tests_properties (VFD-${vfdname}-${vfdtest} PROPERTIES
-            ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+            ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
             WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
         )
         if ("VFD-${vfdname}-${vfdtest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -160,7 +158,6 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
     else ()
       add_test (NAME VFD-${vfdname}-${vfdtest}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VFD:STRING=${vfdname}"
@@ -170,7 +167,7 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
               -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
       )
       set_tests_properties (VFD-${vfdname}-${vfdtest} PROPERTIES
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
       )
       if ("VFD-${vfdname}-${vfdtest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -183,7 +180,6 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
     if (NOT "${vfdtest}" IN_LIST H5_VFD_${vfdname}_SKIP_TESTS)
       add_test (NAME VFD-${vfdname}-${vfdtest}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:${vfdtest}>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VFD:STRING=${vfdname}"
@@ -193,7 +189,7 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
               -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
       )
       set_tests_properties (VFD-${vfdname}-${vfdtest} PROPERTIES
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
       )
       if ("VFD-${vfdname}-${vfdtest}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -239,7 +235,6 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
     if (HDF5_TEST_FHEAP_VFD)
       add_test (NAME VFD-${vfdname}-fheap
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:fheap>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VFD:STRING=${vfdname}"
@@ -250,7 +245,7 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
       )
       set_tests_properties (VFD-${vfdname}-fheap PROPERTIES
           TIMEOUT ${CTEST_VERY_LONG_TIMEOUT}
-          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname}"
+          ENVIRONMENT "srcdir=${HDF5_TEST_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}/${vfdname}
       )
       if ("VFD-${vfdname}-fheap" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -276,9 +271,9 @@ add_custom_target(HDF5_VFDTEST_LIB_files ALL COMMENT "Copying files needed by HD
       set (BIN_REL_PATH "../")
     endif ()
 
-    add_test (NAME H5PLUGIN-vfd_plugin COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:vfd_plugin>)
+    add_test (NAME H5PLUGIN-vfd_plugin COMMAND $<TARGET_FILE:vfd_plugin>)
     set_tests_properties (H5PLUGIN-vfd_plugin PROPERTIES
-        ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/null_vfd_plugin_dir;srcdir=${HDF5_TEST_BINARY_DIR}"
+        ENVIRONMENT "HDF5_PLUGIN_PATH=${CMAKE_BINARY_DIR}/null_vfd_plugin_dir;srcdir=${HDF5_TEST_BINARY_DIR};${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY ${HDF5_TEST_BINARY_DIR}
     )
     if ("H5PLUGIN-vfd_plugin" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

test/flushrefreshTest.cmake

@@ -90,7 +90,7 @@ while (verification_done LESS "1")
     else ()
       message (STATUS "execute: ${TEST_PROGRAM} ${param1} ${param2}")
       execute_process (
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} ${TEST_PROGRAM} ${param1} ${param2}
+          COMMAND ${TEST_PROGRAM} ${param1} ${param2}
           RESULT_VARIABLE TEST_RESULT
           OUTPUT_FILE ${TEST_OUTPUT}
           ERROR_FILE ${TEST_OUTPUT}.err
@@ -133,7 +133,7 @@ while (verification_done LESS "2")
     else ()
       message (STATUS "execute: ${TEST_PROGRAM} ${param1}")
       execute_process (
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} ${TEST_PROGRAM} ${param1}
+          COMMAND ${TEST_PROGRAM} ${param1}
           RESULT_VARIABLE TEST_RESULT
           OUTPUT_FILE ${TEST_OUTPUT}
           ERROR_FILE ${TEST_OUTPUT}.err

testpar/CMakeVFDTests.cmake

@@ -15,7 +15,7 @@
 ###           T E S T I N G                                                ###
 ##############################################################################
 ##############################################################################
-H5_CREATE_VFD_DIR()
+H5_CREATE_VFD_DIR ()
 
 set (H5P_VFD_TESTS
     t_pflush1
@@ -34,7 +34,6 @@ macro (ADD_VFD_TEST vfdname resultcode)
         add_test (
             NAME MPI_TEST_VFD-${vfdname}-${h5_test}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:${h5_test}>"
                 -D "TEST_ARGS:STRING="
                 -D "TEST_VFD:STRING=${vfdname}"
@@ -44,7 +43,7 @@ macro (ADD_VFD_TEST vfdname resultcode)
                 -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
         )
         set_tests_properties (MPI_TEST_VFD-${vfdname}-${h5_test} PROPERTIES
-            ENVIRONMENT "srcdir=${HDF5_TEST_PAR_BINARY_DIR}/${vfdname}"
+            ENVIRONMENT "srcdir=${HDF5_TEST_PAR_BINARY_DIR}/${vfdname};${CROSSCOMPILING_PATH}"
             WORKING_DIRECTORY ${HDF5_TEST_PAR_BINARY_DIR}/${vfdname}
         )
         if ("MPI_TEST_VFD-${vfdname}-${h5_test}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/libtest/CMakeTests.cmake

@@ -24,7 +24,10 @@
 ##############################################################################
 
   macro (ADD_H5_TEST resultfile resultcode)
-    add_test (NAME H5LIBTEST-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5tools_test_utils> ${ARGN})
+    add_test (NAME H5LIBTEST-${resultfile} COMMAND $<TARGET_FILE:h5tools_test_utils> ${ARGN})
+    set_tests_properties (H5LIBTEST-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (NOT "${resultcode}" STREQUAL "0")
       set_tests_properties (H5LIBTEST-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()

tools/test/CMakeLists.txt

@@ -84,7 +84,8 @@ if (HDF5_ENABLE_FORMATTERS)
   endforeach()
 endif ()
 
-#add_test (NAME h5gentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest>)
+#add_test (NAME H5GEN-h5gentest COMMAND $<TARGET_FILE:h5gentest>)
+#set_target_properties (H5GEN-h5gentest PROPERTIES ENVIRONMENT "${CROSSCOMPILING_PATH}")
 
 #-- Add the h5diff tests
 add_subdirectory (h5diff)

tools/test/h5copy/CMakeTests.cmake

@@ -10,7 +10,7 @@
 # help@hdfgroup.org.
 #
 
-include(${HDF_CONFIG_DIR}/HDF5Macros.cmake)
+include (${HDF_CONFIG_DIR}/HDF5Macros.cmake)
 
 # System-independent path separator
 if (WIN32)
@@ -29,12 +29,12 @@ endif ()
 # Copy all the HDF5 files from the source directory into the test directory
 # --------------------------------------------------------------------
 set (LIST_HDF5_TEST_FILES
-  h5copy_extlinks_src.h5
+    h5copy_extlinks_src.h5
-  h5copy_extlinks_trg.h5
+    h5copy_extlinks_trg.h5
-  h5copy_ref.h5
+    h5copy_ref.h5
-  h5copytst.h5
+    h5copytst.h5
-  tudfilter.h5
+    tudfilter.h5
-  tudfilter2.h5
+     tudfilter2.h5
 )
 
 set (LIST_OTHER_TEST_FILES
@@ -50,44 +50,44 @@ set (LIST_OTHER_TEST_FILES
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 
 # Generate testfiles for VOL connector(s), if any
-set(h5copy_vol_files_list "")
+set (h5copy_vol_files_list "")
 
 foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
-  HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} ext_vol_dir_name vol_env)
+  HDF5_GET_VOL_TGT_INFO (${external_vol_tgt} ext_vol_dir_name vol_env)
 
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles" RESULT)
   if (NOT ${RESULT} EQUAL 0)
-    message(FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles")
+    message (FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles")
   endif()
 
-  add_test(NAME ${external_vol_tgt}-h5copygentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> --h5copy)
+  add_test(NAME ${external_vol_tgt}-h5copygentest COMMAND $<TARGET_FILE:h5gentest> --h5copy)
 
-  set_tests_properties(${external_vol_tgt}-h5copygentest PROPERTIES
+  set_tests_properties (${external_vol_tgt}-h5copygentest PROPERTIES
-    ENVIRONMENT "${vol_env}"
+      ENVIRONMENT "${vol_env};${CROSSCOMPILING_PATH}"
-    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles"
-    FIXTURES_SETUP ${external_vol_tgt}-files
+      FIXTURES_SETUP ${external_vol_tgt}-files
   )
 
   # These aren't HDF5 files, just copy them to the VOL's subdirectory
   foreach (listothers ${LIST_OTHER_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${listothers}"
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${listothers}"
-    "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${listothers}"
+        "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${listothers}"
-    "h5copy_vol_files"
+        "h5copy_vol_files"
     )
   endforeach ()
 endforeach ()
-add_custom_target(h5copy_vol_files ALL COMMENT "Copying files needed by h5copy tests" DEPENDS ${h5copy_vol_files_list})
+add_custom_target (h5copy_vol_files ALL COMMENT "Copying files needed by h5copy tests" DEPENDS ${h5copy_vol_files_list})
 
 # Copy pre-existing files for Native tests  
 foreach (listfiles ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listfiles}" "h5copy_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listfiles}" "h5copy_files")
 endforeach ()
 
 foreach (listothers ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5copy/expected/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/${listothers}" "h5copy_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5copy/expected/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/${listothers}" "h5copy_files")
 endforeach ()
-add_custom_target(h5copy_files ALL COMMENT "Copying files needed by h5copy tests" DEPENDS ${h5copy_files_list})
+add_custom_target (h5copy_files ALL COMMENT "Copying files needed by h5copy tests" DEPENDS ${h5copy_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -125,32 +125,32 @@ add_custom_target(h5copy_files ALL COMMENT "Copying files needed by h5copy tests
 #   - Additional arguments can be passed after all keywords (e.g., "-p" flag)
 #
 macro (ADD_H5_TEST testname)
-  cmake_parse_arguments(ARG
+  cmake_parse_arguments (ARG
-    "SAME_FILE;VERBOSE"
+      "SAME_FILE;VERBOSE"
-    "RESULT_CODE;ERROR_CHECK;INPUT_FILE;FORCE_FLAG;PREFILL_SRC;PREFILL_DEST;SOURCE_NAME;DEST_NAME"
+      "RESULT_CODE;ERROR_CHECK;INPUT_FILE;FORCE_FLAG;PREFILL_SRC;PREFILL_DEST;SOURCE_NAME;DEST_NAME"
-    ""
+      ""
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
   if (NOT DEFINED ARG_RESULT_CODE)
-    message(FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
+    message (FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
   endif ()
   if (NOT DEFINED ARG_INPUT_FILE)
-    message(FATAL_ERROR "ADD_H5_TEST: INPUT_FILE is required")
+    message (FATAL_ERROR "ADD_H5_TEST: INPUT_FILE is required")
   endif ()
   if (NOT DEFINED ARG_SOURCE_NAME)
-    message(FATAL_ERROR "ADD_H5_TEST: SOURCE_NAME is required")
+    message (FATAL_ERROR "ADD_H5_TEST: SOURCE_NAME is required")
   endif ()
   if (NOT DEFINED ARG_DEST_NAME)
-    message(FATAL_ERROR "ADD_H5_TEST: DEST_NAME is required")
+    message (FATAL_ERROR "ADD_H5_TEST: DEST_NAME is required")
   endif ()
 
   # Set up force flag
   if (DEFINED ARG_FORCE_FLAG AND NOT "${ARG_FORCE_FLAG}" STREQUAL "")
     set (fparam_flag "-f")
     set (fparam "${ARG_FORCE_FLAG}")
-  else()
+  else ()
     set (fparam_flag "")
     set (fparam "")
   endif ()
@@ -158,32 +158,32 @@ macro (ADD_H5_TEST testname)
   # Set up verbose flag
   if (ARG_VERBOSE)
     set (vparam "-v")
-  else()
+  else ()
     set (vparam "")
   endif ()
 
   # Determine input file for main test
   if (ARG_SAME_FILE)
     set (main_infile "${testname}.out.h5")
-  else()
+  else ()
     set (main_infile "${ARG_INPUT_FILE}")
-  endif()
+  endif ()
 
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}")
@@ -193,52 +193,49 @@ macro (ADD_H5_TEST testname)
     # Remove any output file left over from previous test run
     add_test (
         NAME ${vol_prefix}H5COPY-${testname}-clear-objects
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> ./testfiles/${testname}.out.h5
+        COMMAND $<TARGET_FILE:h5delete> ./testfiles/${testname}.out.h5
     )
-
     set_tests_properties (${vol_prefix}H5COPY-${testname}-clear-objects PROPERTIES
-      # h5delete will return an error code if targeted file does not exist - accept any result
+        # h5delete will return an error code if targeted file does not exist - accept any result
-      PASS_REGULAR_EXPRESSION "^$|"
+        PASS_REGULAR_EXPRESSION "^$|"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5COPY-${testname}-clear-objects PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        WORKING_DIRECTORY "${vol_workdir}"
+          WORKING_DIRECTORY "${vol_workdir}"
-        FIXTURES_REQUIRED "${vol_fixtures}"
+          FIXTURES_REQUIRED "${vol_fixtures}"
       )
     endif ()
 
     # Optional prefill sub-test, to be done before main test
     if (DEFINED ARG_PREFILL_SRC OR DEFINED ARG_PREFILL_DEST)
       if (NOT DEFINED ARG_PREFILL_SRC OR NOT DEFINED ARG_PREFILL_DEST)
-        message(FATAL_ERROR "Prefill test requires both PREFILL_SRC and PREFILL_DEST")
+        message (FATAL_ERROR "Prefill test requires both PREFILL_SRC and PREFILL_DEST")
       endif ()
-
       add_test (
         NAME ${vol_prefix}H5COPY-${testname}-prefill
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5copy> -i ./testfiles/${ARG_INPUT_FILE} -o ./testfiles/${testname}.out.h5 -v -s ${ARG_PREFILL_SRC} -d ${ARG_PREFILL_DEST}
+        COMMAND $<TARGET_FILE:h5copy> -i ./testfiles/${ARG_INPUT_FILE} -o ./testfiles/${testname}.out.h5 -v -s ${ARG_PREFILL_SRC} -d ${ARG_PREFILL_DEST}
       )
       set_tests_properties (${vol_prefix}H5COPY-${testname}-prefill PROPERTIES
-        DEPENDS ${vol_prefix}H5COPY-${testname}-clear-objects
+          DEPENDS ${vol_prefix}H5COPY-${testname}-clear-objects
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY-${testname}-prefill PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${vol_prefix}H5COPY-${testname}-prefill" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY-${testname}-prefill PROPERTIES DISABLED true)
       endif ()
 
-      set(prefill_dep "${vol_prefix}H5COPY-${testname}-prefill")
+      set (prefill_dep "${vol_prefix}H5COPY-${testname}-prefill")
     else ()
       # No prefill dependency
-      set(prefill_dep "")
+      set (prefill_dep "")
     endif () # end prefill step
 
     # No error check
@@ -246,13 +243,12 @@ macro (ADD_H5_TEST testname)
     if (NOT DEFINED ARG_ERROR_CHECK OR "${ARG_ERROR_CHECK}" STREQUAL "" OR HDF5_ENABLE_USING_MEMCHECKER)
       add_test (
           NAME ${vol_prefix}H5COPY-${testname}
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5copy> ${fparam_flag} ${fparam} -i ./testfiles/${main_infile} -o ./testfiles/${testname}.out.h5 ${vparam} -s ${ARG_SOURCE_NAME} -d ${ARG_DEST_NAME} ${ARG_UNPARSED_ARGUMENTS}
+          COMMAND $<TARGET_FILE:h5copy> ${fparam_flag} ${fparam} -i ./testfiles/${main_infile} -o ./testfiles/${testname}.out.h5 ${vparam} -s ${ARG_SOURCE_NAME} -d ${ARG_DEST_NAME} ${ARG_UNPARSED_ARGUMENTS}
       )
-    else() # Perform the same test with error checking
+    else () # Perform the same test with error checking
       add_test (
         NAME ${vol_prefix}H5COPY-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5copy>"
             -D "TEST_ARGS=${fparam_flag};${fparam};-i;./testfiles/${main_infile};-o;./testfiles/${testname}.out.h5;${vparam};-s;${ARG_SOURCE_NAME};-d;${ARG_DEST_NAME}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -265,19 +261,17 @@ macro (ADD_H5_TEST testname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
         )
     endif ()
-
     set_tests_properties (${vol_prefix}H5COPY-${testname} PROPERTIES DEPENDS
-      "${vol_prefix}H5COPY-${testname}-clear-objects;${prefill_dep}"
+        "${vol_prefix}H5COPY-${testname}-clear-objects;${prefill_dep}"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5COPY-${testname} PROPERTIES
-      ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-      WORKING_DIRECTORY "${vol_workdir}"
+          WORKING_DIRECTORY "${vol_workdir}"
-      FIXTURES_REQUIRED "${vol_fixtures}"
+          FIXTURES_REQUIRED "${vol_fixtures}"
       )
     endif ()
-
     if ("${vol_prefix}H5COPY-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (${vol_prefix}H5COPY-${testname} PROPERTIES DISABLED true)
     endif ()
@@ -286,23 +280,23 @@ macro (ADD_H5_TEST testname)
     if (NOT "${ARG_RESULT_CODE}" STREQUAL "2")
       add_test (
           NAME ${vol_prefix}H5COPY-${testname}-DIFF
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> -v ./testfiles/${main_infile} ./testfiles/${testname}.out.h5 ${ARG_SOURCE_NAME} ${ARG_DEST_NAME}
+          COMMAND $<TARGET_FILE:h5diff> -v ./testfiles/${main_infile} ./testfiles/${testname}.out.h5 ${ARG_SOURCE_NAME} ${ARG_DEST_NAME}
+      )
+      set_tests_properties (${vol_prefix}H5COPY-${testname}-DIFF PROPERTIES
+          DEPENDS ${vol_prefix}H5COPY-${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-      set_tests_properties (${vol_prefix}H5COPY-${testname}-DIFF PROPERTIES DEPENDS ${vol_prefix}H5COPY-${testname})
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY-${testname}-DIFF PROPERTIES
-          DEPENDS ${vol_prefix}H5COPY-${testname}
+            DEPENDS ${vol_prefix}H5COPY-${testname}
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${ARG_RESULT_CODE}" STREQUAL "1")
         set_tests_properties (${vol_prefix}H5COPY-${testname}-DIFF PROPERTIES WILL_FAIL "true")
       endif ()
-
       if ("${vol_prefix}H5COPY-${testname}-DIFF" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY-${testname}-DIFF PROPERTIES DISABLED true)
       endif ()
@@ -310,88 +304,84 @@ macro (ADD_H5_TEST testname)
 
     add_test (
         NAME ${vol_prefix}H5COPY-${testname}-clean-objects
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> ./testfiles/${testname}.out.h5
+        COMMAND $<TARGET_FILE:h5delete> ./testfiles/${testname}.out.h5
     )
-
     set_tests_properties (${vol_prefix}H5COPY-${testname}-clean-objects PROPERTIES
-      # h5delete will return an error code if targeted file does not exist - accept any result
+        # h5delete will return an error code if targeted file does not exist - accept any result
-      PASS_REGULAR_EXPRESSION "^$|"
+        PASS_REGULAR_EXPRESSION "^$|"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5COPY-${testname}-clean-objects PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        WORKING_DIRECTORY "${vol_workdir}"
+          WORKING_DIRECTORY "${vol_workdir}"
-        FIXTURES_REQUIRED "${vol_fixtures}"
+          FIXTURES_REQUIRED "${vol_fixtures}"
       )
     endif ()
-
-
     if (NOT "${ARG_RESULT_CODE}" STREQUAL "2")
       set_tests_properties (${vol_prefix}H5COPY-${testname}-clean-objects PROPERTIES DEPENDS ${vol_prefix}H5COPY-${testname}-DIFF)
     else ()
       set_tests_properties (${vol_prefix}H5COPY-${testname}-clean-objects PROPERTIES DEPENDS ${vol_prefix}H5COPY-${testname})
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname cmpfile)
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}")
       set (vol_fixtures "${vol_prefix}files")
 
       # Isolate plugin path string
-      string(FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
+      string (FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
       if (vol_plugin_path_posn GREATER -1)
         # Grab path string after HDF5_PLUGIN_PATH=
-        string(LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
+        string (LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
-        math(EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
+        math (EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
-        string(SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
+        string (SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
-      else()
+      else ()
-        set(vol_plugin_path "")
+        set (vol_plugin_path "")
-      endif()
+      endif ()
     endif ()
 
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
       # Remove any output file left over from previous test run
       add_test (
           NAME ${vol_prefix}H5COPY_UD-${testname}-clear-objects
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> testfiles/${testname}.out.h5
+          COMMAND $<TARGET_FILE:h5delete> testfiles/${testname}.out.h5
       )
-
+      set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clear-objects PROPERTIES
-      set_tests_properties(${vol_prefix}H5COPY_UD-${testname}-clear-objects PROPERTIES
+          # h5delete will return an error code if targeted file does not exist - accept any result
-        # h5delete will return an error code if targeted file does not exist - accept any result
+          PASS_REGULAR_EXPRESSION "^$|"
-        PASS_REGULAR_EXPRESSION "^$|"
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-
       if (NOT "${vol}" STREQUAL "native")
-        set_tests_properties(${vol_prefix}H5COPY_UD-${testname}-clear-objects PROPERTIES
+        set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clear-objects PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
 
       if ("${resultcode}" STREQUAL "2")
         # force a plugin not found error
         set (ud_search_path ${CMAKE_BINARY_DIR})
-      else()
+      else ()
         # use correct search path
         set (ud_search_path ${CMAKE_BINARY_DIR}/plugins)
       endif ()
@@ -399,7 +389,6 @@ macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname c
       add_test (
         NAME ${vol_prefix}H5COPY_UD-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5copy>"
             -D "TEST_ARGS:STRING=-v;-i;./testfiles/${infile};-o;./testfiles/${testname}.out.h5;${sparam};${srcname};${dparam};${dstname}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -411,19 +400,17 @@ macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname c
             -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_OUTPUT_DIRECTORY}"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
-
       set_tests_properties (${vol_prefix}H5COPY_UD-${testname} PROPERTIES
-        DEPENDS ${vol_prefix}H5COPY_UD-${testname}-clear-objects
+          DEPENDS ${vol_prefix}H5COPY_UD-${testname}-clear-objects
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD-${testname} PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${vol_prefix}H5COPY_UD-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY_UD-${testname} PROPERTIES DISABLED true)
       endif ()
@@ -431,7 +418,6 @@ macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname c
       add_test (
           NAME ${vol_prefix}H5COPY_UD-${testname}-DIFF
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
               -D "TEST_ARGS:STRING=-v;./testfiles/${cmpfile};./testfiles/${testname}.out.h5;${srcname};${dstname}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -443,17 +429,18 @@ macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname c
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_OUTPUT_DIRECTORY}"
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
-
+      set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-DIFF PROPERTIES
-      set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-DIFF PROPERTIES DEPENDS ${vol_prefix}H5COPY_UD-${testname})
+          DEPENDS ${vol_prefix}H5COPY_UD-${testname}
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
 
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-DIFF PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${vol_prefix}H5COPY_UD-${testname}-DIFF" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-DIFF PROPERTIES DISABLED true)
       endif ()
@@ -462,77 +449,75 @@ macro (ADD_H5_UD_TEST testname resultcode infile sparam srcname dparam dstname c
           NAME ${vol_prefix}H5COPY_UD-${testname}-clean-objects
           COMMAND ${CMAKE_COMMAND} -E remove testfiles/${testname}.out.h5
       )
-
-      set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clean-objects PROPERTIES DEPENDS ${vol_prefix}H5COPY_UD-${testname}-DIFF)
-
       set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clean-objects PROPERTIES
-        DEPENDS ${vol_prefix}H5COPY_UD-${testname}-DIFF
+          DEPENDS ${vol_prefix}H5COPY_UD-${testname}-DIFF
-        # h5delete will return an error code if targeted file does not exist - accept any result
+      )
-        PASS_REGULAR_EXPRESSION "^$|"
+      set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clean-objects PROPERTIES
+          DEPENDS ${vol_prefix}H5COPY_UD-${testname}-DIFF
+          # h5delete will return an error code if targeted file does not exist - accept any result
+          PASS_REGULAR_EXPRESSION "^$|"
       )
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD-${testname}-clean-objects PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
-      endif()
+      endif ()
 
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_UD_ERR_TEST testname resultcode infile sparam srcname dparam dstname cmpfile)
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}")
       set (vol_fixtures "${vol_prefix}files")
 
       # Isolate plugin path string
-      string(FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
+      string (FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
       if (vol_plugin_path_posn GREATER -1)
         # Grab path string after HDF5_PLUGIN_PATH=
-        string(LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
+        string (LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
-        math(EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
+        math (EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
-        string(SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
+        string (SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
-      else()
+      else ()
-        set(vol_plugin_path "")
+        set (vol_plugin_path "")
-      endif()
+      endif ()
     endif ()
 
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
       # Remove any output file left over from previous test run
       add_test (
           NAME ${vol_prefix}H5COPY_UD_ERR-${testname}-clear-objects
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> testfiles/${testname}_ERR.out.h5
+          COMMAND $<TARGET_FILE:h5delete> testfiles/${testname}_ERR.out.h5
       )
-
       set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clear-objects PROPERTIES
-        # h5delete will return an error code if targeted file does not exist - accept any result
+          # h5delete will return an error code if targeted file does not exist - accept any result
-        PASS_REGULAR_EXPRESSION "^$|"
+          PASS_REGULAR_EXPRESSION "^$|"
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clear-objects PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
 
@@ -549,7 +534,6 @@ macro (ADD_H5_UD_ERR_TEST testname resultcode infile sparam srcname dparam dstna
       add_test (
         NAME ${vol_prefix}H5COPY_UD_ERR-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5copy>"
             -D "TEST_ARGS:STRING=-v;--enable-error-stack;-i;./testfiles/${infile};-o;./testfiles/${testname}_ERR.out.h5;${sparam};${srcname};${dparam};${dstname}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -562,17 +546,17 @@ macro (ADD_H5_UD_ERR_TEST testname resultcode infile sparam srcname dparam dstna
             -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_OUTPUT_DIRECTORY}"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
-
+      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname} PROPERTIES
-      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname} PROPERTIES DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname}-clear-objects)
+          DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname}-clear-objects
-
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname} PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${vol_prefix}H5COPY_UD_ERR-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname} PROPERTIES DISABLED true)
       endif ()
@@ -580,7 +564,6 @@ macro (ADD_H5_UD_ERR_TEST testname resultcode infile sparam srcname dparam dstna
       add_test (
           NAME ${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
               -D "TEST_ARGS:STRING=-v;./testfiles/${cmpfile};./testfiles/${testname}_ERR.out.h5;${srcname};${dstname}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -592,61 +575,61 @@ macro (ADD_H5_UD_ERR_TEST testname resultcode infile sparam srcname dparam dstna
               -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_OUTPUT_DIRECTORY}"
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
-
+      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF PROPERTIES
-      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF PROPERTIES DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname})
+          DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname}
-
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
-
       if ("${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF PROPERTIES DISABLED true)
       endif ()
 
       add_test (
           NAME ${vol_prefix}H5COPY_UD_ERR-${testname}-clean-objects
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> testfiles/${testname}_ERR.out.h5
+          COMMAND $<TARGET_FILE:h5delete> testfiles/${testname}_ERR.out.h5
       )
-
       set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clean-objects PROPERTIES
-        # h5delete will return an error code if targeted file does not exist - accept any result
+          # h5delete will return an error code if targeted file does not exist - accept any result
-        PASS_REGULAR_EXPRESSION "^$|"
+          PASS_REGULAR_EXPRESSION "^$|"
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
+      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clean-objects PROPERTIES
+          DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF
       )
-
-      set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clean-objects PROPERTIES DEPENDS ${vol_prefix}H5COPY_UD_ERR-${testname}-DIFF)
-
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5COPY_UD_ERR-${testname}-clean-objects PROPERTIES
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
-          WORKING_DIRECTORY "${vol_workdir}"
+            WORKING_DIRECTORY "${vol_workdir}"
-          FIXTURES_REQUIRED "${vol_fixtures}"
+            FIXTURES_REQUIRED "${vol_fixtures}"
         )
       endif ()
 
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_SIMPLE_TEST resultfile resultcode)
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}")
@@ -655,7 +638,7 @@ macro (ADD_SIMPLE_TEST resultfile resultcode)
 
     # If using memchecker add tests without using scripts
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${vol_prefix}H5COPY-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5copy> ${ARGN})
+      add_test (NAME ${vol_prefix}H5COPY-${resultfile} COMMAND $<TARGET_FILE:h5copy> ${ARGN})
       if (${resultcode})
         set_tests_properties (${vol_prefix}H5COPY-${resultfile} PROPERTIES WILL_FAIL "true")
       endif ()
@@ -663,7 +646,6 @@ macro (ADD_SIMPLE_TEST resultfile resultcode)
       add_test (
           NAME ${vol_prefix}H5COPY-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5copy>"
               -D "TEST_ARGS=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -675,16 +657,15 @@ macro (ADD_SIMPLE_TEST resultfile resultcode)
     endif ()
     set_tests_properties (${vol_prefix}H5COPY-${resultfile} PROPERTIES
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5COPY-${resultfile} PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        WORKING_DIRECTORY "${vol_workdir}"
+          WORKING_DIRECTORY "${vol_workdir}"
-        FIXTURES_REQUIRED "${vol_fixtures}"
+          FIXTURES_REQUIRED "${vol_fixtures}"
       )
     endif ()
-
     if ("${vol_prefix}H5COPY-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (${vol_prefix}H5COPY-${resultfile} PROPERTIES DISABLED true)
     endif ()

tools/test/h5diff/CMakeTests.cmake

@@ -10,7 +10,7 @@
 # help@hdfgroup.org.
 #
 
-include(${HDF_CONFIG_DIR}/HDF5Macros.cmake)
+include (${HDF_CONFIG_DIR}/HDF5Macros.cmake)
 
 # System-independent path separator
 if (WIN32)
@@ -345,39 +345,39 @@ endif ()
 # copy test files from source to build dir
 #
 foreach (h5_tstfiles ${LIST_DIFF_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
   if (H5_HAVE_PARALLEL)
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
   endif ()
 endforeach ()
 foreach (h5_tstfiles ${LIST_VDS_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
   if (H5_HAVE_PARALLEL)
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
   endif ()
 endforeach ()
 foreach (h5_tstfiles ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
   if (H5_HAVE_PARALLEL)
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
   endif ()
 endforeach ()
 foreach (h5_tstfiles ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}" "h5diff_files")
   if (H5_HAVE_PARALLEL)
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}" "h5diff_files")
   endif ()
 endforeach ()
 # copy second version of tvlstr.h5
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tvlstr.h5" "${PROJECT_BINARY_DIR}/testfiles/tvlstr2.h5" "h5diff_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tvlstr.h5" "${PROJECT_BINARY_DIR}/testfiles/tvlstr2.h5" "h5diff_files")
 if (H5_HAVE_PARALLEL)
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/tvlstr.h5" "${PROJECT_BINARY_DIR}/PAR/testfiles/tvlstr2.h5" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/tvlstr.h5" "${PROJECT_BINARY_DIR}/PAR/testfiles/tvlstr2.h5" "h5diff_files")
 endif ()
 
 # create test files for each external VOL connector
-set(h5diff_vol_files_list "")
+set (h5diff_vol_files_list "")
-foreach(external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
+foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
-  HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} ext_vol_dir_name vol_env)
+  HDF5_GET_VOL_TGT_INFO (${external_vol_tgt} ext_vol_dir_name vol_env)
 
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles")
@@ -386,49 +386,49 @@ foreach(external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
   endif ()
 
   # Generate test files
-  add_test(NAME ${external_vol_tgt}-h5diffgentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> -h5diff)
+  add_test (NAME ${external_vol_tgt}-h5diffgentest COMMAND $<TARGET_FILE:h5gentest> -h5diff)
-  set_tests_properties(${external_vol_tgt}-h5diffgentest PROPERTIES
+  set_tests_properties (${external_vol_tgt}-h5diffgentest PROPERTIES
-    ENVIRONMENT "${vol_env}"
+      ENVIRONMENT "${vol_env};${CROSSCOMPILING_PATH}"
-    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles"
-    FIXTURES_SETUP ${ext_vol_dir_name}-files
+      FIXTURES_SETUP ${ext_vol_dir_name}-files
   )
 
   if (H5_HAVE_PARALLEL)
-    add_test(NAME ${external_vol_tgt}-h5diffgentest-PAR COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> -h5diff)
+    add_test (NAME ${external_vol_tgt}-h5diffgentest-PAR COMMAND $<TARGET_FILE:h5gentest> -h5diff)
-    set_tests_properties(${external_vol_tgt}-h5diffgentest-PAR PROPERTIES
+    set_tests_properties (${external_vol_tgt}-h5diffgentest-PAR PROPERTIES
-      ENVIRONMENT "${vol_env}"
+        ENVIRONMENT "${vol_env}"
-      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles"
-      FIXTURES_SETUP ${ext_vol_dir_name}-files
+        FIXTURES_SETUP ${ext_vol_dir_name}-files
     )
   endif ()
 
   # These aren't HDF5 files, just copy them to the VOL's subdirectory
   foreach (listothers ${LIST_OTHER_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${listothers}"
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${listothers}"
-    "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${listothers}"
+        "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${listothers}"
-    "h5diff_vol_files"
+        "h5diff_vol_files"
     )
   endforeach ()
 
   if (COPY_WINDOWS_FILES)
-    foreach(h5_tstfiles ${LIST_WIN_TEST_FILES})
+    foreach (h5_tstfiles ${LIST_WIN_TEST_FILES})
-      HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
+      HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
 
       if (H5_HAVE_PARALLEL)
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
       endif ()
-    endforeach()
+    endforeach ()
   else ()
-    foreach(h5_tstfiles ${LIST_WIN_TEST_FILES})
+    foreach (h5_tstfiles ${LIST_WIN_TEST_FILES})
-      HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
+      HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
 
       if (H5_HAVE_PARALLEL)
-        HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
+        HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/PAR/${ext_vol_dir_name}/testfiles/${h5_tstfiles}.txt" "h5diff_vol_files")
       endif ()
-    endforeach()
+    endforeach ()
   endif ()
 endforeach () # per-VOL loop
-add_custom_target(h5diff_vol_files ALL COMMENT "Copying files needed by h5diff VOL tests" DEPENDS ${h5diff_vol_files_list})
+add_custom_target (h5diff_vol_files ALL COMMENT "Copying files needed by h5diff VOL tests" DEPENDS ${h5diff_vol_files_list})
 
 #
 # Overwrite system dependent files (Windows) and not VS2015
@@ -443,20 +443,20 @@ if (WIN32 AND MSVC_VERSION LESS 1900)
 endif ()
 if (COPY_WINDOWS_FILES)
   foreach (h5_tstfiles ${LIST_WIN_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}.txt" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}.txt" "h5diff_files")
     if (H5_HAVE_PARALLEL)
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}.txt" "h5diff_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}w.txt" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}.txt" "h5diff_files")
     endif ()
   endforeach ()
 else ()
   foreach (h5_tstfiles ${LIST_WIN_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}.txt" "h5diff_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/testfiles/${h5_tstfiles}.txt" "h5diff_files")
     if (H5_HAVE_PARALLEL)
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}.txt" "h5diff_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5diff/expected/${h5_tstfiles}.txt" "${PROJECT_BINARY_DIR}/PAR/testfiles/${h5_tstfiles}.txt" "h5diff_files")
     endif ()
   endforeach ()
 endif ()
-add_custom_target(h5diff_files ALL COMMENT "Copying files needed by h5diff tests" DEPENDS ${h5diff_files_list})
+add_custom_target (h5diff_files ALL COMMENT "Copying files needed by h5diff tests" DEPENDS ${h5diff_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -483,21 +483,21 @@ add_custom_target(h5diff_files ALL COMMENT "Copying files needed by h5diff tests
 #
 macro (ADD_H5_TEST testname)
   cmake_parse_arguments(ARG
-    "SERIAL_ONLY"
+      "SERIAL_ONLY"
-    "RESULT_CODE;ERROR_REF"
+      "RESULT_CODE;ERROR_REF"
-    ""
+      ""
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
   if (NOT DEFINED ARG_RESULT_CODE)
-    message(FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
+    message (FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
   endif ()
 
   # Set up args to pass to serial/parallel variants
   if (DEFINED ARG_ERROR_REF)
     set(err_ref2 "ERROR_REF" "${ARG_ERROR_REF}")
-  else()
+  else ()
     set (err_ref2 "")
   endif ()
 
@@ -512,53 +512,53 @@ endmacro ()
 
 macro (ADD_SH5_TEST testname)
   cmake_parse_arguments(ARG
-    ""
+      ""
-    "RESULT_CODE;ERROR_REF"
+      "RESULT_CODE;ERROR_REF"
-    ""
+      ""
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
   if (NOT DEFINED ARG_RESULT_CODE)
-    message(FATAL_ERROR "ADD_SH5_TEST: RESULT_CODE is required")
+    message (FATAL_ERROR "ADD_SH5_TEST: RESULT_CODE is required")
   endif ()
 
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
-    set(vol_env "")
+    set (vol_env "")
 
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
       set (workdir "${PROJECT_BINARY_DIR}/testfiles")
     else ()
       # An external VOL connector
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
 
       set (workdir "${PROJECT_BINARY_DIR}/${vol}/testfiles")
       # Isolate plugin path string
-      string(FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
+      string (FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
 
       if (vol_plugin_path_posn GREATER -1)
         # Grab path string after HDF5_PLUGIN_PATH=
-        string(LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
+        string (LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
-        math(EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
+        math (EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
-        string(SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
+        string (SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
       else()
-        set(vol_plugin_path "")
+        set (vol_plugin_path "")
-      endif()
+      endif ()
     endif ()
 
     # If using memchecker add tests without using scripts
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${vol_prefix}H5DIFF-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> ${ARG_UNPARSED_ARGUMENTS})
+      add_test (NAME ${vol_prefix}H5DIFF-${testname} COMMAND $<TARGET_FILE:h5diff> ${ARG_UNPARSED_ARGUMENTS})
       if (${ARG_RESULT_CODE})
         set_tests_properties (${vol_prefix}H5DIFF-${testname} PROPERTIES WILL_FAIL "true")
       endif ()
@@ -566,7 +566,6 @@ macro (ADD_SH5_TEST testname)
       add_test (
           NAME ${vol_prefix}H5DIFF-${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
               -D "TEST_ARGS:STRING=${ARG_UNPARSED_ARGUMENTS}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -579,35 +578,33 @@ macro (ADD_SH5_TEST testname)
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
     endif ()
-
     set_tests_properties (${vol_prefix}H5DIFF-${testname} PROPERTIES
         WORKING_DIRECTORY "${workdir}"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5DIFF-${testname} PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        FIXTURES_REQUIRED "h5diff_vol_files"
+          FIXTURES_REQUIRED "h5diff_vol_files"
       )
     endif ()
-
     if ("${vol_prefix}H5DIFF-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (${vol_prefix}H5DIFF-${testname} PROPERTIES DISABLED true)
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_PH5_TEST testname)
   cmake_parse_arguments(ARG
-    ""
+      ""
-    "RESULT_CODE;ERROR_REF"
+      "RESULT_CODE;ERROR_REF"
-    ""
+      ""
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
   if (NOT DEFINED ARG_RESULT_CODE)
-    message(FATAL_ERROR "ADD_PH5_TEST: RESULT_CODE is required")
+    message (FATAL_ERROR "ADD_PH5_TEST: RESULT_CODE is required")
   endif ()
 
   # Handle parallel-exlusive ref file logic
@@ -618,37 +615,37 @@ macro (ADD_PH5_TEST testname)
     set (ref_file "${testname}.txt")
   endif ()
 
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
-    set(vol_env "")
+    set (vol_env "")
 
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
       set (workdir "${PROJECT_BINARY_DIR}/PAR/testfiles")
     else ()
       # An external VOL connector
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
 
       set (workdir "${PROJECT_BINARY_DIR}/PAR/${vol}/testfiles")
       # Isolate plugin path string
-      string(FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
+      string (FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
 
       if (vol_plugin_path_posn GREATER -1)
         # Grab path string after HDF5_PLUGIN_PATH=
-        string(LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
+        string (LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
-        math(EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
+        math (EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
-        string(SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
+        string (SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
-      else()
+      else ()
-        set(vol_plugin_path "")
+        set (vol_plugin_path "")
-      endif()
+      endif ()
     endif ()
 
     # If using memchecker add tests without using scripts
@@ -683,15 +680,15 @@ macro (ADD_PH5_TEST testname)
 
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}MPI_TEST_H5DIFF-${testname} PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        FIXTURES_REQUIRED "h5diff_vol_files"
+          FIXTURES_REQUIRED "h5diff_vol_files"
       )
     endif ()
 
     if ("${vol_prefix}MPI_TEST_H5DIFF-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (${vol_prefix}MPI_TEST_H5DIFF-${testname} PROPERTIES DISABLED true)
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_UD_TEST testname resultcode resultfile)
@@ -707,7 +704,6 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
     add_test (
         NAME ${vol_prefix}H5DIFF_UD-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -720,7 +716,9 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
             -D "TEST_LIBRARY_DIRECTORY=${CMAKE_TEST_OUTPUT_DIRECTORY}"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
-
+    set_tests_properties (${vol_prefix}H5DIFF_UD-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("${vol_prefix}H5DIFF_UD-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (${vol_prefix}H5DIFF_UD-${testname} PROPERTIES DISABLED true)
     endif ()

tools/test/h5dump/CMakeTests.cmake

@@ -16,7 +16,7 @@
 ##############################################################################
 ##############################################################################
 
-include(${HDF_CONFIG_DIR}/HDF5Macros.cmake)
+include (${HDF_CONFIG_DIR}/HDF5Macros.cmake)
 
 # System-independent path separator
 if (WIN32)
@@ -403,66 +403,66 @@ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/S3TEST/testfiles")
 # copy test files from source dir to test dir
 #
 foreach (tst_h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_h5_file}" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_h5_file}" "h5dump_std_files")
 endforeach ()
 
 foreach (tst_exp_file ${HDF5_REFERENCE_EXP_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/${tst_exp_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_exp_file}" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/${tst_exp_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_exp_file}" "h5dump_std_files")
 endforeach ()
 
 foreach (tst_other_file ${HDF5_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_other_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_other_file}" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_other_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_other_file}" "h5dump_std_files")
 endforeach ()
 
 foreach (tst_h5N_file ${HDF5_N_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_h5N_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_h5N_file}-N" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_h5N_file}" "${PROJECT_BINARY_DIR}/testfiles/std/${tst_h5N_file}-N" "h5dump_std_files")
 endforeach ()
 
 foreach (tst_s3_file ${H5DUMP_S3PROXY_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_s3_file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${tst_s3_file}" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_s3_file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${tst_s3_file}" "h5dump_std_files")
 endforeach ()
 
 # --------------------------------------------------------------------
 # Special file handling
 # --------------------------------------------------------------------
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/tbin1.ddl" "${PROJECT_BINARY_DIR}/testfiles/std/tbin1LE.ddl" "h5dump_std_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/tbin1.ddl" "${PROJECT_BINARY_DIR}/testfiles/std/tbin1LE.ddl" "h5dump_std_files")
 
 # Certain versions of Visual Studio produce rounding differences compared with the reference data of the tfloatsattr test
 if (WIN32 AND (CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION VERSION_LESS 10.0.18362.0))
-  configure_file(${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp ${PROJECT_BINARY_DIR}/testfiles/std/tbinregR.exp NEWLINE_STYLE CRLF)
+  configure_file (${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp ${PROJECT_BINARY_DIR}/testfiles/std/tbinregR.exp NEWLINE_STYLE CRLF)
 else ()
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp" "${PROJECT_BINARY_DIR}/testfiles/std/tbinregR.exp" "h5dump_std_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp" "${PROJECT_BINARY_DIR}/testfiles/std/tbinregR.exp" "h5dump_std_files")
 endif ()
-add_custom_target(h5dump_std_files ALL COMMENT "Copying files needed by h5dump_std tests" DEPENDS ${h5dump_std_files_list})
+add_custom_target (h5dump_std_files ALL COMMENT "Copying files needed by h5dump_std tests" DEPENDS ${h5dump_std_files_list})
 
 # --------------------------------------------------------------------
 # Copy test files for each external VOL connector
 # --------------------------------------------------------------------
-set(h5dump_vol_files_list "")
+set (h5dump_vol_files_list "")
-foreach(external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
+foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
-  HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} ext_vol_dir_name vol_env)
+  HDF5_GET_VOL_TGT_INFO (${external_vol_tgt} ext_vol_dir_name vol_env)
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std")
 
   # Generate test files
-  add_test(NAME ${external_vol_tgt}-h5dumpgentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> --h5dump)
+  add_test (NAME ${external_vol_tgt}-h5dumpgentest COMMAND $<TARGET_FILE:h5gentest> --h5dump)
-  set_tests_properties(${external_vol_tgt}-h5dumpgentest PROPERTIES
+  set_tests_properties (${external_vol_tgt}-h5dumpgentest PROPERTIES
-    ENVIRONMENT "${vol_env}"
+      ENVIRONMENT "${vol_env}"
-    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std"
-    FIXTURES_SETUP "h5dump_vol_files"
+      FIXTURES_SETUP "h5dump_vol_files"
   )
 
   # These aren't HDF5 files, just copy them to the VOL's subdirectory
   foreach (tst_exp_file ${HDF5_REFERENCE_EXP_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/${tst_exp_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_exp_file}" "h5dump_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/${tst_exp_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_exp_file}" "h5dump_vol_files")
   endforeach ()
 
   foreach (tst_other_file ${HDF5_REFERENCE_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_other_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_other_file}" "h5dump_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_other_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_other_file}" "h5dump_vol_files")
   endforeach ()
 
   foreach (tst_h5N_file ${HDF5_N_REFERENCE_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_h5N_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_h5N_file}-N" "h5dump_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${tst_h5N_file}" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/${tst_h5N_file}-N" "h5dump_vol_files")
   endforeach ()
 
   # Don't copy s3 files for each VOL connector, since the s3 files are specific to the native-exlusive ROS3 VFD
@@ -470,16 +470,16 @@ foreach(external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
   # --------------------------------------------------------------------
   # Special file handling
   # --------------------------------------------------------------------
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/tbin1.ddl" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbin1LE.ddl" "h5dump_vol_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/tbin1.ddl" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbin1LE.ddl" "h5dump_vol_files")
   
   # Certain versions of Visual Studio produce rounding differences compared with the reference data of the tfloatsattr test
   if (WIN32 AND (CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION VERSION_LESS 10.0.18362.0))
-    configure_file(${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp ${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbinregR.exp NEWLINE_STYLE CRLF)
+    configure_file (${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp ${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbinregR.exp NEWLINE_STYLE CRLF)
   else ()
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbinregR.exp" "h5dump_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/exportfiles/tbinregR.exp" "${PROJECT_BINARY_DIR}/${ext_vol_dir_name}/testfiles/std/tbinregR.exp" "h5dump_vol_files")
   endif ()
 endforeach ()
-add_custom_target(h5dump_vol_files ALL COMMENT "Copying files needed by h5dump VOL tests" DEPENDS ${h5dump_vol_files_list})
+add_custom_target (h5dump_vol_files ALL COMMENT "Copying files needed by h5dump VOL tests" DEPENDS ${h5dump_vol_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -490,12 +490,11 @@ add_custom_target(h5dump_vol_files ALL COMMENT "Copying files needed by h5dump V
 macro (ADD_HELP_TEST testname resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARGN})
+    add_test (NAME H5DUMP-${testname} COMMAND $<TARGET_FILE:h5dump> ${ARGN})
   else ()
     add_test (
         NAME H5DUMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/std"
@@ -507,6 +506,7 @@ macro (ADD_HELP_TEST testname resultcode)
   endif ()
   set_tests_properties (H5DUMP-${testname} PROPERTIES
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/std"
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
   )
   if ("H5DUMP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5DUMP-${testname} PROPERTIES DISABLED true)
@@ -548,20 +548,20 @@ endmacro ()
 #   ANY_PATHS <paths>   - The -N/--any_path argument(s) to h5dump.
 #
 macro (ADD_H5_TEST testname)
-  cmake_parse_arguments(ARG
+  cmake_parse_arguments (ARG
-    "BINARY_OUTPUT;MASK_ERROR;GREP_COMPARE;BINFILE;SKIP_TEST;NATIVE_ONLY" # Flags
+      "BINARY_OUTPUT;MASK_ERROR;GREP_COMPARE;BINFILE;SKIP_TEST;NATIVE_ONLY" # Flags
-    "RESULT_CODE;APPLY_FILTERS;TARGET_FILE;OUTPUT_FILE;DDL_FILE;H5ERRREF;ENVVAR;ENVVAL" # Single value args
+      "RESULT_CODE;APPLY_FILTERS;TARGET_FILE;OUTPUT_FILE;DDL_FILE;H5ERRREF;ENVVAR;ENVVAL" # Single value args
-    "ANY_PATHS" # Multi value args
+      "ANY_PATHS" # Multi value args
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
   if (NOT DEFINED ARG_RESULT_CODE)
-    message(FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
+    message (FATAL_ERROR "ADD_H5_TEST: RESULT_CODE is required")
   endif ()
 
   if (NOT DEFINED ARG_TARGET_FILE)
-    message(FATAL_ERROR "ADD_H5_TEST: TARGET_FILE is required")
+    message (FATAL_ERROR "ADD_H5_TEST: TARGET_FILE is required")
   endif ()
 
   # Validate optional parameters
@@ -569,7 +569,7 @@ macro (ADD_H5_TEST testname)
     if ("${ARG_APPLY_FILTERS}" STREQUAL "")
       # default
       set (_FILTER_VAL "1")
-    else()
+    else ()
       set (_FILTER_VAL "${ARG_APPLY_FILTERS}")
     endif ()
 
@@ -600,28 +600,28 @@ macro (ADD_H5_TEST testname)
   endif ()
 
   if (DEFINED ARG_ANY_PATHS)
-    set(temp_path_arg "")
+    set (temp_path_arg "")
     foreach (arg_path IN LISTS ARG_ANY_PATHS)
-        if (arg_path STREQUAL "")
+      if (arg_path STREQUAL "")
-            message(FATAL_ERROR "ADD_H5_TEST: ANY_PATHS requires a path")
+        message (FATAL_ERROR "ADD_H5_TEST: ANY_PATHS requires a path")
-        endif ()
+      endif ()
 
-        list(APPEND temp_path_arg "--any_path=${arg_path}")
+      list (APPEND temp_path_arg "--any_path=${arg_path}")
-    endforeach()
+    endforeach ()
 
     set (ARG_ANY_PATHS ${temp_path_arg})
   endif ()
 
   # both of these args want to define argument to -o flag
   if (DEFINED ARG_OUTPUT_FILE AND ${ARG_BINFILE}) 
-    message(FATAL_ERROR "ADD_H5_TEST: OUTPUT_FILE and BINFILE are mutually exclusive")
+    message  (FATAL_ERROR "ADD_H5_TEST: OUTPUT_FILE and BINFILE are mutually exclusive")
   endif()
 
   if (DEFINED ARG_OUTPUT_FILE)
     set (ARG_OUTPUT_FILEARGS "-o" "${ARG_OUTPUT_FILE}.txt")
   elseif (${ARG_BINFILE})
     set (ARG_OUTPUT_FILEARGS "-o" "${testname}.bin")
-  else()
+  else ()
     set (ARG_OUTPUT_FILEARGS "")
   endif ()
 
@@ -630,26 +630,26 @@ macro (ADD_H5_TEST testname)
 
   if (${ARG_BINFILE})
     set (ctest_testname "BIN_EXPORT-${testname}")
-  elseif(DEFINED ARG_ANY_PATHS)
+  elseif (DEFINED ARG_ANY_PATHS)
     set (ctest_testname "N-${testname}")
-  elseif(DEFINED ARG_OUTPUT_FILE AND ARG_BINARY_OUTPUT)
+  elseif (DEFINED ARG_OUTPUT_FILE AND ARG_BINARY_OUTPUT)
     set (ctest_testname "output-${testname}")
-  endif()
+  endif ()
 
   # Set up list of files to clean up
-  set(DO_CLEANUP FALSE)
+  set (DO_CLEANUP FALSE)
-  set(CLEANUP_DEPENDENCIES "")
+  set (CLEANUP_DEPENDENCIES "")
 
   if (DEFINED ARG_TARGET_FILE OR DEFINED ARG_OUTPUT_FILE OR DEFINED ARG_DDL_FILE OR DEFINED ARG_ANY_PATHS OR ${ARG_BINFILE})
-    set(DO_CLEANUP TRUE)
+    set (DO_CLEANUP TRUE)
   endif ()
 
   if (DEFINED ARG_ENVVAL AND NOT DEFINED ARG_ENVVAR)
-    message(FATAL_ERROR "ADD_H5_TEST: ENVVAL requires ENVVAR")
+    message (FATAL_ERROR "ADD_H5_TEST: ENVVAL requires ENVVAR")
   endif ()
 
   if (DEFINED ARG_ENVVAR AND NOT DEFINED ARG_ENVVAL)
-    message(FATAL_ERROR "ADD_H5_TEST: ENVVAR requires ENVVAL")
+    message (FATAL_ERROR "ADD_H5_TEST: ENVVAR requires ENVVAL")
   endif ()
 
   if (DEFINED ARG_DDL_FILE)
@@ -660,13 +660,13 @@ macro (ADD_H5_TEST testname)
 
   if (${ARG_BINARY_OUTPUT})
     if (NOT DEFINED ARG_OUTPUT_FILE)
-      message(FATAL_ERROR "ADD_H5_TEST: BINARY_OUTPUT flag requires OUTPUT_FILE")
+      message (FATAL_ERROR "ADD_H5_TEST: BINARY_OUTPUT flag requires OUTPUT_FILE")
     endif ()
 
     set (BINARY_OUTPUT_FLAG "-b")
   else ()
     set (BINARY_OUTPUT_FLAG "")
-  endif()
+  endif ()
 
   if (DEFINED ${ARG_RESULT_CHECK})
     set (ARG_RESULT_CHECK_FILE "${ARG_RESULT_CHECK}")
@@ -679,49 +679,50 @@ macro (ADD_H5_TEST testname)
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
     if (DEFINED ARG_H5ERRREF OR ${ARG_BINFILE} OR ${ARG_GREP_COMPARE})
-      set(should_skip_test TRUE)
+      set (should_skip_test TRUE)
-    endif()
+    endif ()
-  endif()
+  endif ()
 
   if (${ARG_SKIP_TEST})
-    set(should_skip_test TRUE)
+    set (should_skip_test TRUE)
-  endif()
+  endif ()
 
   if (${ARG_NATIVE_ONLY})
-    set(num_ext_vols 0)
+    set (num_ext_vols 0)
-  else()
+  else ()
-    list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+    list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
-  endif()
+  endif ()
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
-    set(vol_env "")
+    set (vol_env "")
 
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
       set (vol_prefix "")
+      set (vol_env "${CROSSCOMPILING_PATH}")
       set (workdir "${PROJECT_BINARY_DIR}/testfiles/std")
     else ()
       # An external VOL connector
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
 
       set (workdir "${PROJECT_BINARY_DIR}/${vol}/testfiles/std")
       # Isolate plugin path string
-      string(FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
+      string (FIND "${vol_env}" "HDF5_PLUGIN_PATH=" vol_plugin_path_posn)
 
       if (vol_plugin_path_posn GREATER -1)
         # Grab path string after HDF5_PLUGIN_PATH=
-        string(LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
+        string (LENGTH "HDF5_PLUGIN_PATH=" path_prefix_len)
-        math(EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
+        math (EXPR vol_plugin_path_posn "${vol_plugin_path_posn} + ${path_prefix_len}")
-        string(SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
+        string (SUBSTRING "${vol_env}" ${vol_plugin_path_posn} -1 vol_plugin_path)
-      else()
+      else ()
-        set(vol_plugin_path "")
+        set (vol_plugin_path "")
-      endif()
+      endif ()
     endif () # env VOL arg setup
 
     # Clean up if test produces artifacts
@@ -743,15 +744,17 @@ macro (ADD_H5_TEST testname)
 
     # If using memchecker add tests without using scripts
     if (HDF5_ENABLE_USING_MEMCHECKER AND NOT ARG_MASK_ERROR AND NOT ARG_GREP_COMPARE AND NOT DEFINED ARG_H5ERRREF)
-      add_test (NAME ${vol_prefix}H5DUMP-${ctest_testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARG_ANY_PATHS} ${ARG_UNPARSED_ARGUMENTS} ${ARG_DDL_FILE_CMD} ${BINARY_OUTPUT_FLAG} ${ARG_OUTPUT_FILEARGS} ${ARG_TARGET_FILE})
+      add_test (NAME ${vol_prefix}H5DUMP-${ctest_testname} COMMAND $<TARGET_FILE:h5dump> ${ARG_ANY_PATHS} ${ARG_UNPARSED_ARGUMENTS} ${ARG_DDL_FILE_CMD} ${BINARY_OUTPUT_FLAG} ${ARG_OUTPUT_FILEARGS} ${ARG_TARGET_FILE})
       if (${ARG_RESULT_CODE})
-        set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES WILL_FAIL "true")
+        set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname}
+            PROPERTIES WILL_FAIL "true"
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
       endif ()
     else ()
       add_test (
           NAME ${vol_prefix}H5DUMP-${ctest_testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=${ARG_ANY_PATHS};${ARG_UNPARSED_ARGUMENTS};${ARG_DDL_FILE_CMD};${BINARY_OUTPUT_FLAG};${ARG_OUTPUT_FILEARGS};${ARG_TARGET_FILE}"
               -D "TEST_FOLDER=${workdir}"
@@ -775,8 +778,12 @@ macro (ADD_H5_TEST testname)
     # Set VOL-specific properties
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        FIXTURES_REQUIRED "h5dump_vol_files"
+          FIXTURES_REQUIRED "h5dump_vol_files"
+      )
+    else ()
+      set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES
+          ENVIRONMENT "${vol_env}"
       )
     endif ()
 
@@ -784,34 +791,35 @@ macro (ADD_H5_TEST testname)
       set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES DISABLED true)
     endif ()
       
-    set(CLEANUP_DEPENDENCIES "${vol_prefix}H5DUMP-${ctest_testname}")
+    set (CLEANUP_DEPENDENCIES "${vol_prefix}H5DUMP-${ctest_testname}")
 
     if (DEFINED ARG_TARGET_FILE AND DEFINED ARG_OUTPUT_FILE)
       add_test (
-        NAME ${vol_prefix}H5DUMP-${ctest_testname}-output-cmp
+          NAME ${vol_prefix}H5DUMP-${ctest_testname}-output-cmp
-        COMMAND ${CMAKE_COMMAND} -E compare_files --ignore-eol ${testname}.txt ${testname}.exp
+          COMMAND ${CMAKE_COMMAND} -E compare_files --ignore-eol ${testname}.txt ${testname}.exp
       )
 
-      set_tests_properties(${vol_prefix}H5DUMP-${ctest_testname}-output-cmp PROPERTIES
+      set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname}-output-cmp PROPERTIES
-        DEPENDS H5DUMP-${ctest_testname}
+          DEPENDS H5DUMP-${ctest_testname}
-        WORKING_DIRECTORY "${workdir}"
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+          WORKING_DIRECTORY "${workdir}"
       )
 
       if ("${vol_prefix}H5DUMP-${ctest_testname}-output-cmp" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname}-output-cmp PROPERTIES DISABLED true)
       endif ()
 
-      list(APPEND CLEANUP_DEPENDENCIES "${vol_prefix}H5DUMP-${ctest_testname}-output-cmp")
+      list (APPEND CLEANUP_DEPENDENCIES "${vol_prefix}H5DUMP-${ctest_testname}-output-cmp")
     endif ()
 
     if (${DO_CLEANUP})
       add_test (
-        NAME ${vol_prefix}H5DUMP-${ctest_testname}-clean-objects
+          NAME ${vol_prefix}H5DUMP-${ctest_testname}-clean-objects
-        COMMAND ${CMAKE_COMMAND} -E remove
+          COMMAND ${CMAKE_COMMAND} -E remove
-          "${testname}.txt"
+              "${testname}.txt"
-          "${ARG_OUTPUT_FILE}.txt"
+              "${ARG_OUTPUT_FILE}.txt"
-          "${ARG_DDL_FILE}.txt"
+              "${ARG_DDL_FILE}.txt"
-          "${testname}.bin"
+              "${testname}.bin"
       )
 
       set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname}-clean-objects PROPERTIES
@@ -822,8 +830,8 @@ macro (ADD_H5_TEST testname)
 
     # Mark the test as disabled if needed
     if (should_skip_test)
-      set_tests_properties(${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES DISABLED true)
+      set_tests_properties (${vol_prefix}H5DUMP-${ctest_testname} PROPERTIES DISABLED true)
-    endif()
+    endif ()
   endforeach () # per-VOL loop
 endmacro ()
 
@@ -842,7 +850,6 @@ macro (ADD_H5_TEST_IMPORT conffile resultfile testfile resultcode)
     add_test (
         NAME H5DUMP-IMPORT-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN};-o;${resultfile}.bin;${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/std"
@@ -853,22 +860,25 @@ macro (ADD_H5_TEST_IMPORT conffile resultfile testfile resultcode)
     )
     set_tests_properties (H5DUMP-IMPORT-${resultfile} PROPERTIES
         DEPENDS H5DUMP-IMPORT-${resultfile}-clear-objects
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/std"
     )
     if ("H5DUMP-IMPORT-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5DUMP-IMPORT-${resultfile} PROPERTIES DISABLED true)
     endif ()
-    add_test (NAME H5DUMP-IMPORT-h5import-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5import> ${resultfile}.bin -c ${conffile}.out -o ${resultfile}.h5)
+    add_test (NAME H5DUMP-IMPORT-h5import-${resultfile} COMMAND $<TARGET_FILE:h5import> ${resultfile}.bin -c ${conffile}.out -o ${resultfile}.h5)
     set_tests_properties (H5DUMP-IMPORT-h5import-${resultfile} PROPERTIES
         DEPENDS H5DUMP-IMPORT-${resultfile}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/std"
     )
     if ("H5DUMP-IMPORT-h5import-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5DUMP-IMPORT-h5import-${resultfile} PROPERTIES DISABLED true)
     endif ()
-    add_test (NAME H5DUMP-IMPORT-h5diff-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> ${testfile} ${resultfile}.h5 /integer /integer)
+    add_test (NAME H5DUMP-IMPORT-h5diff-${resultfile} COMMAND $<TARGET_FILE:h5diff> ${testfile} ${resultfile}.h5 /integer /integer)
     set_tests_properties (H5DUMP-IMPORT-h5diff-${resultfile} PROPERTIES
         DEPENDS H5DUMP-IMPORT-h5import-${resultfile}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/std"
     )
     if ("H5DUMP-IMPORT-h5diff-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -892,7 +902,6 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
     add_test (
         NAME H5DUMP_UD-${testname}-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/std"
@@ -905,6 +914,7 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5DUMP_UD-${testname}-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/std"
     )
     if ("H5DUMP_UD-${testname}-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -916,7 +926,7 @@ endmacro ()
 macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARGN})
+    add_test (NAME H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND $<TARGET_FILE:h5dump> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -927,7 +937,6 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
     add_test (
         NAME H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=--enable-error-stack=2;${ARGN};${urlscheme}://${urlpath}/${resultfile}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/S3TEST"
@@ -941,7 +950,7 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   endif ()
   set_tests_properties (H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES
       FIXTURES_REQUIRED h5dump_s3_proxy
-      ENVIRONMENT "${h5dump_s3tests_env}"
+      ENVIRONMENT "${h5dump_s3tests_env};${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/S3TEST
   )
   if ("H5DUMP_S3TEST-${resultfile}_${urlscheme}_${credtype}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -955,7 +964,7 @@ endmacro ()
 ##############################################################################
 ##############################################################################
 
-ADD_HELP_TEST(help 0 -h)
+ADD_HELP_TEST (help 0 -h)
 
 # test data output redirection
 #ADD_H5_TEST (tnoddl RESULT_CODE RESULT_CODE 0 --enable-error-stack -O -y TARGET_FILE packedbits.h5)
@@ -1448,10 +1457,10 @@ if (HDF5_ENABLE_ROS3_VFD_DOCKER_PROXY)
   # AWS_PROFILE is set in order to use the correct testing
   # credentials created in CMakeTests.cmake
   set (h5dump_s3tests_env
-    "AWS_ENDPOINT_URL=http://localhost:${h5dump_s3tests_port}"
+      "AWS_ENDPOINT_URL=http://localhost:${h5dump_s3tests_port}"
-    "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
+      "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
-    "AWS_REGION=us-east-2"
+      "AWS_REGION=us-east-2"
-    "AWS_PROFILE=ros3_vfd_test"
+      "AWS_PROFILE=ros3_vfd_test"
   )
 
   add_test (

tools/test/h5dump/CMakeTestsPBITS.cmake

@@ -82,13 +82,13 @@ set (HDF5_REFERENCE_TEST_PBITS
 )
 
 foreach (pbits_h5_file ${HDF5_REFERENCE_TEST_PBITS})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${pbits_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/pbits/${pbits_h5_file}" "h5dump_pbits_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${pbits_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/pbits/${pbits_h5_file}" "h5dump_pbits_files")
 endforeach ()
 
 foreach (ddl_pbits ${HDF5_REFERENCE_PBITS})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/pbits/${ddl_pbits}" "${PROJECT_BINARY_DIR}/testfiles/pbits/${ddl_pbits}" "h5dump_pbits_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/pbits/${ddl_pbits}" "${PROJECT_BINARY_DIR}/testfiles/pbits/${ddl_pbits}" "h5dump_pbits_files")
 endforeach ()
-add_custom_target(h5dump_pbits_files ALL COMMENT "Copying files needed by h5dump_pbits tests" DEPENDS ${h5dump_pbits_files_list})
+add_custom_target (h5dump_pbits_files ALL COMMENT "Copying files needed by h5dump_pbits tests" DEPENDS ${h5dump_pbits_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -99,7 +99,7 @@ add_custom_target(h5dump_pbits_files ALL COMMENT "Copying files needed by h5dump
 macro (ADD_H5_PBITS_TEST resultfile resultcode result_errcheck)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARGN})
+    add_test (NAME H5DUMP-${resultfile} COMMAND $<TARGET_FILE:h5dump> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5DUMP-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -108,7 +108,6 @@ macro (ADD_H5_PBITS_TEST resultfile resultcode result_errcheck)
       add_test (
           NAME H5DUMP-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/pbits"
@@ -122,7 +121,6 @@ macro (ADD_H5_PBITS_TEST resultfile resultcode result_errcheck)
       add_test (
           NAME H5DUMP-${resultfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/pbits"
@@ -134,6 +132,7 @@ macro (ADD_H5_PBITS_TEST resultfile resultcode result_errcheck)
     endif ()
   endif ()
   set_tests_properties (H5DUMP-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/pbits"
   )
   if ("H5DUMP-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/test/h5dump/CMakeTestsVDS.cmake

@@ -82,18 +82,18 @@ set (HDF5_REFERENCE_PREFIX_VDS
 )
 
 foreach (vds_h5_file ${HDF5_REFERENCE_TEST_VDS})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${vds_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/vds/${vds_h5_file}" "h5dump_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${vds_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/vds/${vds_h5_file}" "h5dump_vds_files")
 endforeach ()
 
 foreach (vds_h5_file ${HDF5_REFERENCE_PREFIX_VDS})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${vds_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${vds_h5_file}" "h5dump_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${vds_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${vds_h5_file}" "h5dump_vds_files")
 endforeach ()
 
 foreach (ddl_vds ${HDF5_REFERENCE_VDS})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/vds/${ddl_vds}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${ddl_vds}" "h5dump_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/vds/${ddl_vds}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${ddl_vds}" "h5dump_vds_files")
 endforeach ()
 
-add_custom_target(h5dump_vds_files ALL COMMENT "Copying files needed by h5dump_vds tests" DEPENDS ${h5dump_vds_files_list})
+add_custom_target (h5dump_vds_files ALL COMMENT "Copying files needed by h5dump_vds tests" DEPENDS ${h5dump_vds_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -104,7 +104,7 @@ add_custom_target(h5dump_vds_files ALL COMMENT "Copying files needed by h5dump_v
 macro (ADD_H5_VDS_TEST resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARGN})
+    add_test (NAME H5DUMP-${resultfile} COMMAND $<TARGET_FILE:h5dump> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5DUMP-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -112,7 +112,6 @@ macro (ADD_H5_VDS_TEST resultfile resultcode)
     add_test (
         NAME H5DUMP-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/vds"
@@ -123,6 +122,7 @@ macro (ADD_H5_VDS_TEST resultfile resultcode)
     )
   endif ()
   set_tests_properties (H5DUMP-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds"
   )
   if ("H5DUMP-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -133,9 +133,9 @@ endmacro ()
 macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP_PREFIX-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> ${ARGN})
+    add_test (NAME H5DUMP_PREFIX-${resultfile} COMMAND $<TARGET_FILE:h5dump> ${ARGN})
     set_tests_properties (H5DUMP_PREFIX-${resultfile} PROPERTIES
-        ENVIRONMENT "HDF5_VDS_PREFIX=${PROJECT_BINARY_DIR}/testfiles/vds/"
+        ENVIRONMENT "HDF5_VDS_PREFIX=${PROJECT_BINARY_DIR}/testfiles/vds/;${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds/prefix"
     )
     if (${resultcode})
@@ -148,7 +148,6 @@ macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
     add_test (
         NAME H5DUMP_PREFIX-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/vds/prefix"
@@ -159,6 +158,7 @@ macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
             -D "TEST_ENV_VALUE=${PROJECT_BINARY_DIR}/testfiles/vds/"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
+    set_tests_properties (H5DUMP_PREFIX-${resultfile} PROPERTIES ENVIRONMENT "${CROSSCOMPILING_PATH}")
   endif ()
   if ("H5DUMP_PREFIX-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5DUMP_PREFIX-${resultfile} PROPERTIES DISABLED true)
@@ -168,8 +168,11 @@ endmacro ()
 macro (ADD_H5_VDS_LAYOUT resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> -p ${ARGN})
+    add_test (NAME H5DUMP-${resultfile} COMMAND $<TARGET_FILE:h5dump> -p ${ARGN})
-    set_tests_properties (H5DUMP-${resultfile} PROPERTIES WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds")
+    set_tests_properties (H5DUMP-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds"
+    )
     if (${resultcode})
       set_tests_properties (H5DUMP-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -180,7 +183,6 @@ macro (ADD_H5_VDS_LAYOUT resultfile resultcode)
     add_test (
         NAME H5DUMP-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-p;${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/vds"
@@ -189,6 +191,7 @@ macro (ADD_H5_VDS_LAYOUT resultfile resultcode)
             -D "TEST_REFERENCE=${resultfile}.ddl"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
+    set_tests_properties (H5DUMP-${resultfile} PROPERTIES ENVIRONMENT "${CROSSCOMPILING_PATH}")
   endif ()
   if ("H5DUMP-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5DUMP-${resultfile} PROPERTIES DISABLED true)

tools/test/h5dump/CMakeTestsXML.cmake

@@ -155,17 +155,17 @@ set (HDF5_XML_REFERENCE_FILES
 )
 
 foreach (tst_xml_h5_file ${HDF5_XML_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_xml_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xml_h5_file}" "h5dump_xml_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${tst_xml_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xml_h5_file}" "h5dump_xml_files")
 endforeach ()
 
 foreach (tst_xmlonly_h5_file ${HDF5_XML_REFERENCE_ONLY_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/xml/${tst_xmlonly_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xmlonly_h5_file}" "h5dump_xml_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/xml/${tst_xmlonly_h5_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xmlonly_h5_file}" "h5dump_xml_files")
 endforeach ()
 
 foreach (tst_xml_other_file ${HDF5_XML_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/xml/${tst_xml_other_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xml_other_file}" "h5dump_xml_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/xml/${tst_xml_other_file}" "${PROJECT_BINARY_DIR}/testfiles/xml/${tst_xml_other_file}" "h5dump_xml_files")
 endforeach ()
-add_custom_target(h5dump_xml_files ALL COMMENT "Copying files needed by h5dump_xml tests" DEPENDS ${h5dump_xml_files_list})
+add_custom_target (h5dump_xml_files ALL COMMENT "Copying files needed by h5dump_xml tests" DEPENDS ${h5dump_xml_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -189,7 +189,7 @@ endmacro ()
 
 macro (ADD_XML_H5_TEST resultfile resultcode)
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5DUMP_XML-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dump> --xml ${ARGN})
+    add_test (NAME H5DUMP_XML-${resultfile} COMMAND $<TARGET_FILE:h5dump> --xml ${ARGN})
     if (${resultcode})
       set_tests_properties (H5DUMP_XML-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -197,7 +197,6 @@ macro (ADD_XML_H5_TEST resultfile resultcode)
     add_test (
         NAME H5DUMP_XML-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=--xml;${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/xml"
@@ -208,6 +207,7 @@ macro (ADD_XML_H5_TEST resultfile resultcode)
     )
   endif ()
   set_tests_properties (H5DUMP_XML-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/xml"
   )
   if ("H5DUMP_XML-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/test/h5dump/CMakeVFDTests.cmake

@@ -15,60 +15,60 @@
 ###           T E S T I N G                                                ###
 ##############################################################################
 ##############################################################################
-H5_CREATE_VFD_DIR()
+H5_CREATE_VFD_DIR ()
 
 # --------------------------------------------------------------------
 # Copy all the HDF5 files from the source directory into the test directory
 # --------------------------------------------------------------------
 set (HDF5_VFD_H5DUMP_FILES
-  packedbits
+    packedbits
 )
 
 set (HDF5_SF_VFD_H5DUMP_FILES
-  test_subfiling_stripe_sizes.h5
+    test_subfiling_stripe_sizes.h5
 )
 
 set (HDF5_SF2_VFD_H5DUMP_FILES
-  test_subfiling_precreate_rank_0.h5
+    test_subfiling_precreate_rank_0.h5
 )
 
 foreach (vfdtest ${VFD_LIST})
   if (vfdtest STREQUAL "subfiling")
     foreach (h5_tfile ${HDF5_SF_VFD_H5DUMP_FILES})
-      file(COPY "${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}" DESTINATION "${PROJECT_BINARY_DIR}/${vfdtest}")
+      file (COPY "${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}" DESTINATION "${PROJECT_BINARY_DIR}/${vfdtest}")
-      execute_process(
+      execute_process (
-        COMMAND ls -i ${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}
+          COMMAND ls -i ${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}
-        OUTPUT_VARIABLE OUTPUT_VALUE
+          OUTPUT_VARIABLE OUTPUT_VALUE
-        OUTPUT_STRIP_TRAILING_WHITESPACE
+          OUTPUT_STRIP_TRAILING_WHITESPACE
       )
-      string(REGEX MATCH "^ *([0-9]+) *" INODE_VALUE "${OUTPUT_VALUE}")
+      string (REGEX MATCH "^ *([0-9]+) *" INODE_VALUE "${OUTPUT_VALUE}")
-      string(STRIP ${INODE_VALUE} INODE_STR)
+      string (STRIP ${INODE_VALUE} INODE_STR)
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_1_of_1" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_1_of_1" "HDF5_SF_VFD_H5DUMP_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_1_of_1" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_1_of_1" "HDF5_SF_VFD_H5DUMP_files")
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile.config" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}.config" "HDF5_SF_VFD_H5DUMP_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile.config" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}.config" "HDF5_SF_VFD_H5DUMP_files")
     endforeach ()
     foreach (h5_tfile ${HDF5_SF2_VFD_H5DUMP_FILES})
-      file(COPY "${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}" DESTINATION "${PROJECT_BINARY_DIR}/${vfdtest}")
+      file (COPY "${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}" DESTINATION "${PROJECT_BINARY_DIR}/${vfdtest}")
-      execute_process(
+      execute_process (
-        COMMAND ls -i ${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}
+          COMMAND ls -i ${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}
-        OUTPUT_VARIABLE OUTPUT_VALUE
+          OUTPUT_VARIABLE OUTPUT_VALUE
-        OUTPUT_STRIP_TRAILING_WHITESPACE
+          OUTPUT_STRIP_TRAILING_WHITESPACE
       )
-      string(REGEX MATCH "^ *([0-9]+) *" INODE_VALUE "${OUTPUT_VALUE}")
+      string (REGEX MATCH "^ *([0-9]+) *" INODE_VALUE "${OUTPUT_VALUE}")
-      string(STRIP ${INODE_VALUE} INODE_STR)
+      string (STRIP ${INODE_VALUE} INODE_STR)
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_1_of_2" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_1_of_2" "HDF5_SF2_VFD_H5DUMP_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_1_of_2" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_1_of_2" "HDF5_SF2_VFD_H5DUMP_files")
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_2_of_2" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_2_of_2" "HDF5_SF2_VFD_H5DUMP_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile_2_of_2" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}_2_of_2" "HDF5_SF2_VFD_H5DUMP_files")
-      HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile.config" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}.config" "HDF5_SF2_VFD_H5DUMP_files")
+      HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.subfile.config" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.subfile_${INODE_STR}.config" "HDF5_SF2_VFD_H5DUMP_files")
     endforeach ()
   endif ()
   foreach (h5_tfile ${HDF5_VFD_H5DUMP_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.h5" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.h5" "HDF5_VFD_H5DUMP_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_tfile}.h5" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.h5" "HDF5_VFD_H5DUMP_files")
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${h5_tfile}.ddl" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.ddl" "HDF5_VFD_H5DUMP_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/expected/${h5_tfile}.ddl" "${PROJECT_BINARY_DIR}/${vfdtest}/${h5_tfile}.ddl" "HDF5_VFD_H5DUMP_files")
   endforeach ()
 endforeach ()
 
-add_custom_target(HDF5_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_VFD_H5DUMP tests" DEPENDS ${HDF5_VFD_H5DUMP_files_list})
+add_custom_target (HDF5_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_VFD_H5DUMP tests" DEPENDS ${HDF5_VFD_H5DUMP_files_list})
-add_custom_target(HDF5_SF_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_SF_VFD_H5DUMP tests" DEPENDS ${HDF5_SF_VFD_H5DUMP_files_list})
+add_custom_target (HDF5_SF_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_SF_VFD_H5DUMP tests" DEPENDS ${HDF5_SF_VFD_H5DUMP_files_list})
-add_custom_target(HDF5_SF2_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_SF2_VFD_H5DUMP tests" DEPENDS ${HDF5_SF2_VFD_H5DUMP_files_list})
+add_custom_target (HDF5_SF2_VFD_H5DUMP_files ALL COMMENT "Copying files needed by HDF5_SF2_VFD_H5DUMP tests" DEPENDS ${HDF5_SF2_VFD_H5DUMP_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -81,7 +81,6 @@ macro (ADD_VFD_H5DUMP_TEST vfdname resultfile resultcode)
     add_test (
         NAME H5DUMP_VFD-${vfdname}-${resultfile}-h5dump
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_VFD:STRING=${vfdname}"
@@ -91,7 +90,10 @@ macro (ADD_VFD_H5DUMP_TEST vfdname resultfile resultcode)
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/${vfdname}"
             -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
     )
-    set_tests_properties (H5DUMP_VFD-${vfdname}-${resultfile}-h5dump PROPERTIES TIMEOUT ${CTEST_SHORT_TIMEOUT})
+    set_tests_properties (H5DUMP_VFD-${vfdname}-${resultfile}-h5dump PROPERTIES
+        TIMEOUT ${CTEST_SHORT_TIMEOUT}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("H5DUMP_VFD-${vfdname}-${resultfile}-h5dump" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5DUMP_VFD-${vfdname}-${resultfile}-h5dump PROPERTIES DISABLED true)
     endif ()

tools/test/h5format_convert/CMakeTests.cmake

@@ -73,20 +73,20 @@ set (HDF5_REFERENCE_TEST_FILES
 )
 
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
-add_custom_target(h5fc-files ALL COMMENT "Copying files needed by h5fc tests")
+add_custom_target (h5fc-files ALL COMMENT "Copying files needed by h5fc tests")
 
 foreach (ddl_file ${HDF5_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5format_convert/expected/${ddl_file}" "${PROJECT_BINARY_DIR}/testfiles/${ddl_file}" "h5fc_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5format_convert/expected/${ddl_file}" "${PROJECT_BINARY_DIR}/testfiles/${ddl_file}" "h5fc_files")
 endforeach ()
 
 foreach (h5_file ${HDF5_REFERENCE_ERR_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5format_convert/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5fc_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5format_convert/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5fc_files")
 endforeach ()
 
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5fc_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5fc_files")
 endforeach ()
-add_custom_target(h5fc_files ALL COMMENT "Copying files needed by h5fc tests" DEPENDS ${h5fc_files_list})
+add_custom_target (h5fc_files ALL COMMENT "Copying files needed by h5fc tests" DEPENDS ${h5fc_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -112,7 +112,6 @@ macro (ADD_H5_OUTPUT testname resultfile resultcode testfile)
       add_test (
           NAME H5FC-${testname}-${testfile}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
               -D "TEST_ARGS=${ARGN};${testname}-tmp.h5"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -123,6 +122,7 @@ macro (ADD_H5_OUTPUT testname resultfile resultcode testfile)
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
       set_tests_properties (H5FC-${testname}-${testfile} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           DEPENDS H5FC-${testname}-${testfile}-tmpfile
       )
       if ("H5FC-${testname}-${testfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -133,7 +133,6 @@ macro (ADD_H5_OUTPUT testname resultfile resultcode testfile)
       add_test (
           NAME H5FC-${testname}-${testfile}-NA
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
               -D "TEST_ARGS=${ARGN}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -143,6 +142,7 @@ macro (ADD_H5_OUTPUT testname resultfile resultcode testfile)
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
       set_tests_properties (H5FC-${testname}-${testfile}-NA PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           DEPENDS H5FC-${testname}-${testfile}-tmpfile
       )
       if ("H5FC-${testname}-${testfile}-NA" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -176,7 +176,6 @@ macro (ADD_H5_NOERR_OUTPUT testname resultfile resultcode testfile)
     add_test (
         NAME H5FC-${testname}-${testfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
             -D "TEST_ARGS=${ARGN};${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -186,6 +185,7 @@ macro (ADD_H5_NOERR_OUTPUT testname resultfile resultcode testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5FC-${testname}-${testfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5FC-${testname}-${testfile}-tmpfile
     )
     if ("H5FC-${testname}-${testfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -218,7 +218,6 @@ macro (ADD_H5_MASK_OUTPUT testname resultfile resultcode result_errcheck testfil
     add_test (
         NAME H5FC-${testname}-${testfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
             -D "TEST_ARGS=${ARGN};${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -229,6 +228,7 @@ macro (ADD_H5_MASK_OUTPUT testname resultfile resultcode result_errcheck testfil
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5FC-${testname}-${testfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5FC-${testname}-${testfile}-tmpfile
     )
     if ("H5FC-${testname}-${testfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -273,7 +273,6 @@ macro (ADD_H5_TEST testname resultcode testfile)
     add_test (
         NAME H5FC-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
             -D "TEST_ARGS=${ARGN};./testfiles/${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -284,6 +283,7 @@ macro (ADD_H5_TEST testname resultcode testfile)
     )
     set_tests_properties (H5FC-${testname} PROPERTIES
         DEPENDS "H5FC-${testname}-tmpfile"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         FIXTURES_REQUIRED clear_H5FC-${testname}
     )
     if ("H5FC-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -297,10 +297,11 @@ macro (ADD_H5_CHECK_IDX dependtest testname)
   if (NOT HDF5_ENABLE_USING_MEMCHECKER)
     add_test (
         NAME H5FC_CHECK_IDX-${dependtest}-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5fc_chk_idx> ./testfiles/${dependtest}-tmp.h5 ${ARGN}
+        COMMAND $<TARGET_FILE:h5fc_chk_idx> ./testfiles/${dependtest}-tmp.h5 ${ARGN}
     )
     set_tests_properties (H5FC_CHECK_IDX-${dependtest}-${testname} PROPERTIES
         DEPENDS "H5FC-${dependtest}"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         FIXTURES_REQUIRED clear_H5FC-${dependtest}
     )
     if ("H5FC_CHECK_IDX-${dependtest}-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -327,7 +328,6 @@ macro (ADD_H5_TEST_CHECK_IDX testname resultcode testfile)
     add_test (
         NAME H5FC_TEST_CHECK_IDX-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
             -D "TEST_ARGS=-d;${ARGN};./testfiles/${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -337,6 +337,7 @@ macro (ADD_H5_TEST_CHECK_IDX testname resultcode testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5FC_TEST_CHECK_IDX-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5FC_TEST_CHECK_IDX-${testname}-tmpfile"
     )
     if ("H5FC_TEST_CHECK_IDX-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -344,9 +345,10 @@ macro (ADD_H5_TEST_CHECK_IDX testname resultcode testfile)
     endif ()
     add_test (
         NAME H5FC_TEST_CHECK_IDX-${testname}-check
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5fc_chk_idx> ./testfiles/${testname}-tmp.h5 ${ARGN}
+        COMMAND $<TARGET_FILE:h5fc_chk_idx> ./testfiles/${testname}-tmp.h5 ${ARGN}
     )
     set_tests_properties (H5FC_TEST_CHECK_IDX-${testname}-check PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5FC_TEST_CHECK_IDX-${testname}"
     )
     if ("H5FC_TEST_CHECK_IDX-${testname}-check" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -381,7 +383,6 @@ macro (ADD_H5_H5DUMP_CHECK testname)
     add_test (
         NAME H5FC_H5DUMP_CHECK-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5format_convert>"
             -D "TEST_ARGS=${ARGN};./testfiles/${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -391,6 +392,7 @@ macro (ADD_H5_H5DUMP_CHECK testname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5FC_H5DUMP_CHECK-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5FC_H5DUMP_CHECK-${testname}-tmpfile"
     )
     if ("H5FC_H5DUMP_CHECK-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -399,7 +401,6 @@ macro (ADD_H5_H5DUMP_CHECK testname)
     add_test (
         NAME H5FC_H5DUMP_CHECK-${testname}-dump
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-BH;${testname}-tmp.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -409,6 +410,7 @@ macro (ADD_H5_H5DUMP_CHECK testname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5FC_H5DUMP_CHECK-${testname}-dump PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5FC_H5DUMP_CHECK-${testname}"
     )
     if ("H5FC_H5DUMP_CHECK-${testname}-dump" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/test/h5import/CMakeTests.cmake

@@ -76,25 +76,25 @@ set (HDF5_TOOLS_TEST_FILES
 
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 foreach (conf_file ${HDF5_REFERENCE_CONF_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${conf_file}" "${PROJECT_BINARY_DIR}/testfiles/${conf_file}" "h5import_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${conf_file}" "${PROJECT_BINARY_DIR}/testfiles/${conf_file}" "h5import_files")
 endforeach ()
 
 foreach (txt_file ${HDF5_REFERENCE_TXT_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5import_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5import_files")
 endforeach ()
 
 foreach (txt_file ${HDF5_REFERENCE_DDL_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5import_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5import/testfiles/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5import_files")
 endforeach ()
 
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5import_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5import_files")
 endforeach ()
 
 foreach (h5_file ${HDF5_TOOLS_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5import_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5import_files")
 endforeach ()
-add_custom_target(h5import_files ALL COMMENT "Copying files needed by h5import tests" DEPENDS ${h5import_files_list})
+add_custom_target (h5import_files ALL COMMENT "Copying files needed by h5import tests" DEPENDS ${h5import_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -113,8 +113,9 @@ macro (ADD_H5_TEST testname importfile conffile testfile)
       FIXTURES_REQUIRED set_h5importtest
   )
 
-  add_test (NAME H5IMPORT-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5import> ${importfile} -c ${conffile} -o ${testfile})
+  add_test (NAME H5IMPORT-${testname} COMMAND $<TARGET_FILE:h5import> ${importfile} -c ${conffile} -o ${testfile})
   set_tests_properties (H5IMPORT-${testname} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       DEPENDS H5IMPORT-${testname}-clear-objects
       FIXTURES_REQUIRED set_h5importtest
   )
@@ -126,7 +127,6 @@ macro (ADD_H5_TEST testname importfile conffile testfile)
     add_test (
         NAME H5IMPORT-${testname}-H5DMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -138,6 +138,7 @@ macro (ADD_H5_TEST testname importfile conffile testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT-${testname}-H5DMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5IMPORT-${testname}
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -147,7 +148,6 @@ macro (ADD_H5_TEST testname importfile conffile testfile)
     add_test (
         NAME H5IMPORT-${testname}-H5DMP_CMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=testfiles/${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -158,6 +158,7 @@ macro (ADD_H5_TEST testname importfile conffile testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT-${testname}-H5DMP_CMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5IMPORT-${testname}-H5DMP
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -197,7 +198,6 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
       add_test (
           NAME H5IMPORT-DUMP-${testname}-H5DMP
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=-p;-d;${datasetname};-o;d${testfile}.bin;-b;NATIVE;testfiles/${testfile}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -211,7 +211,6 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
       add_test (
           NAME H5IMPORT-DUMP-${testname}-H5DMP
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=-p;-d;${datasetname};-o;d${testfile}.bin;-y;--width=1;testfiles/${testfile}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -223,6 +222,7 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
       )
     endif ()
     set_tests_properties (H5IMPORT-DUMP-${testname}-H5DMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT-DUMP-${testname}-clear-objects"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -233,7 +233,6 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
     add_test (
         NAME H5IMPORT-DUMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5import>"
             -D "TEST_ARGS:STRING=d${testfile}.bin;-c;d${testfile}.dmp;-o;d${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -243,6 +242,7 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT-DUMP-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT-DUMP-${testname}-H5DMP"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -253,7 +253,6 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
     add_test (
         NAME H5IMPORT-DUMP-${testname}-H5DFF
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
             -D "TEST_ARGS:STRING=-r;d${testfile};testfiles/${testfile};${datasetname};${datasetname}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -264,6 +263,7 @@ macro (ADD_H5_DUMPTEST testname datasetname testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT-DUMP-${testname}-H5DFF PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT-DUMP-${testname}"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -302,7 +302,6 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
     add_test (
         NAME H5IMPORT_SUB-DUMP-${testname}-H5DMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-p;-d;${datasetname};${ARGN};-o;ds${testname}.bin;-b;NATIVE;testfiles/${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -313,6 +312,7 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT_SUB-DUMP-${testname}-H5DMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT_SUB-DUMP-${testname}-clear-objects"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -323,7 +323,6 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
     add_test (
         NAME H5IMPORT_SUB-DUMP-${testname}-H5IMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5import>"
             -D "TEST_ARGS:STRING=ds${testname}.bin;-c;ds${testname}.dmp;-o;ds${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -333,6 +332,7 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT_SUB-DUMP-${testname}-H5IMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT_SUB-DUMP-${testname}-H5DMP"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -342,7 +342,6 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
     add_test (
         NAME H5IMPORT_SUB-DUMP-${testname}-CMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-p;ds${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -352,6 +351,7 @@ macro (ADD_H5_DUMPSUBTEST testname testfile datasetname)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5IMPORT_SUB-DUMP-${testname}-CMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS "H5IMPORT_SUB-DUMP-${testname}-H5IMP"
         FIXTURES_REQUIRED set_h5importtest
     )
@@ -379,7 +379,7 @@ macro (ADD_H5_SKIP_DUMPTEST testname datasetname testfile)
         NAME H5IMPORT-DUMP-${testname}
         COMMAND ${CMAKE_COMMAND} -E echo "SKIP ${testname} ${datasetname} ${testfile} --- DEFLATE filter not available"
     )
-    set_property(TEST H5IMPORT-DUMP-${testname} PROPERTY DISABLED true)
+    set_property (TEST H5IMPORT-DUMP-${testname} PROPERTY DISABLED true)
   endif ()
 endmacro ()
 
@@ -499,8 +499,9 @@ add_test (
     COMMAND ${CMAKE_COMMAND} -E remove ${H5IMPORTTEST_CLEANFILES}
 )
 
-add_test (NAME H5IMPORT-h5importtest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5importtest>)
+add_test (NAME H5IMPORT-h5importtest COMMAND $<TARGET_FILE:h5importtest>)
 set_tests_properties (H5IMPORT-h5importtest PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     FIXTURES_SETUP set_h5importtest
     DEPENDS H5IMPORT-h5importtest-clear-objects
 )

tools/test/h5jam/CMakeTests.cmake

@@ -33,13 +33,13 @@ set (HDF5_REFERENCE_TEST_FILES
 
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5jam_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5jam_files")
 endforeach ()
 
 foreach (txt_file ${HDF5_REFERENCE_TXT_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5jam/expected/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5jam_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5jam/expected/${txt_file}" "${PROJECT_BINARY_DIR}/testfiles/${txt_file}" "h5jam_files")
 endforeach ()
-add_custom_target(h5jam_files ALL COMMENT "Copying files needed by h5jam tests" DEPENDS ${h5jam_files_list})
+add_custom_target (h5jam_files ALL COMMENT "Copying files needed by h5jam tests" DEPENDS ${h5jam_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -54,7 +54,7 @@ add_custom_target(h5jam_files ALL COMMENT "Copying files needed by h5jam tests"
 macro (TEST_H5JAM_OUTPUT expectfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5JAM-${expectfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5jam> ${ARGN})
+    add_test (NAME H5JAM-${expectfile} COMMAND $<TARGET_FILE:h5jam> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5JAM-${expectfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -62,7 +62,6 @@ macro (TEST_H5JAM_OUTPUT expectfile resultcode)
     add_test (
         NAME H5JAM-${expectfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5jam>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -74,6 +73,9 @@ macro (TEST_H5JAM_OUTPUT expectfile resultcode)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
   endif ()
+  set_tests_properties (H5JAM-${expectfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
+  )
   if ("H5JAM-${expectfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5JAM-${expectfile} PROPERTIES DISABLED true)
   endif ()
@@ -86,7 +88,7 @@ endmacro ()
 macro (TEST_H5UNJAM_OUTPUT expectfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5JAM-UNJAM-${expectfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5unjam> ${ARGN})
+    add_test (NAME H5JAM-UNJAM-${expectfile} COMMAND $<TARGET_FILE:h5unjam> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5JAM-UNJAM-${expectfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -94,7 +96,6 @@ macro (TEST_H5UNJAM_OUTPUT expectfile resultcode)
     add_test (
         NAME H5JAM-UNJAM-${expectfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5unjam>"
             -D "TEST_ARGS=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -104,6 +105,9 @@ macro (TEST_H5UNJAM_OUTPUT expectfile resultcode)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
   endif ()
+  set_tests_properties (H5JAM-UNJAM-${expectfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
+  )
   if ("H5JAM-UNJAM-${expectfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5JAM-UNJAM-${expectfile} PROPERTIES DISABLED true)
   endif ()
@@ -115,7 +119,6 @@ macro (CHECKFILE testname testdepends expected actual)
     add_test (
         NAME H5JAM-${testname}-CHECKFILE-H5DMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=testfiles/${expected}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -128,11 +131,13 @@ macro (CHECKFILE testname testdepends expected actual)
     if ("H5JAM-${testname}-CHECKFILE-H5DMP" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP PROPERTIES DISABLED true)
     endif ()
-    set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP PROPERTIES DEPENDS ${testdepends})
+    set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP PROPERTIES
+        DEPENDS ${testdepends}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     add_test (
         NAME H5JAM-${testname}-CHECKFILE-H5DMP_CMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=${actual}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -145,9 +150,12 @@ macro (CHECKFILE testname testdepends expected actual)
     if ("H5JAM-${testname}-CHECKFILE-H5DMP_CMP" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP_CMP PROPERTIES DISABLED true)
     endif ()
-    set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP_CMP PROPERTIES DEPENDS H5JAM-${testname}-CHECKFILE-H5DMP)
+    set_tests_properties (H5JAM-${testname}-CHECKFILE-H5DMP_CMP PROPERTIES
+        DEPENDS H5JAM-${testname}-CHECKFILE-H5DMP
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
   endif ()
-endmacro()
+endmacro ()
 
 macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
   if (NOT HDF5_ENABLE_USING_MEMCHECKER)
@@ -171,15 +179,17 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
           COMMAND ${CMAKE_COMMAND} -E remove ${ufile}
       )
       set_tests_properties (H5JAM-${testname}-UNJAM_D-clear-objects PROPERTIES DEPENDS H5JAM-${testname}-UNJAM-clear-objects)
-      add_test (NAME H5JAM-${testname}-UNJAM COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5unjam> -i ${infile} -u ${ufile} -o ${outfile})
+      add_test (NAME H5JAM-${testname}-UNJAM COMMAND $<TARGET_FILE:h5unjam> -i ${infile} -u ${ufile} -o ${outfile})
-      set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES DEPENDS H5JAM-${testname}-UNJAM_D-clear-objects)
+      set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES
+          DEPENDS H5JAM-${testname}-UNJAM_D-clear-objects
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       set (compare_test ${ufile})
     else ()
       if (NOT "${ARGN}" STREQUAL "--delete")
         add_test (
             NAME H5JAM-${testname}-UNJAM
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:h5unjam>"
                 -D "TEST_ARGS:STRING=-i;${infile};-o;${outfile}"
                 -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -188,11 +198,17 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
                 -D "TEST_SKIP_COMPARE=TRUE"
                 -P "${HDF_RESOURCES_DIR}/runTest.cmake"
         )
-        set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES DEPENDS H5JAM-${testname}-UNJAM-clear-objects)
+        set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES
+            DEPENDS H5JAM-${testname}-UNJAM-clear-objects
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (compare_test "${outfile}.ufile.txt")
       else ()
-        add_test (NAME H5JAM-${testname}-UNJAM COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5unjam> -i ${infile} -o ${outfile})
+        add_test (NAME H5JAM-${testname}-UNJAM COMMAND $<TARGET_FILE:h5unjam> -i ${infile} -o ${outfile})
-        set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES DEPENDS H5JAM-${testname}-UNJAM-clear-objects)
+        set_tests_properties (H5JAM-${testname}-UNJAM PROPERTIES
+            DEPENDS H5JAM-${testname}-UNJAM-clear-objects
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        )
         set (compare_test "")
       endif ()
     endif ()
@@ -211,7 +227,6 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
       add_test (
           NAME H5JAM-${testname}-UNJAM-CHECK_UB_1
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:tellub>"
               -D "TEST_GET_PROGRAM=$<TARGET_FILE:getub>"
               -D "TEST_CHECKUB=YES"
@@ -222,7 +237,10 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
               -D "TEST_OFILE="
               -P "${HDF_RESOURCES_DIR}/userblockTest.cmake"
       )
-      set_tests_properties (H5JAM-${testname}-UNJAM-CHECK_UB_1 PROPERTIES DEPENDS H5JAM-${testname}-UNJAM-CHECK_UB_1-clear-objects)
+      set_tests_properties (H5JAM-${testname}-UNJAM-CHECK_UB_1 PROPERTIES
+          DEPENDS H5JAM-${testname}-UNJAM-CHECK_UB_1-clear-objects
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      )
       if ("H5JAM-${testname}-UNJAM-CHECK_UB_1" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
         set_tests_properties (H5JAM-${testname}-UNJAM-CHECK_UB_1 PROPERTIES DISABLED true)
       endif ()
@@ -231,7 +249,6 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
     add_test (
         NAME H5JAM-${testname}-UNJAM-CHECK_NOUB
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:tellub>"
             -D "TEST_GET_PROGRAM=$<TARGET_FILE:getub>"
             -D "TEST_CHECKUB=NO"
@@ -242,6 +259,9 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
             -D "TEST_OFILE=NULL"
             -P "${HDF_RESOURCES_DIR}/userblockTest.cmake"
     )
+    set_tests_properties (H5JAM-${testname}-UNJAM-CHECK_NOUB PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if (${compare_test})
       set_tests_properties (H5JAM-${testname}-UNJAM-CHECK_NOUB PROPERTIES DEPENDS H5JAM-${testname}-UNJAM-CHECK_UB_1)
     else ()
@@ -253,7 +273,7 @@ macro (UNJAMTEST testname setfile infile ufile chkfile outfile)
 
     CHECKFILE (${testname} "H5JAM-${testname}-UNJAM-CHECK_NOUB" ${chkfile} ${outfile})
   endif ()
-endmacro()
+endmacro ()
 
 macro (JAMTEST testname jamfile infile chkfile outfile)
   if (NOT HDF5_ENABLE_USING_MEMCHECKER)
@@ -262,7 +282,10 @@ macro (JAMTEST testname jamfile infile chkfile outfile)
         COMMAND ${CMAKE_COMMAND} -E remove ${outfile} ${infile}.cpy.h5
     )
   endif ()
-  add_test (NAME H5JAM-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5jam> -u testfiles/${jamfile} -i testfiles/${infile} -o ${outfile} ${ARGN})
+  add_test (NAME H5JAM-${testname} COMMAND $<TARGET_FILE:h5jam> -u testfiles/${jamfile} -i testfiles/${infile} -o ${outfile} ${ARGN})
+  set_tests_properties (H5JAM-${testname} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
+  )
   if ("H5JAM-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5JAM-${testname} PROPERTIES DISABLED true)
   endif ()
@@ -285,7 +308,6 @@ macro (JAMTEST testname jamfile infile chkfile outfile)
     add_test (
         NAME H5JAM-${testname}-CHECK_UB_1
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:tellub>"
             -D "TEST_GET_PROGRAM=$<TARGET_FILE:getub>"
             -D "TEST_CHECKUB=YES"
@@ -296,7 +318,10 @@ macro (JAMTEST testname jamfile infile chkfile outfile)
             -D "TEST_OFILE=${compare_orig}"
             -P "${HDF_RESOURCES_DIR}/userblockTest.cmake"
     )
-    set_tests_properties (H5JAM-${testname}-CHECK_UB_1 PROPERTIES DEPENDS H5JAM-${testname}-CHECK_UB_1-clear-objects)
+    set_tests_properties (H5JAM-${testname}-CHECK_UB_1 PROPERTIES
+        DEPENDS H5JAM-${testname}-CHECK_UB_1-clear-objects
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("H5JAM-${testname}-CHECK_UB_1" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5JAM-${testname}-CHECK_UB_1 PROPERTIES DISABLED true)
     endif ()
@@ -326,8 +351,11 @@ macro (JAMTEST_NONE testname jamfile infile setfile chkfile)
       set_tests_properties (H5JAM-${testname}_NONE_COPY PROPERTIES DISABLED true)
     endif ()
 
-    add_test (NAME H5JAM-${testname}_NONE COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5jam> -u testfiles/${jamfile} -i ${chkfile} ${ARGN})
+    add_test (NAME H5JAM-${testname}_NONE COMMAND $<TARGET_FILE:h5jam> -u testfiles/${jamfile} -i ${chkfile} ${ARGN})
-    set_tests_properties (H5JAM-${testname}_NONE PROPERTIES DEPENDS H5JAM-${testname}_NONE_COPY)
+    set_tests_properties (H5JAM-${testname}_NONE PROPERTIES
+        DEPENDS H5JAM-${testname}_NONE_COPY
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("H5JAM-${testname}_NONE" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5JAM-${testname}_NONE PROPERTIES DISABLED true)
     endif ()
@@ -349,7 +377,6 @@ macro (JAMTEST_NONE testname jamfile infile setfile chkfile)
     add_test (
         NAME H5JAM-${testname}_NONE-CHECK_UB_1
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:tellub>"
             -D "TEST_GET_PROGRAM=$<TARGET_FILE:getub>"
             -D "TEST_CHECKUB=YES"
@@ -360,7 +387,10 @@ macro (JAMTEST_NONE testname jamfile infile setfile chkfile)
             -D "TEST_OFILE=${compare_orig}"
             -P "${HDF_RESOURCES_DIR}/userblockTest.cmake"
     )
-    set_tests_properties (H5JAM-${testname}_NONE-CHECK_UB_1 PROPERTIES DEPENDS H5JAM-${testname}_NONE-CHECK_UB_1-clear-objects)
+    set_tests_properties (H5JAM-${testname}_NONE-CHECK_UB_1 PROPERTIES
+        DEPENDS H5JAM-${testname}_NONE-CHECK_UB_1-clear-objects
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+    )
     if ("H5JAM-${testname}_NONE-CHECK_UB_1" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5JAM-${testname}_NONE-CHECK_UB_1 PROPERTIES DISABLED true)
     endif ()
@@ -378,10 +408,10 @@ endmacro ()
 # Testing h5jam
 #-------------------------------
 # help page
-TEST_H5JAM_OUTPUT(h5jam-help 0 -h)
+TEST_H5JAM_OUTPUT (h5jam-help 0 -h)
 
 # don't allow HDF5 format file as an user block file
-TEST_H5JAM_OUTPUT(h5jam-ub-nohdf5 1 -i testfiles/tall.h5 -u testfiles/tall.h5 -o tall-tmp.h5)
+TEST_H5JAM_OUTPUT (h5jam-ub-nohdf5 1 -i testfiles/tall.h5 -u testfiles/tall.h5 -o tall-tmp.h5)
 
 JAMTEST (tall_u10 u10.txt tall.h5 tall.h5 ta2.h5)
 JAMTEST (tall_u511 u511.txt tall.h5 tall.h5 ta3.h5)
@@ -427,7 +457,7 @@ JAMTEST_NONE (N_twithub513_u513_c u513.txt tall.h5 twithub513.h5 tay9.h5 --clobb
 # Testing h5unjam
 #-------------------------------
 # help page
-TEST_H5UNJAM_OUTPUT(h5unjam-help 0 -h)
+TEST_H5UNJAM_OUTPUT (h5unjam-help 0 -h)
 
 UNJAMTEST (twithub_tall twithub.h5 tai1.h5 o10.txt tall.h5 taa1.h5)
 UNJAMTEST (twithub513_tall twithub513.h5 tai2.h5 o512.txt tall.h5 taa2.h5)

tools/test/h5ls/CMakeTests.cmake

@@ -149,78 +149,78 @@ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/S3TEST/testfiles")
 
 # copy the list of test files
 foreach (listlsfiles ${LIST_HDF5_TESTLS_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${listlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listlsfiles}" "h5ls_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${listlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listlsfiles}" "h5ls_files")
 endforeach ()
 if (H5_WORDS_BIGENDIAN)
   foreach (listendlsfiles ${LIST_HDF5_END_TESTLS_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/bigendian/${listendlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendlsfiles}" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/bigendian/${listendlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendlsfiles}" "h5ls_files")
   endforeach ()
 else ()
   foreach (listendlsfiles ${LIST_HDF5_END_TESTLS_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${listendlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendlsfiles}" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${listendlsfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendlsfiles}" "h5ls_files")
   endforeach ()
 endif ()
 foreach (listfiles ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listfiles}" "h5ls_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listfiles}" "h5ls_files")
 endforeach ()
 if (H5_WORDS_BIGENDIAN)
   foreach (listendfiles ${LIST_HDF5_END_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/bigendian/${listendfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendfiles}" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/bigendian/${listendfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendfiles}" "h5ls_files")
   endforeach ()
 else ()
   foreach (listendfiles ${LIST_HDF5_END_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${listendfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendfiles}" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${listendfiles}" "${PROJECT_BINARY_DIR}/testfiles/${listendfiles}" "h5ls_files")
   endforeach ()
 endif ()
 foreach (listothers ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/${listothers}" "h5ls_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/${listothers}" "h5ls_files")
 endforeach ()
 if (H5_WORDS_BIGENDIAN)
   foreach (listothersendian ${LIST_OTHER_TEST_FILES_END})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothersendian}BE.ls" "${PROJECT_BINARY_DIR}/testfiles/${listothersendian}.ls" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothersendian}BE.ls" "${PROJECT_BINARY_DIR}/testfiles/${listothersendian}.ls" "h5ls_files")
   endforeach ()
 else ()
   foreach (listothersendian ${LIST_OTHER_TEST_FILES_END})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothersendian}.ls" "${PROJECT_BINARY_DIR}/testfiles/${listothersendian}.ls" "h5ls_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5ls/expected/${listothersendian}.ls" "${PROJECT_BINARY_DIR}/testfiles/${listothersendian}.ls" "h5ls_files")
   endforeach ()
 endif ()
 foreach (lists3file ${H5LS_S3PROXY_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${lists3file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${lists3file}" "h5ls_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${lists3file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${lists3file}" "h5ls_files")
 endforeach ()
-add_custom_target(h5ls_files ALL COMMENT "Copying files needed by h5ls tests" DEPENDS ${h5ls_files_list})
+add_custom_target (h5ls_files ALL COMMENT "Copying files needed by h5ls tests" DEPENDS ${h5ls_files_list})
 
 # Generate testfiles for VOL connector(s) through script, if enabled
-set(h5ls_vol_files_list "")
+set (h5ls_vol_files_list "")
 foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
   HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} vol vol_env)
 
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles" RESULT)
   if (NOT ${RESULT} EQUAL 0)
-    message(FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${external_vol_tgt}/testfiles")
+    message (FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${external_vol_tgt}/testfiles")
-  endif()
+  endif ()
 
-  add_test(NAME ${external_vol_tgt}-h5lsgentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> --h5ls)
+  add_test (NAME ${external_vol_tgt}-h5lsgentest COMMAND $<TARGET_FILE:h5gentest> --h5ls)
   
-  set_tests_properties(${external_vol_tgt}-h5lsgentest PROPERTIES
+  set_tests_properties (${external_vol_tgt}-h5lsgentest PROPERTIES
-    ENVIRONMENT "${vol_env}"
+      ENVIRONMENT "${vol_env}"
-    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles"
-    FIXTURES_SETUP h5ls_vol_files
+      FIXTURES_SETUP h5ls_vol_files
   )
 
   foreach (listfiles ${LIST_HDF5_TEST_FILES_ALWAYS_COPY})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${listfiles}" "h5ls_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/testfiles/${listfiles}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${listfiles}" "h5ls_vol_files")
-  endforeach()
+  endforeach ()
 
   # These aren't HDF5 files, just copy them to the VOL's subdirectory
   foreach (listothers ${LIST_OTHER_TEST_FILES})
-    HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${listothers}"
+    HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${listothers}"
-    "${PROJECT_BINARY_DIR}/${vol}/testfiles/${listothers}"
+        "${PROJECT_BINARY_DIR}/${vol}/testfiles/${listothers}"
-    "h5ls_vol_files"
+        "h5ls_vol_files"
     )
   endforeach ()
 endforeach ()
-add_custom_target(h5ls_vol_files ALL COMMENT "Copying files needed by h5ls tests" DEPENDS ${h5ls_vol_files_list})
+add_custom_target (h5ls_vol_files ALL COMMENT "Copying files needed by h5ls tests" DEPENDS ${h5ls_vol_files_list})
 ##############################################################################
 ##############################################################################
 ###           T H E   T E S T S  M A C R O S                               ###
@@ -246,11 +246,11 @@ add_custom_target(h5ls_vol_files ALL COMMENT "Copying files needed by h5ls tests
 # SKIP_TEST - Skip this test.
 #
 macro (ADD_H5_TEST testname)
-  cmake_parse_arguments(ARG
+  cmake_parse_arguments (ARG
-    "WILL_FAIL;SKIP_TEST;NATIVE_ONLY" # flags
+      "WILL_FAIL;SKIP_TEST;NATIVE_ONLY" # flags
-    "RESULT_CODE;RESULT_ERRCHECK" # one-value args
+      "RESULT_CODE;RESULT_ERRCHECK" # one-value args
-    "" # multi-value args
+      "" # multi-value args
-    ${ARGN}
+      ${ARGN}
   )
 
   # Validate required parameters
@@ -259,25 +259,25 @@ macro (ADD_H5_TEST testname)
   endif ()
 
   if (${ARG_NATIVE_ONLY})
-    set(num_ext_vols 0)
+    set (num_ext_vols 0)
-  else()
+  else ()
-    list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+    list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
   endif ()
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
-      set(vol_workdir "${PROJECT_BINARY_DIR}/testfiles")
+      set (vol_workdir "${PROJECT_BINARY_DIR}/testfiles")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}/testfiles")
@@ -286,17 +286,12 @@ macro (ADD_H5_TEST testname)
 
     # If using memchecker add tests without using scripts
     if (HDF5_ENABLE_USING_MEMCHECKER)
-      add_test (NAME ${vol_prefix}H5LS-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5ls> ${ARG_UNPARSED_ARGUMENTS})
+      add_test (NAME ${vol_prefix}H5LS-${testname} COMMAND $<TARGET_FILE:h5ls> ${ARG_UNPARSED_ARGUMENTS})
-
-      if ("${ARG_RESULT_CODE}" STREQUAL "1")
-        set_tests_properties (${vol_prefix}H5LS-${testname} PROPERTIES WILL_FAIL "true")
-      endif ()
     else ()
       # Remove any output file left over from previous test run
       add_test (
           NAME ${vol_prefix}H5LS-${testname}
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
               -D "TEST_ARGS=${ARG_UNPARSED_ARGUMENTS}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -313,6 +308,7 @@ macro (ADD_H5_TEST testname)
     endif ()
 
     set_tests_properties (${vol_prefix}H5LS-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${vol_workdir}"
     )
 
@@ -322,16 +318,16 @@ macro (ADD_H5_TEST testname)
 
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5LS-${testname} PROPERTIES
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
-        FIXTURES_REQUIRED h5ls_vol_files
+          FIXTURES_REQUIRED h5ls_vol_files
       )
     endif ()
 
     if (${ARG_SKIP_TEST})
-      set_tests_properties( ${vol_prefix}H5LS-${testname} PROPERTIES DISABLED true)
+      set_tests_properties (${vol_prefix}H5LS-${testname} PROPERTIES DISABLED true)
-    endif()
+    endif ()
 
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_UD_TEST testname resultcode resultfile)
@@ -339,7 +335,6 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
     add_test (
         NAME H5LS_UD-${testname}-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
             -D "TEST_ARGS=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -352,6 +347,7 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5LS_UD-${testname}-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
     )
     if ("H5LS_UD-${testname}-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -363,10 +359,7 @@ endmacro ()
 macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5ls> ${ARGN})
+    add_test (NAME H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND $<TARGET_FILE:h5ls> ${ARGN})
-    set_tests_properties (H5LS-${resultfile}_${urlscheme}_${credtype} PROPERTIES
-        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/S3TEST"
-    )
     if ("${resultcode}" STREQUAL "1")
       set_tests_properties (H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -374,7 +367,6 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
     add_test (
         NAME H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
             -D "TEST_ARGS=--enable-error-stack;${ARGN};${urlscheme}://${urlpath}/${resultfile}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/S3TEST"
@@ -388,7 +380,7 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   endif ()
   set_tests_properties (H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES
       FIXTURES_REQUIRED h5ls_s3_proxy
-      ENVIRONMENT "${h5ls_s3tests_env}"
+      ENVIRONMENT "${h5ls_s3tests_env};${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/S3TEST
   )
   if ("H5LS_S3TEST-${resultfile}_${urlscheme}_${credtype}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -644,10 +636,10 @@ if (HDF5_ENABLE_ROS3_VFD_DOCKER_PROXY)
   # AWS_PROFILE is set in order to use the correct testing
   # credentials created in CMakeTests.cmake
   set (h5ls_s3tests_env
-    "AWS_ENDPOINT_URL=http://localhost:${h5ls_s3tests_port}"
+      "AWS_ENDPOINT_URL=http://localhost:${h5ls_s3tests_port}"
-    "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
+      "HDF5_ROS3_VFD_FORCE_PATH_STYLE=1"
-    "AWS_REGION=us-east-2"
+      "AWS_REGION=us-east-2"
-    "AWS_PROFILE=ros3_vfd_test"
+      "AWS_PROFILE=ros3_vfd_test"
   )
 
   add_test (

tools/test/h5ls/CMakeTestsVDS.cmake

@@ -58,22 +58,22 @@ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 
 # copy the list of test files
 foreach (listfiles ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/vds/${listfiles}" "h5ls_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/vds/${listfiles}" "h5ls_vds_files")
 endforeach ()
 
 foreach (listothers ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5ls/expected/vds/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/vds/${listothers}" "h5ls_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5ls/expected/vds/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/vds/${listothers}" "h5ls_vds_files")
 endforeach ()
 
 foreach (listfiles ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${listfiles}" "h5ls_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${listfiles}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${listfiles}" "h5ls_vds_files")
 endforeach ()
 
 foreach (listothers ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5ls/vds_prefix/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${listothers}" "h5ls_vds_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5ls/vds_prefix/${listothers}" "${PROJECT_BINARY_DIR}/testfiles/vds/prefix/${listothers}" "h5ls_vds_files")
 endforeach ()
 
-add_custom_target(h5ls_vds_files ALL COMMENT "Copying files needed by h5ls_vds tests" DEPENDS ${h5ls_vds_files_list})
+add_custom_target (h5ls_vds_files ALL COMMENT "Copying files needed by h5ls_vds tests" DEPENDS ${h5ls_vds_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -84,8 +84,7 @@ add_custom_target(h5ls_vds_files ALL COMMENT "Copying files needed by h5ls_vds t
 macro (ADD_H5_VDS_TEST resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5LS-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5ls> ${ARGN})
+    add_test (NAME H5LS-${resultfile} COMMAND $<TARGET_FILE:h5ls> ${ARGN})
-    set_tests_properties (H5LS-${resultfile} PROPERTIES WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds")
     if ("${resultcode}" STREQUAL "1")
       set_tests_properties (H5LS-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -93,7 +92,6 @@ macro (ADD_H5_VDS_TEST resultfile resultcode)
     add_test (
         NAME H5LS-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
             -D "TEST_ARGS=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles/vds"
@@ -103,6 +101,10 @@ macro (ADD_H5_VDS_TEST resultfile resultcode)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
   endif ()
+  set_tests_properties (H5LS-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles/vds"
+  )
   if ("H5LS-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5LS-${resultfile} PROPERTIES DISABLED true)
   endif ()
@@ -111,9 +113,9 @@ endmacro ()
 macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5LS_PREFIX-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5ls> ${ARGN})
+    add_test (NAME H5LS_PREFIX-${resultfile} COMMAND $<TARGET_FILE:h5ls> ${ARGN})
     set_tests_properties (H5LS_PREFIX-${resultfile} PROPERTIES
-        ENVIRONMENT "HDF5_VDS_PREFIX=\${ORIGIN}"
+        ENVIRONMENT "HDF5_VDS_PREFIX=\${ORIGIN};${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
     )
     if ("${resultcode}" STREQUAL "1")
@@ -123,7 +125,6 @@ macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
     add_test (
         NAME H5LS_PREFIX-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
             -D "TEST_ARGS=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -135,6 +136,10 @@ macro (ADD_H5_VDS_PREFIX_TEST resultfile resultcode)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
   endif ()
+    set_tests_properties (H5LS_PREFIX-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
+    )
   if ("H5LS_PREFIX-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
     set_tests_properties (H5LS_PREFIX-${resultfile} PROPERTIES DISABLED true)
   endif ()

tools/test/h5repack/CMakeTests.cmake

@@ -19,16 +19,16 @@
 # --------------------------------------------------------------------
 # Copy all the HDF5 files from the source directory into the test directory
 # --------------------------------------------------------------------
-set(LIST_REPACK_TEST_FILES
+set (LIST_REPACK_TEST_FILES
-  h5repack_f32le_ex-0.dat
+    h5repack_f32le_ex-0.dat
-  h5repack_int32le_1d_ex-0.dat
+    h5repack_int32le_1d_ex-0.dat
-  h5repack_int32le_1d_ex-1.dat
+    h5repack_int32le_1d_ex-1.dat
-  h5repack_int32le_2d_ex-0.dat
+    h5repack_int32le_2d_ex-0.dat
-  h5repack_int32le_3d_ex-0.dat
+    h5repack_int32le_3d_ex-0.dat
-  h5repack_uint8be_ex-0.dat
+    h5repack_uint8be_ex-0.dat
-  h5repack_uint8be_ex-1.dat
+    h5repack_uint8be_ex-1.dat
-  h5repack_uint8be_ex-2.dat
+    h5repack_uint8be_ex-2.dat
-  h5repack_uint8be_ex-3.dat
+    h5repack_uint8be_ex-3.dat
 )
 
 set (LIST_REPACK_HDF5_TEST_FILES
@@ -211,81 +211,81 @@ set (LIST_DDL_TEST_FILES
 )
 
 foreach (h5_file ${LIST_REPACK_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach(h5_file ${LIST_REPACK_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_COPY_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_DIFF_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_VDS_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/vds/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_HDF5_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_OTHER_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_TST_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
 
 foreach (h5_file ${LIST_DDL_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5repack_files")
 endforeach ()
-add_custom_target(h5repack_files ALL COMMENT "Copying files needed by h5repack tests" DEPENDS ${h5repack_files_list})
+add_custom_target (h5repack_files ALL COMMENT "Copying files needed by h5repack tests" DEPENDS ${h5repack_files_list})
 
 # Generate testfiles for VOL connector(s) through script
-set(h5repack_vol_files_list "")
+set (h5repack_vol_files_list "")
 
 foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
-  HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} vol vol_env)
+  HDF5_GET_VOL_TGT_INFO (${external_vol_tgt} vol vol_env)
 
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles" RESULT)
   if (NOT ${RESULT} EQUAL 0)
-    message(FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${vol}/testfiles")
+    message (FATAL_ERROR "Could not create directory ${PROJECT_BINARY_DIR}/${vol}/testfiles")
   endif()
 
-  add_test(NAME ${external_vol_tgt}-h5repackgentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5gentest> --h5repack)
+  add_test (NAME ${external_vol_tgt}-h5repackgentest COMMAND $<TARGET_FILE:h5gentest> --h5repack)
 
-  set_tests_properties(${external_vol_tgt}-h5repackgentest PROPERTIES
+  set_tests_properties (${external_vol_tgt}-h5repackgentest PROPERTIES
-    ENVIRONMENT "${vol_env}"
+      ENVIRONMENT "${vol_env}"
-    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles"
-    FIXTURES_SETUP h5repack_vol_files
+      FIXTURES_SETUP h5repack_vol_files
   )
 
   # These aren't HDF5 files, just copy them to the VOL's subdirectory
   foreach (test_file ${LIST_REPACK_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
-  endforeach()
+  endforeach ()
 
   foreach (test_file ${LIST_OTHER_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/testfiles/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
-  endforeach()
+  endforeach ()
 
   foreach (test_file ${LIST_TST_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
-  endforeach()
+  endforeach ()
 
   foreach (test_file ${LIST_DDL_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5repack/expected/${test_file}" "${PROJECT_BINARY_DIR}/${vol}/testfiles/${test_file}" "h5repack_vol_files")
-  endforeach()
+  endforeach ()
 endforeach ()
 
-add_custom_target(h5repack_vol_files ALL COMMENT "Copying files needed by h5repack tests" DEPENDS ${h5repack_vol_files_list})
+add_custom_target (h5repack_vol_files ALL COMMENT "Copying files needed by h5repack tests" DEPENDS ${h5repack_vol_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -296,12 +296,11 @@ add_custom_target(h5repack_vol_files ALL COMMENT "Copying files needed by h5repa
 macro (ADD_HELP_TEST testname resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5REPACK-h5repack-${testname} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${ARGN})
+    add_test (NAME H5REPACK-h5repack-${testname} COMMAND $<TARGET_FILE:h5repack> ${ARGN})
   else ()
     add_test (
         NAME H5REPACK-h5repack-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5repack>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -312,6 +311,7 @@ macro (ADD_HELP_TEST testname resultcode)
     )
   endif ()
   set_tests_properties (H5REPACK-h5repack-${testname} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
   )
   if ("H5REPACK-h5repack-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -348,20 +348,20 @@ endmacro ()
 #
 macro (ADD_H5_TEST testname)
   # === Argument handling ===
-  cmake_parse_arguments(ARG
+  cmake_parse_arguments (ARG
-    "ERROR_STACK;GZIP_FILTER;SIZE_FILTER;DUMP_CHECK;DUMP_NO_OPT;FULL_DIFF;STAT_CHECK;NATIVE_ONLY" # flags
+      "ERROR_STACK;GZIP_FILTER;SIZE_FILTER;DUMP_CHECK;DUMP_NO_OPT;FULL_DIFF;STAT_CHECK;NATIVE_ONLY" # flags
-    "TEST_TYPE;TEST_FILE;RESULT_CODE;DIFF_RESULT_CODE;ERR_REF;STAT_ARG;STAT_RESULT_CODE;LAYOUT_DSET;LAYOUT_FILTER" # single arg
+      "TEST_TYPE;TEST_FILE;RESULT_CODE;DIFF_RESULT_CODE;ERR_REF;STAT_ARG;STAT_RESULT_CODE;LAYOUT_DSET;LAYOUT_FILTER" # single arg
-    "" # multi arg
+      "" # multi arg
-    ${ARGN}
+      ${ARGN}
   )
 
   # Check for required arguments
   if (NOT ARG_TEST_TYPE)
-    message(FATAL_ERROR "ADD_H5_TEST: TEST_TYPE is a required argument")
+    message (FATAL_ERROR "ADD_H5_TEST: TEST_TYPE is a required argument")
   endif ()
 
   if (NOT ARG_TEST_FILE)
-    message(FATAL_ERROR "ADD_H5_TEST: TEST_FILE is a required argument")
+    message (FATAL_ERROR "ADD_H5_TEST: TEST_FILE is a required argument")
   endif ()
 
   # Default values for local variables
@@ -383,12 +383,12 @@ macro (ADD_H5_TEST testname)
   set (ARG_ERROR_STACK_FLAG "")
 
   # Whether to perform comparison in runTest or locally with h5diff
-  set(ARG_COMPARE_LOCAL true)
+  set (ARG_COMPARE_LOCAL true)
 
   if (${ARG_STAT_CHECK})
     if (NOT DEFINED ARG_STAT_ARG)
-      message(FATAL_ERROR "ADD_H5_TEST: STAT_ARG is a required argument when STAT_CHECK is provided")
+      message (FATAL_ERROR "ADD_H5_TEST: STAT_ARG is a required argument when STAT_CHECK is provided")
-    endif()
+    endif ()
 
     set (ARG_MAIN_OUT_FILE "out-${ARG_STAT_ARG}.${ARG_TEST_FILE}")
   else ()
@@ -397,19 +397,19 @@ macro (ADD_H5_TEST testname)
 
   # Process optional arguments
   if (ARG_ERROR_STACK)
-    set(ARG_ERROR_STACK_FLAG "--enable-error-stack")
+    set (ARG_ERROR_STACK_FLAG "--enable-error-stack")
   endif ()
 
   if (NOT DEFINED ARG_RESULT_CODE)
-    set(ARG_RESULT_CODE 0)
+    set (ARG_RESULT_CODE 0)
   endif ()
 
   if (NOT DEFINED ARG_DIFF_RESULT_CODE)
-    set(ARG_DIFF_RESULT_CODE 0)
+    set (ARG_DIFF_RESULT_CODE 0)
   endif ()
 
   if (NOT DEFINED ARG_STAT_RESULT_CODE)
-    set(ARG_STAT_RESULT_CODE 0)
+    set (ARG_STAT_RESULT_CODE 0)
   endif ()
 
   if (ARG_DUMP_NO_OPT)
@@ -418,11 +418,11 @@ macro (ADD_H5_TEST testname)
 
   if (DEFINED ARG_LAYOUT_DSET OR DEFINED ARG_LAYOUT_FILTER)
     if (NOT DEFINED ARG_LAYOUT_DSET OR NOT DEFINED ARG_LAYOUT_FILTER)
-      message(FATAL_ERROR "ADD_H5_TEST: Both LAYOUT_DSET and LAYOUT_FILTER must be provided for layout verification tests")
+      message (FATAL_ERROR "ADD_H5_TEST: Both LAYOUT_DSET and LAYOUT_FILTER must be provided for layout verification tests")
     endif ()
     
     if (${ARG_DUMP_CHECK})
-      message(FATAL_ERROR "ADD_H5_TEST: DUMP_CHECK cannot be used with layout verification tests")
+      message (FATAL_ERROR "ADD_H5_TEST: DUMP_CHECK cannot be used with layout verification tests")
     endif ()
 
     # Skip verify layout tests if memchecker enabled
@@ -439,7 +439,7 @@ macro (ADD_H5_TEST testname)
     # - change expected result code to 0
     # - change the layout filter provided to TEST_GREP_FILTER
     if (${ARG_RESULT_CODE})
-      set(ARG_DUMP_OPTIONS "-pH;")
+      set (ARG_DUMP_OPTIONS "-pH;")
 
       if (${ARG_LAYOUT_FILTER} STREQUAL "CHUNKED")
         set (ARG_NOT_LAYOUT_FILTER "(CONTIGUOUS|COMPACT)")
@@ -448,45 +448,45 @@ macro (ADD_H5_TEST testname)
       elseif (${ARG_LAYOUT_FILTER} STREQUAL "COMPACT")
         set (ARG_NOT_LAYOUT_FILTER "(CONTIGUOUS|CHUNK)")
       else ()
-        message(FATAL_ERROR "ADD_H5_TEST: Invalid LAYOUT_FILTER value ${ARG_LAYOUT_FILTER}. Must be CONTIGUOUS, CHUNKED, or COMPACT")
+        message (FATAL_ERROR "ADD_H5_TEST: Invalid LAYOUT_FILTER value ${ARG_LAYOUT_FILTER}. Must be CONTIGUOUS, CHUNKED, or COMPACT")
       endif ()
 
-      set(ARG_DUMP_GREP_FILTER ${ARG_NOT_LAYOUT_FILTER})
+      set (ARG_DUMP_GREP_FILTER ${ARG_NOT_LAYOUT_FILTER})
-      set(ARG_RESULT_CODE 0)
+      set (ARG_RESULT_CODE 0)
     else ()
       set (ARG_DUMP_OPTIONS "-d;${ARG_LAYOUT_DSET};-pH;")
       set (ARG_DUMP_GREP_FILTER ${ARG_LAYOUT_FILTER})
     endif ()
-  endif()
+  endif ()
 
   # Check for incompatible options
   if (${ARG_GZIP_FILTER} AND DEFINED ARG_ERR_REF)
-    message(FATAL_ERROR "ADD_H5_TEST: GZIP_FILTER and ERR_REF options are incompatible")
+    message (FATAL_ERROR "ADD_H5_TEST: GZIP_FILTER and ERR_REF options are incompatible")
   endif ()
   if (${ARG_FULL_DIFF} AND ${ARG_DUMP_CHECK})
-    message(FATAL_ERROR "ADD_H5_TEST: FULL_DIFF and DUMP_CHECK options are incompatible")
+    message (FATAL_ERROR "ADD_H5_TEST: FULL_DIFF and DUMP_CHECK options are incompatible")
   endif ()
   if (${ARG_STAT_CHECK} AND ${ARG_DUMP_CHECK})
-    message(FATAL_ERROR "ADD_H5_TEST: STAT_CHECK and DUMP_CHECK options are incompatible")
+    message (FATAL_ERROR "ADD_H5_TEST: STAT_CHECK and DUMP_CHECK options are incompatible")
   endif ()
 
   # not fundamentally incompatible, but at present this probably indicates a mistake in test setup
   if (${ARG_GZIP_FILTER} AND ${ARG_SIZE_FILTER})
-    message(FATAL_ERROR "ADD_H5_TEST: GZIP_FILTER and SIZE_FILTER options are incompatible")
+    message (FATAL_ERROR "ADD_H5_TEST: GZIP_FILTER and SIZE_FILTER options are incompatible")
   endif ()
 
   if (ARG_GZIP_FILTER)
-    list(APPEND ARG_FILTER_IN "GZIP   \\(0\\.[0-9][0-9][0-9]:1\\);O?...ing file[^\n]+\n")
+    list (APPEND ARG_FILTER_IN "GZIP   \\(0\\.[0-9][0-9][0-9]:1\\);O?...ing file[^\n]+\n")
-    list(APPEND ARG_FILTER_OUT "GZIP   (0.XXX:1);")
+    list (APPEND ARG_FILTER_OUT "GZIP   (0.XXX:1);")
-    set(ARG_REF_FILE "${ARG_TEST_FILE}-${testname}.tst")
+    set (ARG_REF_FILE "${ARG_TEST_FILE}-${testname}.tst")
-    set(base_testname "CMP-${base_testname}")
+    set (base_testname "CMP-${base_testname}")
     # Don't skip runTest comparison if we're using filters
-    set(ARG_COMPARE_LOCAL false)
+    set (ARG_COMPARE_LOCAL false)
   elseif (ARG_SIZE_FILTER)
-    list(APPEND ARG_FILTER_IN "SIZE [0-9][0-9][0-9][0-9] \\(2\\\.[0-9][0-9][0-9]:1 COMPRESSION\\)")
+    list (APPEND ARG_FILTER_IN "SIZE [0-9][0-9][0-9][0-9] \\(2\\\.[0-9][0-9][0-9]:1 COMPRESSION\\)")
-    list(APPEND ARG_FILTER_OUT "SIZE XXXX (2.XXX:1 COMPRESSION)")
+    list (APPEND ARG_FILTER_OUT "SIZE XXXX (2.XXX:1 COMPRESSION)")
     # Don't skip runTest comparison if we're using filters
-    set(ARG_COMPARE_LOCAL false)
+    set (ARG_COMPARE_LOCAL false)
   endif ()
 
   # Size/Offset within file will differ across VOL connectors
@@ -498,35 +498,35 @@ macro (ADD_H5_TEST testname)
   list (APPEND ARG_FILTER_OUT "SIZE XXXX")
 
   if (${ARG_DUMP_CHECK})
-    set(ARG_COMPARE_LOCAL false)
+    set (ARG_COMPARE_LOCAL false)
   endif ()
 
   if (${ARG_STAT_CHECK})
-    set(ARG_COMPARE_LOCAL false)
+    set (ARG_COMPARE_LOCAL false)
-  endif()
+  endif ()
 
   if (${ARG_NATIVE_ONLY})
-    set(num_ext_vols 0)
+    set (num_ext_vols 0)
-  else()
+  else ()
-    list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+    list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
-  endif()
+  endif ()
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_env "")
+      set (vol_env "${CROSSCOMPILING_PATH}")
-      set(vol_prefix "")
+      set (vol_prefix "")
       # Avoid names of the form XXX_BINARY_DIR due to collision risk
-      set(BINARY_DIR_VOL "${PROJECT_BINARY_DIR}")
+      set (BINARY_DIR_VOL "${PROJECT_BINARY_DIR}")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       # Avoid names of the form XXX_BINARY_DIR due to collision risk
@@ -550,7 +550,7 @@ macro (ADD_H5_TEST testname)
             NAME ${REPACK_TESTNAME}
             COMMAND ${CMAKE_COMMAND} -E echo "SKIP ${ARG_UNPARSED_ARGUMENTS} -i ${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE} -o ${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}"
         )
-        set_property(TEST ${REPACK_TESTNAME} PROPERTY DISABLED true)
+        set_property (TEST ${REPACK_TESTNAME} PROPERTY DISABLED true)
       endif ()
     else ()
       # Test is to be run
@@ -560,46 +560,49 @@ macro (ADD_H5_TEST testname)
       )
 
       set_tests_properties (${CLEAR_TESTNAME} PROPERTIES
-        WORKING_DIRECTORY "${BINARY_DIR_VOL}/testfiles"
+          WORKING_DIRECTORY "${BINARY_DIR_VOL}/testfiles"
-        FIXTURES_REQUIRED h5repack_vol_files
+          FIXTURES_REQUIRED h5repack_vol_files
       )
 
       # Build REPACK_TOOL_ARGS properly to avoid empty first argument
-      set(REPACK_TOOL_ARGS "")
+      set (REPACK_TOOL_ARGS "")
 
-      if(ARG_ERROR_STACK_FLAG)
+      if (ARG_ERROR_STACK_FLAG)
-        list(APPEND REPACK_TOOL_ARGS "${ARG_ERROR_STACK_FLAG}")
+        list (APPEND REPACK_TOOL_ARGS "${ARG_ERROR_STACK_FLAG}")
-      endif()
+      endif ()
 
-      if(ARG_UNPARSED_ARGUMENTS)
+      if (ARG_UNPARSED_ARGUMENTS)
-        list(APPEND REPACK_TOOL_ARGS "${ARG_UNPARSED_ARGUMENTS}")
+        list (APPEND REPACK_TOOL_ARGS "${ARG_UNPARSED_ARGUMENTS}")
-      endif()
+      endif ()
 
       if (HDF5_ENABLE_USING_MEMCHECKER OR ${ARG_DUMP_CHECK})
         # Execute h5repack directly - append absolute paths
-        list(APPEND REPACK_TOOL_ARGS "-i;${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE};-o;${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}")
+        list (APPEND REPACK_TOOL_ARGS "-i;${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE};-o;${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}")
 
         add_test (
             NAME ${REPACK_TESTNAME}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${REPACK_TOOL_ARGS}
+            COMMAND $<TARGET_FILE:h5repack> ${REPACK_TOOL_ARGS}
         )
 
         if (NOT "${vol}" STREQUAL "native")
-          set_tests_properties(${REPACK_TESTNAME} PROPERTIES
+          set_tests_properties (${REPACK_TESTNAME} PROPERTIES
               ENVIRONMENT "${vol_env}"
               WORKING_DIRECTORY "${BINARY_DIR_VOL}/testfiles"
               FIXTURES_REQUIRED h5repack_vol_files
           )
-        endif()
+        else ()
+          set_tests_properties (${REPACK_TESTNAME} PROPERTIES
+              ENVIRONMENT "${vol_env}"
+          )
+        endif ()
 
       else ()
         # Execute h5repack through runTest script - append relative paths
-        list(APPEND REPACK_TOOL_ARGS "-i;${ARG_TEST_FILE};-o;${ARG_MAIN_OUT_FILE}")
+        list (APPEND REPACK_TOOL_ARGS "-i;${ARG_TEST_FILE};-o;${ARG_MAIN_OUT_FILE}")
 
         add_test (
             NAME ${REPACK_TESTNAME}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:h5repack>"
                 -D "TEST_ARGS:STRING=${REPACK_TOOL_ARGS}"
                 -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
@@ -614,13 +617,17 @@ macro (ADD_H5_TEST testname)
         )
 
         if (NOT "${vol}" STREQUAL "native")
-          set_tests_properties(${REPACK_TESTNAME} PROPERTIES
+          set_tests_properties (${REPACK_TESTNAME} PROPERTIES
               ENVIRONMENT "${vol_env}"
               # working directory handled by runTest
               FIXTURES_REQUIRED h5repack_vol_files
           )
-        endif()
+        else ()
-      endif()
+          set_tests_properties (${REPACK_TESTNAME} PROPERTIES
+              ENVIRONMENT "${vol_env}"
+          )
+        endif ()
+      endif ()
 
       set_tests_properties (${REPACK_TESTNAME} PROPERTIES
           DEPENDS ${CLEAR_TESTNAME}
@@ -637,10 +644,11 @@ macro (ADD_H5_TEST testname)
         # h5diff directly
         add_test (
             NAME ${DIFF_TESTNAME}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> ${ARG_ERROR_STACK_FLAG} ${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE} ${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}
+            COMMAND $<TARGET_FILE:h5diff> ${ARG_ERROR_STACK_FLAG} ${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE} ${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}
         )
         set_tests_properties (${DIFF_TESTNAME} PROPERTIES
             DEPENDS ${REPACK_TESTNAME}
+            ENVIRONMENT "${CROSSCOMPILING_PATH}"
             WORKING_DIRECTORY "${BINARY_DIR_VOL}"
         )
         if ("${DIFF_TESTNAME}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -649,60 +657,66 @@ macro (ADD_H5_TEST testname)
       elseif (${ARG_COMPARE_LOCAL} AND ${ARG_FULL_DIFF})
         # h5diff via runTest
         add_test (
-          NAME ${DIFF_TESTNAME}
+            NAME ${DIFF_TESTNAME}
-          COMMAND "${CMAKE_COMMAND}"
+            COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
+                -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
-            -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
+                -D "TEST_ARGS:STRING=-v;${ARG_ERROR_STACK_FLAG};${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE};${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}"
-            -D "TEST_ARGS:STRING=-v;${ARG_ERROR_STACK_FLAG};${BINARY_DIR_VOL}/testfiles/${ARG_TEST_FILE};${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}"
+                -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
-            -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
+                -D "TEST_OUTPUT=${ARG_MAIN_OUT_FILE}.out"
-            -D "TEST_OUTPUT=${ARG_MAIN_OUT_FILE}.out"
+                -D "TEST_EXPECT=${ARG_DIFF_RESULT_CODE}"
-            -D "TEST_EXPECT=${ARG_DIFF_RESULT_CODE}"
+                -D "TEST_REFERENCE=${testname}.${ARG_TEST_FILE}.tst"
-            -D "TEST_REFERENCE=${testname}.${ARG_TEST_FILE}.tst"
+                -P "${HDF_RESOURCES_DIR}/runTest.cmake"
-            -P "${HDF_RESOURCES_DIR}/runTest.cmake"
         )
         set_tests_properties (${DIFF_TESTNAME} PROPERTIES
             DEPENDS ${REPACK_TESTNAME}
         )
         if (NOT "${vol}" STREQUAL "native")
-          set_tests_properties(${DIFF_TESTNAME} PROPERTIES
+          set_tests_properties (${DIFF_TESTNAME} PROPERTIES
               ENVIRONMENT "${vol_env}"
               # working directory handled by runTest
               FIXTURES_REQUIRED h5repack_vol_files
           )
-        endif()
+        else ()
+          set_tests_properties (${DIFF_TESTNAME} PROPERTIES
+              ENVIRONMENT "${vol_env}"
+          )
+        endif ()
         if ("${DIFF_TESTNAME}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
           set_tests_properties (${DIFF_TESTNAME} PROPERTIES DISABLED true)
         endif ()
 
-      endif()
+      endif ()
 
       list (APPEND ARG_CLEANUP_DEPENDS "${DIFF_TESTNAME}")
 
       if (${ARG_DUMP_CHECK} OR DEFINED ARG_LAYOUT_DSET)
         # Perform check via h5dump
         add_test (
-          NAME ${DUMP_TESTNAME}
+            NAME ${DUMP_TESTNAME}
-          COMMAND "${CMAKE_COMMAND}"
+            COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
+                -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
-              -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
+                -D "TEST_ARGS:STRING=${ARG_DUMP_OPTIONS};${ARG_MAIN_OUT_FILE}"
-              -D "TEST_ARGS:STRING=${ARG_DUMP_OPTIONS};${ARG_MAIN_OUT_FILE}"
+                -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
-              -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
+                -D "TEST_OUTPUT=${ARG_STDOUT_FILE}"
-              -D "TEST_OUTPUT=${ARG_STDOUT_FILE}"
+                -D "TEST_EXPECT=${ARG_RESULT_CODE}"
-              -D "TEST_EXPECT=${ARG_RESULT_CODE}"
+                -D "TEST_SKIP_COMPARE=${ARG_DUMP_SKIP_COMPARE}"
-              -D "TEST_SKIP_COMPARE=${ARG_DUMP_SKIP_COMPARE}"
+                -D "TEST_GREP_FILTER=${ARG_DUMP_GREP_FILTER}"
-              -D "TEST_GREP_FILTER=${ARG_DUMP_GREP_FILTER}"
+                -D "TEST_GREP_EXPECT=${ARG_RESULT_CODE}"
-              -D "TEST_GREP_EXPECT=${ARG_RESULT_CODE}"
+                -D "TEST_FILTER:STRING=${ARG_FILTER_IN}"
-              -D "TEST_FILTER:STRING=${ARG_FILTER_IN}"
+                -D "TEST_FILTER_REPLACE:STRING=${ARG_FILTER_OUT}"
-              -D "TEST_FILTER_REPLACE:STRING=${ARG_FILTER_OUT}"
+                -D "TEST_REFERENCE=${ARG_DUMP_REFERENCE}"
-              -D "TEST_REFERENCE=${ARG_DUMP_REFERENCE}"
+                -P "${HDF_RESOURCES_DIR}/runTest.cmake"
-              -P "${HDF_RESOURCES_DIR}/runTest.cmake"
         )
         if (NOT "${vol}" STREQUAL "native")
-          set_tests_properties(${DUMP_TESTNAME} PROPERTIES
+          set_tests_properties (${DUMP_TESTNAME} PROPERTIES
               ENVIRONMENT "${vol_env}"
               # working directory handled by runTest
               FIXTURES_REQUIRED h5repack_vol_files
           )
+        else ()
+          set_tests_properties (${DUMP_TESTNAME} PROPERTIES
+              ENVIRONMENT "${vol_env}"
+          )
         endif ()
 
         set_tests_properties (${DUMP_TESTNAME} PROPERTIES
@@ -714,13 +728,12 @@ macro (ADD_H5_TEST testname)
         endif ()
 
         list (APPEND ARG_CLEANUP_DEPENDS "${DUMP_TESTNAME}")
-      endif()
+      endif ()
 
       if (${ARG_STAT_CHECK} AND NOT HDF5_ENABLE_USING_MEMCHECKER)
-          add_test (
+        add_test (
             NAME ${STAT_TESTNAME}
             COMMAND "${CMAKE_COMMAND}"
-                -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
                 -D "TEST_PROGRAM=$<TARGET_FILE:h5stat>"
                 -D "TEST_ARGS:STRING=-S;-s;out-${ARG_STAT_ARG}.${ARG_TEST_FILE}"
                 -D "TEST_FOLDER=${BINARY_DIR_VOL}/testfiles"
@@ -730,11 +743,15 @@ macro (ADD_H5_TEST testname)
                 -P "${HDF_RESOURCES_DIR}/runTest.cmake"
         )
         if (NOT "${vol}" STREQUAL "native")
-          set_tests_properties(${STAT_TESTNAME} PROPERTIES
+          set_tests_properties (${STAT_TESTNAME} PROPERTIES
               ENVIRONMENT "${vol_env}"
               # working directory handled by runTest
               FIXTURES_REQUIRED h5repack_vol_files
           )
+        else ()
+          set_tests_properties (${STAT_TESTNAME} PROPERTIES
+              ENVIRONMENT "${vol_env}"
+          )
         endif ()
 
         set_tests_properties (${STAT_TESTNAME} PROPERTIES
@@ -745,25 +762,29 @@ macro (ADD_H5_TEST testname)
         endif ()
 
         list (APPEND ARG_CLEANUP_DEPENDS "${STAT_TESTNAME}")
-      endif()
+      endif ()
 
       # Post-test cleanup
       add_test (
-        NAME ${CLEAN_TESTNAME}
+          NAME ${CLEAN_TESTNAME}
-        COMMAND ${CMAKE_COMMAND} -E remove "${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}"
+          COMMAND ${CMAKE_COMMAND} -E remove "${BINARY_DIR_VOL}/testfiles/${ARG_MAIN_OUT_FILE}"
       )
       set_tests_properties (${CLEAN_TESTNAME} PROPERTIES
-        WORKING_DIRECTORY "${BINARY_DIR_VOL}/testfiles"
+          WORKING_DIRECTORY "${BINARY_DIR_VOL}/testfiles"
-        FIXTURES_REQUIRED h5repack_vol_files
+          FIXTURES_REQUIRED h5repack_vol_files
       )
       # Only set dependencies if necessary
       if (NOT "${ARG_CLEANUP_DEPENDS}" STREQUAL "")
         set_tests_properties (${CLEAN_TESTNAME} PROPERTIES
             DEPENDS "${ARG_CLEANUP_DEPENDS}"
         )
-      endif()
+      else ()
+        set_tests_properties (${CLEAN_TESTNAME} PROPERTIES
+            ENVIRONMENT "${vol_env}"
+        )
+      endif ()
     endif ()
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_VERIFY_VDS testname testtype resultcode testfile testdset testfilter)
@@ -773,7 +794,7 @@ macro (ADD_H5_VERIFY_VDS testname testtype resultcode testfile testdset testfilt
           NAME H5REPACK_VERIFY_LAYOUT_VDS-${testname}
           COMMAND ${CMAKE_COMMAND} -E echo "SKIP -d ${testdset} -pH ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${resultfile}"
       )
-      set_property(TEST H5REPACK_VERIFY_LAYOUT_VDS-${testname} PROPERTY DISABLED true)
+      set_property (TEST H5REPACK_VERIFY_LAYOUT_VDS-${testname} PROPERTY DISABLED true)
     endif ()
   else ()
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
@@ -784,9 +805,10 @@ macro (ADD_H5_VERIFY_VDS testname testtype resultcode testfile testdset testfilt
       )
       add_test (
           NAME H5REPACK_VERIFY_LAYOUT_VDS-${testname}
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
+          COMMAND $<TARGET_FILE:h5repack> ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
       )
       set_tests_properties (H5REPACK_VERIFY_LAYOUT_VDS-${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_VERIFY_LAYOUT_VDS-${testname}-clear-objects
       )
@@ -796,7 +818,6 @@ macro (ADD_H5_VERIFY_VDS testname testtype resultcode testfile testdset testfilt
       add_test (
           NAME H5REPACK_VERIFY_LAYOUT_VDS-${testname}_DMP
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=-d;${testdset};-p;out-${testname}.${testfile}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -806,6 +827,7 @@ macro (ADD_H5_VERIFY_VDS testname testtype resultcode testfile testdset testfilt
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
       set_tests_properties (H5REPACK_VERIFY_LAYOUT_VDS-${testname}_DMP PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_VERIFY_LAYOUT_VDS-${testname}
       )
@@ -832,9 +854,10 @@ macro (ADD_H5_VERIFY_SUPERBLOCK testname testfile lowbound highbound superblock)
     )
     add_test (
         NAME H5REPACK_VERIFY_SUPERBLOCK-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> -j;${lowbound};-k;${highbound} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
+        COMMAND $<TARGET_FILE:h5repack> -j;${lowbound};-k;${highbound} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
     )
     set_tests_properties (H5REPACK_VERIFY_SUPERBLOCK-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_VERIFY_SUPERBLOCK-${testname}-clear-objects
     )
     if ("H5REPACK_VERIFY_SUPERBLOCK-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -843,7 +866,6 @@ macro (ADD_H5_VERIFY_SUPERBLOCK testname testfile lowbound highbound superblock)
     add_test (
         NAME H5REPACK_VERIFY_SUPERBLOCK-${testname}_DMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-H;-B;out-${testname}.${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -856,6 +878,7 @@ macro (ADD_H5_VERIFY_SUPERBLOCK testname testfile lowbound highbound superblock)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5REPACK_VERIFY_SUPERBLOCK-${testname}_DMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_VERIFY_SUPERBLOCK-${testname}
     )
     if ("H5REPACK_VERIFY_SUPERBLOCK-${testname}_DMP" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -878,9 +901,10 @@ macro (ADD_H5_VERIFY_INVALIDBOUNDS testname resultcode lowbound highbound)
     )
     add_test (
         NAME ADD_H5_VERIFY_INVALIDBOUNDS-h5repack-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> -j;${lowbound};-k;${highbound} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
+        COMMAND $<TARGET_FILE:h5repack> -j;${lowbound};-k;${highbound} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
     )
     set_tests_properties (ADD_H5_VERIFY_INVALIDBOUNDS-h5repack-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS ADD_H5_VERIFY_INVALIDBOUNDS-h5repack-${testname}-clear-objects
         WILL_FAIL "true"
     )
@@ -904,9 +928,10 @@ macro (ADD_H5_VERIFY_USERBLOCK testname userblocksize testfile)
     )
     add_test (
         NAME H5REPACK_VERIFY_USERBLOCK-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> --enable-error-stack ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
+        COMMAND $<TARGET_FILE:h5repack> --enable-error-stack ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}.${testfile}
     )
     set_tests_properties (H5REPACK_VERIFY_USERBLOCK-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_VERIFY_USERBLOCK-${testname}-clear-objects
     )
     if ("H5REPACK_VERIFY_USERBLOCK-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -915,7 +940,6 @@ macro (ADD_H5_VERIFY_USERBLOCK testname userblocksize testfile)
     add_test (
         NAME H5REPACK_VERIFY_USERBLOCK-${testname}_DMP
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
             -D "TEST_ARGS:STRING=-H;-B;out-${testname}.${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -928,6 +952,7 @@ macro (ADD_H5_VERIFY_USERBLOCK testname userblocksize testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5REPACK_VERIFY_USERBLOCK-${testname}_DMP PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_VERIFY_USERBLOCK-${testname}
     )
     if ("H5REPACK_VERIFY_USERBLOCK-${testname}_DMP" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -953,9 +978,10 @@ macro (ADD_H5_TEST_META testname testfile)
     )
     add_test (
         NAME H5REPACK_META-${testname}_N
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}_N.${testname}.h5
+        COMMAND $<TARGET_FILE:h5repack> ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}_N.${testname}.h5
     )
     set_tests_properties (H5REPACK_META-${testname}_N PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_META-${testname}-clear-objects
     )
     if ("H5REPACK_META-${testname}_N" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -964,7 +990,6 @@ macro (ADD_H5_TEST_META testname testfile)
     add_test (
         NAME H5REPACK_META-${testname}_N_DFF
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
             -D "TEST_ARGS:STRING=-v;${testfile};out-${testname}_N.${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -974,6 +999,7 @@ macro (ADD_H5_TEST_META testname testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5REPACK_META-${testname}_N_DFF PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_META-${testname}_N
     )
     if ("H5REPACK_META-${testname}_N_DFF" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -981,9 +1007,10 @@ macro (ADD_H5_TEST_META testname testfile)
     endif ()
     add_test (
         NAME H5REPACK_META-${testname}_M
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}_M.${testname}.h5
+        COMMAND $<TARGET_FILE:h5repack> ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/${testfile} ${PROJECT_BINARY_DIR}/testfiles/out-${testname}_M.${testname}.h5
     )
     set_tests_properties (H5REPACK_META-${testname}_M PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_META-${testname}_N_DFF
     )
     if ("H5REPACK_META-${testname}_M" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -992,7 +1019,6 @@ macro (ADD_H5_TEST_META testname testfile)
     add_test (
         NAME H5REPACK_META-${testname}_M_DFF
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5diff>"
             -D "TEST_ARGS:STRING=-v;${testfile};out-${testname}_M.${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -1002,6 +1028,7 @@ macro (ADD_H5_TEST_META testname testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5REPACK_META-${testname}_M_DFF PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_META-${testname}_M
     )
     if ("H5REPACK_META-${testname}_M_DFF" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1042,7 +1069,6 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
     add_test (
         NAME H5REPACK_UD-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5repack>"
             -D "TEST_ARGS:STRING=${ARGN};${resultfile};out-${testname}.${resultfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -1056,6 +1082,7 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5REPACK_UD-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5REPACK_UD-${testname}-clear-objects
     )
     if ("H5REPACK_UD-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1065,7 +1092,6 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
       add_test (
           NAME H5REPACK_UD-${testname}-h5dump
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5dump>"
               -D "TEST_ARGS:STRING=-pH;out-${testname}.${resultfile}"
               -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -1078,6 +1104,7 @@ macro (ADD_H5_UD_TEST testname resultcode resultfile)
               -P "${HDF_RESOURCES_DIR}/runTest.cmake"
       )
       set_tests_properties (H5REPACK_UD-${testname}-h5dump PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           DEPENDS H5REPACK_UD-${testname}
       )
       if ("H5REPACK_UD-${testname}-h5dump" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -1138,9 +1165,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       # comparison of known files
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}_DFF1
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
+          COMMAND $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname}_DFF1 PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}_CPY
       )
@@ -1150,9 +1178,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       # repack the external file to the repacked file
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> --enable-error-stack ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5
+          COMMAND $<TARGET_FILE:h5repack> --enable-error-stack ${ARGN} ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname} PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}_DFF1
       )
@@ -1162,9 +1191,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       # comparison of repacked file to known files
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}_DFF2
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5
+          COMMAND $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname}_DFF2 PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}
       )
@@ -1173,9 +1203,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       endif ()
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}_DFF3
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
+          COMMAND $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname}_DFF3 PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}_DFF2
       )
@@ -1197,9 +1228,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       # verify comparison of repacked file to known file
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}_DFF4
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5
+          COMMAND $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname}_DFF4 PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}_DATA_RMV
       )
@@ -1209,9 +1241,10 @@ macro (ADD_H5_EXTERNAL_TEST testname testtype testfile)
       # verify comparison of repacked file to known external file fails
       add_test (
           NAME H5REPACK_EXTERNAL-${testname}_DFF_FAIL
-          COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
+          COMMAND $<TARGET_FILE:h5diff> --enable-error-stack ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_rp.h5 ${PROJECT_BINARY_DIR}/testfiles/h5repack_${testfile}_ex.h5
       )
       set_tests_properties (H5REPACK_EXTERNAL-${testname}_DFF_FAIL PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
           DEPENDS H5REPACK_EXTERNAL-${testname}_DFF4
           WILL_FAIL "true"
@@ -1271,7 +1304,7 @@ set (FILEV5 5_vds.h5)
 
 ADD_HELP_TEST(help 0 -h)
 
-add_test (NAME H5REPACK-testh5repack_detect_szip COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:testh5repack_detect_szip>)
+add_test (NAME H5REPACK-testh5repack_detect_szip COMMAND $<TARGET_FILE:testh5repack_detect_szip>)
 if (HDF5_ENABLE_SZIP_SUPPORT)
   if (HDF5_ENABLE_SZIP_ENCODING)
     set (passRegex "yes")
@@ -1284,11 +1317,17 @@ else ()
   set (passRegex "no")
   set_tests_properties (H5REPACK-testh5repack_detect_szip PROPERTIES PASS_REGULAR_EXPRESSION "no")
 endif ()
-set_tests_properties (H5REPACK-testh5repack_detect_szip PROPERTIES DEPENDS H5REPACK-h5repack-${testname})
+set_tests_properties (H5REPACK-testh5repack_detect_szip PROPERTIES
+    DEPENDS H5REPACK-h5repack-${testname}
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
+)
 set (last_test "H5REPACK-testh5repack_detect_szip")
 
-#  add_test (NAME H5REPACK-h5repacktest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repacktest>)
+#  add_test (NAME H5REPACK-h5repacktest COMMAND $<TARGET_FILE:h5repacktest>)
-#  set_tests_properties (H5REPACK-h5repacktest PROPERTIES DEPENDS H5REPACK-testh5repack_detect_szip)
+#  set_tests_properties (H5REPACK-h5repacktest PROPERTIES
+#    DEPENDS H5REPACK-testh5repack_detect_szip
+#    ENVIRONMENT "${CROSSCOMPILING_PATH}"
+#  )
 #  set (last_test "H5REPACK-h5repacktest")
 #
 # The tests
@@ -1533,7 +1572,7 @@ ADD_H5_TEST (deflate_file TEST_TYPE ${TESTTYPE} TEST_FILE ${arg} ERROR_STACK)
 #crtorder
 set (arg tordergr.h5 -L)
 set (TESTTYPE "TEST")
-ADD_H5_TEST(crtorder TEST_TYPE ${TESTTYPE} RESULT_CODE 0 TEST_FILE ${arg} DUMP_CHECK)
+ADD_H5_TEST (crtorder TEST_TYPE ${TESTTYPE} RESULT_CODE 0 TEST_FILE ${arg} DUMP_CHECK)
 
 ###################################################################################################
 # Testing paged aggregation related options:
@@ -1734,16 +1773,22 @@ ADD_H5_TEST (HDFFV-7840 TEST_TYPE "TEST" TEST_FILE h5diff_attr1.h5 ERROR_STACK)
 set (arg --low=1 --high=2 -f GZIP=8 -l dset1:CHUNK=5x6)
 add_test (
     NAME H5REPACK-HDFFV-10590
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${arg} ${PROJECT_BINARY_DIR}/testfiles/h5repack_CVE-2018-17432.h5 ${PROJECT_BINARY_DIR}/testfiles/out-HDFFV-10590.h5repack_CVE-2018-17432.h5
+    COMMAND $<TARGET_FILE:h5repack> ${arg} ${PROJECT_BINARY_DIR}/testfiles/h5repack_CVE-2018-17432.h5 ${PROJECT_BINARY_DIR}/testfiles/out-HDFFV-10590.h5repack_CVE-2018-17432.h5
+)
+set_tests_properties (H5REPACK-HDFFV-10590 PROPERTIES
+    WILL_FAIL "true"
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
-set_tests_properties (H5REPACK-HDFFV-10590 PROPERTIES WILL_FAIL "true")
 
 # test CVE-2018-14460 fix
 add_test (
     NAME H5REPACK-HDFFV-11223
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repack> ${PROJECT_BINARY_DIR}/testfiles/h5repack_CVE-2018-14460.h5 ${PROJECT_BINARY_DIR}/testfiles/out-HDFFV-11223.h5repack_CVE-2018-14460.h5
+    COMMAND $<TARGET_FILE:h5repack> ${PROJECT_BINARY_DIR}/testfiles/h5repack_CVE-2018-14460.h5 ${PROJECT_BINARY_DIR}/testfiles/out-HDFFV-11223.h5repack_CVE-2018-14460.h5
+)
+set_tests_properties (H5REPACK-HDFFV-11223 PROPERTIES
+    WILL_FAIL "true"
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
 )
-set_tests_properties (H5REPACK-HDFFV-11223 PROPERTIES WILL_FAIL "true")
 
 # tests for metadata block size option ('-M')
 ADD_H5_TEST_META (meta_short h5repack_layout.h5 -M 8192)
@@ -1787,8 +1832,8 @@ ADD_H5_VERIFY_VDS (vds_conti ${TESTTYPE} 0 ${FILEV4} vds_dset CONTIGUOUS -l vds_
 ################################################################
 # reference new api conversions
 ###############################################################
-ADD_H5_TEST(attrregion TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tattrreg.h5 DUMP_CHECK)
+ADD_H5_TEST (attrregion TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tattrreg.h5 DUMP_CHECK)
-ADD_H5_TEST(dataregion TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tdatareg.h5 DUMP_CHECK)
+ADD_H5_TEST (dataregion TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tdatareg.h5 DUMP_CHECK)
 
 ##############################################################################
 ###    V E R S I O N  B O U N D S  T E S T S
@@ -1815,12 +1860,12 @@ ADD_H5_EXTERNAL_TEST (ext_uint8be "TEST" uint8be -l CONTI)
 ###    E X T E R N A L  L I N K  T E S T S
 ##############################################################################
 ### HDFFV-11128 needs fixed to enable the following test
-ADD_H5_TEST(h5copy_extlinks_src-base TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (h5copy_extlinks_src-base TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(tsoftlinks-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (tsoftlinks-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlink-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlink-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinkfar-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinkfar.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinkfar-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinkfar.h5 ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinksrc-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinksrc.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinksrc-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinksrc.h5 ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinktar-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinktar.h5 ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinktar-base TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinktar.h5 ERROR_STACK DUMP_CHECK)
 
 ADD_H5_TEST (h5copy_extlinks_src-merge TEST_TYPE "TEST" DIFF_RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 --merge FULL_DIFF ERROR_STACK)
 ADD_H5_TEST (tsoftlinks-merge TEST_TYPE "TEST" DIFF_RESULT_CODE 1 TEST_FILE tsoftlinks.h5 --merge FULL_DIFF ERROR_STACK)
@@ -1833,22 +1878,22 @@ ADD_H5_TEST (textlinksrc-merge TEST_TYPE "SKIP" DIFF_RESULT_CODE 1 TEST_FILE tex
 ### HDFFV-11128 needs fixed to enable the following test
 ADD_H5_TEST (textlinktar-merge TEST_TYPE "SKIP" DIFF_RESULT_CODE 1 TEST_FILE textlinktar.h5 --merge FULL_DIFF ERROR_STACK)
 
-ADD_H5_TEST(h5copy_extlinks_src-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (h5copy_extlinks_src-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(tsoftlinks-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (tsoftlinks-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlink-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlink-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinkfar-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinkfar.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinkfar-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinkfar.h5 --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinksrc-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinksrc.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinksrc-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinksrc.h5 --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlinktar-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinktar.h5 --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinktar-prune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlinktar.h5 --prune ERROR_STACK DUMP_CHECK)
 
-ADD_H5_TEST(h5copy_extlinks_src-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (h5copy_extlinks_src-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE h5copy_extlinks_src.h5 --merge --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(tsoftlinks-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (tsoftlinks-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tsoftlinks.h5 --merge --prune ERROR_STACK DUMP_CHECK)
-ADD_H5_TEST(textlink-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlink-mergeprune TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE textlink.h5 --merge --prune ERROR_STACK DUMP_CHECK)
 ### HDFFV-11128 needs fixed to enable the following test
-ADD_H5_TEST(textlinkfar-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinkfar.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinkfar-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinkfar.h5 --merge --prune ERROR_STACK DUMP_CHECK)
 ### HDFFV-11128 needs fixed to enable the following test
-ADD_H5_TEST(textlinksrc-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinksrc.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinksrc-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinksrc.h5 --merge --prune ERROR_STACK DUMP_CHECK)
 ### HDFFV-11128 needs fixed to enable the following test
-ADD_H5_TEST(textlinktar-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinktar.h5 --merge --prune ERROR_STACK DUMP_CHECK)
+ADD_H5_TEST (textlinktar-mergeprune TEST_TYPE "SKIP" RESULT_CODE 0 TEST_FILE textlinktar.h5 --merge --prune ERROR_STACK DUMP_CHECK)
 
 ADD_H5_TEST (tst_onion_dset_1d TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tst_onion_dset_1d.h5 --src-vfd-name onion --src-vfd-info 1 DUMP_CHECK DUMP_NO_OPT)
 ADD_H5_TEST (tst_onion_dset_ext TEST_TYPE "TEST" RESULT_CODE 0 TEST_FILE tst_onion_dset_ext.h5 --src-vfd-name onion --src-vfd-info 1 DUMP_CHECK DUMP_NO_OPT)

tools/test/h5repack/CMakeVFDTests.cmake

@@ -15,7 +15,7 @@
 ###           T E S T I N G                                                ###
 ##############################################################################
 ##############################################################################
-H5_CREATE_VFD_DIR()
+H5_CREATE_VFD_DIR ()
 
 set (H5REPACK_VFD_subfiling_SKIP_TESTS
   h5repacktest
@@ -70,7 +70,6 @@ macro (ADD_VFD_TEST vfdname resultcode)
       add_test (
           NAME H5REPACK_VFD-${vfdname}-h5repacktest
           COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
               -D "TEST_PROGRAM=$<TARGET_FILE:h5repacktest>"
               -D "TEST_ARGS:STRING="
               -D "TEST_VFD:STRING=${vfdname}"
@@ -80,6 +79,7 @@ macro (ADD_VFD_TEST vfdname resultcode)
               -P "${HDF_RESOURCES_DIR}/vfdTest.cmake"
       )
       set_tests_properties (H5REPACK_VFD-${vfdname}-h5repacktest PROPERTIES
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
           DEPENDS H5REPACK_VFD-${vfdname}-h5repacktest-clear-objects
           TIMEOUT ${CTEST_SHORT_TIMEOUT}
       )

tools/test/h5stat/CMakeTests.cmake

@@ -72,15 +72,15 @@ file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/S3TEST")
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/S3TEST/testfiles")
 
 foreach (ddl_file ${HDF5_REFERENCE_FILES})
-  HDFTEST_COPY_FILE("${PROJECT_SOURCE_DIR}/expected/${ddl_file}.ddl" "${PROJECT_BINARY_DIR}/${ddl_file}.ddl" "h5stat_files")
+  HDFTEST_COPY_FILE ("${PROJECT_SOURCE_DIR}/expected/${ddl_file}.ddl" "${PROJECT_BINARY_DIR}/${ddl_file}.ddl" "h5stat_files")
 endforeach ()
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "h5stat_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "h5stat_files")
 endforeach ()
 foreach (lists3file ${H5STAT_S3PROXY_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${lists3file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${lists3file}" "h5stat_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${lists3file}" "${PROJECT_BINARY_DIR}/S3TEST/testfiles/${lists3file}" "h5stat_files")
 endforeach ()
-add_custom_target(h5stat_files ALL COMMENT "Copying files needed by h5stat tests" DEPENDS ${h5stat_files_list})
+add_custom_target (h5stat_files ALL COMMENT "Copying files needed by h5stat tests" DEPENDS ${h5stat_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -91,7 +91,7 @@ add_custom_target(h5stat_files ALL COMMENT "Copying files needed by h5stat tests
 macro (ADD_H5_TEST resultfile resultcode)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5STAT-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5stat> ${ARGN})
+    add_test (NAME H5STAT-${resultfile} COMMAND $<TARGET_FILE:h5stat> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5STAT-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -99,7 +99,6 @@ macro (ADD_H5_TEST resultfile resultcode)
     add_test (
         NAME H5STAT-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5stat>"
             -D "TEST_ARGS=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -110,6 +109,7 @@ macro (ADD_H5_TEST resultfile resultcode)
     )
   endif ()
   set_tests_properties (H5STAT-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
   )
   if ("H5STAT-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -120,7 +120,7 @@ endmacro ()
 macro (ADD_H5_ERR_TEST resultfile resultcode errtext)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5STAT-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5stat> ${ARGN})
+    add_test (NAME H5STAT-${resultfile} COMMAND $<TARGET_FILE:h5stat> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5STAT-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -128,7 +128,6 @@ macro (ADD_H5_ERR_TEST resultfile resultcode errtext)
     add_test (
         NAME H5STAT-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5stat>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -141,6 +140,7 @@ macro (ADD_H5_ERR_TEST resultfile resultcode errtext)
     )
   endif ()
   set_tests_properties (H5STAT-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
   )
   if ("H5STAT-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -151,7 +151,7 @@ endmacro ()
 macro (ADD_H5_CMP_TEST resultfile resultcode errtext)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5STAT-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5stat> ${ARGN})
+    add_test (NAME H5STAT-${resultfile} COMMAND $<TARGET_FILE:h5stat> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5STAT-${resultfile} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -159,7 +159,6 @@ macro (ADD_H5_CMP_TEST resultfile resultcode errtext)
     add_test (
         NAME H5STAT-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5stat>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}"
@@ -172,6 +171,7 @@ macro (ADD_H5_CMP_TEST resultfile resultcode errtext)
     )
   endif ()
   set_tests_properties (H5STAT-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
   )
   if ("H5STAT-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -182,7 +182,7 @@ endmacro ()
 macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   # If using memchecker add tests without using scripts
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5stat> ${ARGN})
+    add_test (NAME H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype} COMMAND $<TARGET_FILE:h5stat> ${ARGN})
     if (${resultcode})
       set_tests_properties (H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES WILL_FAIL "true")
     endif ()
@@ -190,7 +190,6 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
     add_test (
         NAME H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5stat>"
             -D "TEST_ARGS=--enable-error-stack=2;${ARGN};${urlscheme}://${urlpath}/${resultfile}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/S3TEST"
@@ -204,7 +203,7 @@ macro (ADD_H5_S3TEST resultfile resultcode credtype urlscheme urlpath)
   endif ()
   set_tests_properties (H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype} PROPERTIES
       FIXTURES_REQUIRED h5stat_s3_proxy
-      ENVIRONMENT "${h5stat_s3tests_env}"
+      ENVIRONMENT "${h5stat_s3tests_env};${CROSSCOMPILING_PATH}"
       WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/S3TEST
   )
   if ("H5STAT_S3TEST-${resultfile}_${urlscheme}_${credtype}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/test/misc/CMakeLists.txt

@@ -19,7 +19,8 @@ else ()
   target_link_libraries (h5clear_gentest PRIVATE ${HDF5_TOOLS_LIBSH_TARGET} ${HDF5_TEST_LIBSH_TARGET})
 endif ()
 set_target_properties (h5clear_gentest PROPERTIES FOLDER tools)
-#add_test (NAME H5CLEAR-h5clear_gentest COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear_gentest>)
+#add_test (NAME H5CLEAR-h5clear_gentest COMMAND $<TARGET_FILE:h5clear_gentest>)
+#set_target_properties (h5clear_gentest ENVIRONMENT "${CROSSCOMPILING_PATH}")
 
 #-----------------------------------------------------------------------------
 # Add Target to clang-format

tools/test/misc/CMakeTestsClear.cmake

@@ -60,18 +60,18 @@ set (HDF5_REFERENCE_TEST_FILES
 )
 
 foreach (h5_file ${HDF5_TEST_FILES} ${HDF5_SEC2_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5clear_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5clear_files")
 endforeach ()
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5clear_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_file}" "h5clear_files")
 endforeach ()
 # make second copy of h5clear_sec2.h5
 foreach (h5_file ${HDF5_SEC2_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/orig_${h5_file}" "h5clear_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/testfiles/orig_${h5_file}" "h5clear_files")
 endforeach ()
 # make second copy of mod_h5clear_mdc_image.h5
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/mod_h5clear_mdc_image.h5" "${PROJECT_BINARY_DIR}/testfiles/mod_h5clear_mdc_image2.h5" "h5clear_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/mod_h5clear_mdc_image.h5" "${PROJECT_BINARY_DIR}/testfiles/mod_h5clear_mdc_image2.h5" "h5clear_files")
-add_custom_target(h5clear_files ALL COMMENT "Copying files needed by h5clear tests" DEPENDS ${h5clear_files_list})
+add_custom_target (h5clear_files ALL COMMENT "Copying files needed by h5clear tests" DEPENDS ${h5clear_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -86,7 +86,6 @@ macro (ADD_H5_CMP testname resultfile resultcode)
     add_test (
         NAME H5CLEAR_CMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -95,6 +94,7 @@ macro (ADD_H5_CMP testname resultfile resultcode)
             -D "TEST_REFERENCE=${resultfile}.ddl"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
+    set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES ENVIRONMENT "${CROSSCOMPILING_PATH}")
     if ("H5CLEAR_CMP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES DISABLED true)
     endif ()
@@ -110,7 +110,6 @@ macro (ADD_H5_ERR_CMP testname resultfile resultcode result_errcheck)
     add_test (
         NAME H5CLEAR_CMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -121,6 +120,7 @@ macro (ADD_H5_ERR_CMP testname resultfile resultcode result_errcheck)
             -D "TEST_SKIP_COMPARE=true"
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
+    set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES ENVIRONMENT "${CROSSCOMPILING_PATH}")
     if ("H5CLEAR_CMP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
       set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES DISABLED true)
     endif ()
@@ -148,7 +148,6 @@ macro (ADD_H5_CMP_WITH_COPY testname resultcode resultfile testfile)
     add_test (
         NAME H5CLEAR_CMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=${ARGN};${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -158,6 +157,7 @@ macro (ADD_H5_CMP_WITH_COPY testname resultcode resultfile testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_CMP-copy_${testname}
     )
     if ("H5CLEAR_CMP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -183,7 +183,6 @@ macro (ADD_H5_ERR_CMP_WITH_COPY testname resultcode resultfile testfile)
     add_test (
         NAME H5CLEAR_CMP-${testname}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=${ARGN};${testfile}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -194,6 +193,7 @@ macro (ADD_H5_ERR_CMP_WITH_COPY testname resultcode resultfile testfile)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_CMP-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_CMP-copy_${testname}
     )
     if ("H5CLEAR_CMP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -206,9 +206,10 @@ macro (ADD_H5_RETTEST testname resultcode)
   if (NOT HDF5_ENABLE_USING_MEMCHECKER)
     add_test (
         NAME H5CLEAR_RET-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> ${ARGN}
+        COMMAND $<TARGET_FILE:h5clear> ${ARGN}
     )
     set_tests_properties (H5CLEAR_RET-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
         WILL_FAIL "${resultcode}"
     )
@@ -235,7 +236,6 @@ macro (ADD_H5_FILESIZE_TEST testname resultcode resultfile incr_size)
     add_test (
         NAME H5CLEAR_FILESIZE_CMP-${testname}_before_size
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=--filesize;${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -245,6 +245,7 @@ macro (ADD_H5_FILESIZE_TEST testname resultcode resultfile incr_size)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_FILESIZE_CMP-${testname}_before_size PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_FILESIZE_TEST-copy_${testname}
     )
     if ("H5CLEAR_FILESIZE_CMP-${testname}_before_size" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -253,15 +254,16 @@ macro (ADD_H5_FILESIZE_TEST testname resultcode resultfile incr_size)
     if (NOT ${incr_size} MATCHES "NONE")
         add_test (
             NAME H5CLEAR_FILESIZE_INCR-${testname}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> --increment=${incr_size} ${testname}.h5
+            COMMAND $<TARGET_FILE:h5clear> --increment=${incr_size} ${testname}.h5
         )
     else ()
         add_test (
             NAME H5CLEAR_FILESIZE_INCR-${testname}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> --increment ${testname}.h5
+            COMMAND $<TARGET_FILE:h5clear> --increment ${testname}.h5
         )
     endif ()
     set_tests_properties (H5CLEAR_FILESIZE_INCR-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
         WILL_FAIL "${resultcode}"
         DEPENDS H5CLEAR_FILESIZE_CMP-${testname}_before_size
@@ -272,7 +274,6 @@ macro (ADD_H5_FILESIZE_TEST testname resultcode resultfile incr_size)
     add_test (
         NAME H5CLEAR_FILESIZE_CMP-${testname}_after_size
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=--filesize;${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -282,6 +283,7 @@ macro (ADD_H5_FILESIZE_TEST testname resultcode resultfile incr_size)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_FILESIZE_CMP-${testname}_after_size PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_FILESIZE_INCR-${testname}
     )
     if ("H5CLEAR_FILESIZE_CMP-${testname}_after_size" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -310,7 +312,6 @@ macro (ADD_H5_FILESIZE_FAIL_TEST testname resultcode resultfile incr_size)
     add_test (
         NAME H5CLEAR_FILESIZE_FAIL_CMP-${testname}_before_size
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=--filesize;${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -320,6 +321,7 @@ macro (ADD_H5_FILESIZE_FAIL_TEST testname resultcode resultfile incr_size)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_FILESIZE_FAIL_CMP-${testname}_before_size PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_FILESIZE_FAIL_TEST-copy_${testname}
     )
     if ("H5CLEAR_FILESIZE_FAIL_CMP-${testname}_before_size" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -328,15 +330,16 @@ macro (ADD_H5_FILESIZE_FAIL_TEST testname resultcode resultfile incr_size)
     if (NOT ${incr_size} MATCHES "NONE")
         add_test (
             NAME H5CLEAR_FILESIZE_FAIL_INCR-${testname}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> -s --increment=${incr_size} ${testname}.h5
+            COMMAND $<TARGET_FILE:h5clear> -s --increment=${incr_size} ${testname}.h5
         )
     else ()
         add_test (
             NAME H5CLEAR_FILESIZE_FAIL_INCR-${testname}
-            COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> -s --increment ${testname}.h5
+            COMMAND $<TARGET_FILE:h5clear> -s --increment ${testname}.h5
         )
     endif ()
     set_tests_properties (H5CLEAR_FILESIZE_FAIL_INCR-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
         DEPENDS H5CLEAR_FILESIZE_FAIL_CMP-${testname}_before_size
     )
@@ -346,7 +349,6 @@ macro (ADD_H5_FILESIZE_FAIL_TEST testname resultcode resultfile incr_size)
     add_test (
         NAME H5CLEAR_FILESIZE_FAIL_CMP-${testname}_after_size
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5clear>"
             -D "TEST_ARGS:STRING=--filesize;${testname}.h5"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -356,6 +358,7 @@ macro (ADD_H5_FILESIZE_FAIL_TEST testname resultcode resultfile incr_size)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5CLEAR_FILESIZE_FAIL_CMP-${testname}_after_size PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR_FILESIZE_FAIL_INCR-${testname}
     )
     if ("H5CLEAR_FILESIZE_FAIL_CMP-${testname}_after_size" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -376,9 +379,10 @@ macro (ADD_H5_TEST testname testfile resultcode)
     # File open succeeds because the library does not check status_flags for file with < v3 superblock
     add_test (
         NAME H5CLEAR-clr_open_chk-${testname}_${resultcode}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:clear_open_chk> ${testfile}.h5
+        COMMAND $<TARGET_FILE:clear_open_chk> ${testfile}.h5
     )
     set_tests_properties (H5CLEAR-clr_open_chk-${testname}_${resultcode} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         WILL_FAIL "${resultcode}"
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
         DEPENDS H5CLEAR-clr_open_chk-copy_${testname}.h5
@@ -390,9 +394,10 @@ macro (ADD_H5_TEST testname testfile resultcode)
     # After "h5clear" the file, the subsequent file open succeeds
     add_test (
         NAME H5CLEAR-h5clr-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5clear> -s ${testfile}.h5
+        COMMAND $<TARGET_FILE:h5clear> -s ${testfile}.h5
     )
     set_tests_properties (H5CLEAR-h5clr-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR-clr_open_chk-${testname}_${resultcode}
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
     )
@@ -401,9 +406,10 @@ macro (ADD_H5_TEST testname testfile resultcode)
     endif ()
     add_test (
         NAME H5CLEAR-clr_open_chk-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:clear_open_chk> ${testfile}.h5
+        COMMAND $<TARGET_FILE:clear_open_chk> ${testfile}.h5
     )
     set_tests_properties (H5CLEAR-clr_open_chk-${testname} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5CLEAR-h5clr-${testname}
         WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
     )

tools/test/misc/CMakeTestsMkgrp.cmake

@@ -40,19 +40,19 @@ set (HDF5_MKGRP_TEST_FILES
 file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
 
 foreach (h5_mkgrp_file ${HDF5_MKGRP_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_mkgrp_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_mkgrp_file}" "h5mkgrp_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_mkgrp_file}" "${PROJECT_BINARY_DIR}/testfiles/${h5_mkgrp_file}" "h5mkgrp_files")
 endforeach ()
 
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/misc/expected/h5mkgrp_help.txt" "${PROJECT_BINARY_DIR}/testfiles/h5mkgrp_help.txt" "h5mkgrp_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/misc/expected/h5mkgrp_help.txt" "${PROJECT_BINARY_DIR}/testfiles/h5mkgrp_help.txt" "h5mkgrp_files")
-add_custom_target(h5mkgrp_files ALL COMMENT "Copying files needed by h5mkgrp tests" DEPENDS ${h5mkgrp_files_list})
+add_custom_target (h5mkgrp_files ALL COMMENT "Copying files needed by h5mkgrp tests" DEPENDS ${h5mkgrp_files_list})
 
 configure_file (${HDF5_TOOLS_TEST_MISC_SOURCE_DIR}/testfiles/h5mkgrp_version.txt.in ${PROJECT_BINARY_DIR}/testfiles/h5mkgrp_version.txt @ONLY)
 
 #  Generate testfiles for VOL connector(s), if any
-set(h5mkgrp_vol_files_list "")
+set (h5mkgrp_vol_files_list "")
 
 foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
-  HDF5_GET_VOL_TGT_INFO(${external_vol_tgt} vol vol_env)
+  HDF5_GET_VOL_TGT_INFO (${external_vol_tgt} vol vol_env)
 
   # Setup testfiles directory
   file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/${vol}/testfiles" RESULT)
@@ -64,13 +64,14 @@ foreach (external_vol_tgt ${HDF5_EXTERNAL_VOL_TARGETS})
 
   # Copy expected output files
   foreach (h5_mkgrp_file ${HDF5_MKGRP_TEST_FILES})
-    HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_mkgrp_file}"
+    HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/misc/expected/${h5_mkgrp_file}"
-      "${PROJECT_BINARY_DIR}/${vol}/testfiles/${h5_mkgrp_file}"
+        "${PROJECT_BINARY_DIR}/${vol}/testfiles/${h5_mkgrp_file}"
-      "h5mkgrp_vol_files")
+        "h5mkgrp_vol_files"
+    )
   endforeach ()
-endforeach()
+endforeach ()
 
-add_custom_target(h5mkgrp_vol_files ALL COMMENT "Copying files needed by h5mkgrp VOL tests" DEPENDS ${h5mkgrp_vol_files_list})
+add_custom_target (h5mkgrp_vol_files ALL COMMENT "Copying files needed by h5mkgrp VOL tests" DEPENDS ${h5mkgrp_vol_files_list})
 ##############################################################################
 ##############################################################################
 ###           T H E   T E S T S  M A C R O S                               ###
@@ -91,7 +92,7 @@ add_custom_target(h5mkgrp_vol_files ALL COMMENT "Copying files needed by h5mkgrp
 #
 macro (ADD_H5_TEST testname)
   # === Argument processing  ===
-  cmake_parse_arguments(
+  cmake_parse_arguments (
       ARG
       "" # flags
       "RESULT_CODE;RESULT_OPTION" # one value args
@@ -108,22 +109,22 @@ macro (ADD_H5_TEST testname)
   endif ()
 
   # === Adding the Test ===
-  list(LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
+  list (LENGTH HDF5_EXTERNAL_VOL_TARGETS num_ext_vols)
 
   # Add a test for the native connector and each external VOL connector
   foreach (vol_idx RANGE 0 ${num_ext_vols})
     # First, populate VOL info to be passed to tests
     if (${vol_idx} EQUAL 0)
-      set(vol "native")
+      set (vol "native")
-      set(vol_prefix "")
+      set (vol_prefix "")
-      set(vol_workdir "${PROJECT_BINARY_DIR}/testfiles")
+      set (vol_workdir "${PROJECT_BINARY_DIR}/testfiles")
     else ()
       # An external VOL connector
-      set(vol_env "")
+      set (vol_env "")
 
-      math(EXPR vol_idx_fixed "${vol_idx} - 1")
+      math (EXPR vol_idx_fixed "${vol_idx} - 1")
-      list(GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
+      list (GET HDF5_EXTERNAL_VOL_TARGETS ${vol_idx_fixed} ext_vol_tgt)
-      HDF5_GET_VOL_TGT_INFO(${ext_vol_tgt} vol vol_env)
+      HDF5_GET_VOL_TGT_INFO (${ext_vol_tgt} vol vol_env)
 
       set (vol_prefix "HDF5_VOL_${vol}-")
       set (vol_workdir "${PROJECT_BINARY_DIR}/${vol}/testfiles")
@@ -133,20 +134,21 @@ macro (ADD_H5_TEST testname)
     # == Clean up ==
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
       add_test (
-        NAME ${vol_prefix}H5MKGRP-${testname}-clear-objects
+          NAME ${vol_prefix}H5MKGRP-${testname}-clear-objects
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5delete> ${testname}.h5
+          COMMAND $<TARGET_FILE:h5delete> ${testname}.h5
       )
 
       set_tests_properties (${vol_prefix}H5MKGRP-${testname}-clear-objects PROPERTIES
-        WORKING_DIRECTORY "${vol_workdir}"
+          WORKING_DIRECTORY "${vol_workdir}"
           # h5delete will return an error code if targeted file does not exist - accept any result
-        PASS_REGULAR_EXPRESSION "^$|"
+          PASS_REGULAR_EXPRESSION "^$|"
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
 
       if (NOT "${vol}" STREQUAL "native")
         set_tests_properties (${vol_prefix}H5MKGRP-${testname}-clear-objects PROPERTIES
-          DEPENDS h5mkgrp_vol_files
+            DEPENDS h5mkgrp_vol_files
-          ENVIRONMENT "${vol_env}"
+            ENVIRONMENT "${vol_env}"
         )
       endif ()
     endif ()
@@ -154,7 +156,7 @@ macro (ADD_H5_TEST testname)
     # == Main test ==
     add_test (
         NAME ${vol_prefix}H5MKGRP-${testname}
-        COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5mkgrp> ${ARG_RESULT_OPTION} ${testname}.h5 ${ARG_UNPARSED_ARGUMENTS}
+        COMMAND $<TARGET_FILE:h5mkgrp> ${ARG_RESULT_OPTION} ${testname}.h5 ${ARG_UNPARSED_ARGUMENTS}
     )
 
     if ("${vol_prefix}H5MKGRP-${testname}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -163,14 +165,15 @@ macro (ADD_H5_TEST testname)
 
     if (NOT HDF5_ENABLE_USING_MEMCHECKER)
       set_tests_properties (${vol_prefix}H5MKGRP-${testname} PROPERTIES
-        DEPENDS ${vol_prefix}H5MKGRP-${testname}-clear-objects
+          DEPENDS ${vol_prefix}H5MKGRP-${testname}-clear-objects
+          ENVIRONMENT "${CROSSCOMPILING_PATH}"
       )
     endif()
 
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5MKGRP-${testname} PROPERTIES
-        DEPENDS h5mkgrp_vol_files
+          DEPENDS h5mkgrp_vol_files
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
       )
     endif ()
 
@@ -178,7 +181,6 @@ macro (ADD_H5_TEST testname)
     add_test (
       NAME ${vol_prefix}H5MKGRP-${testname}-h5ls
       COMMAND "${CMAKE_COMMAND}"
-          -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
           -D "TEST_PROGRAM=$<TARGET_FILE:h5ls>"
           -D "TEST_ARGS:STRING=-v;-r;${testname}.h5"
           -D "TEST_FOLDER=${vol_workdir}"
@@ -189,13 +191,14 @@ macro (ADD_H5_TEST testname)
     )
 
     set_tests_properties (${vol_prefix}H5MKGRP-${testname}-h5ls PROPERTIES
-      DEPENDS ${vol_prefix}H5MKGRP-${testname}
+        DEPENDS ${vol_prefix}H5MKGRP-${testname}
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
 
     if (NOT "${vol}" STREQUAL "native")
       set_tests_properties (${vol_prefix}H5MKGRP-${testname}-h5ls PROPERTIES
-        DEPENDS h5mkgrp_vol_files
+          DEPENDS h5mkgrp_vol_files
-        ENVIRONMENT "${vol_env}"
+          ENVIRONMENT "${vol_env}"
       )
     endif ()
 
@@ -203,15 +206,20 @@ macro (ADD_H5_TEST testname)
       set_tests_properties (${vol_prefix}H5MKGRP-${testname}-h5ls PROPERTIES DISABLED true)
     endif ()
 
-    set_tests_properties("${vol_prefix}H5MKGRP-${testname}" PROPERTIES
+    set_tests_properties ("${vol_prefix}H5MKGRP-${testname}" PROPERTIES
-      WORKING_DIRECTORY "${vol_workdir}"
+        WORKING_DIRECTORY "${vol_workdir}"
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
     )
-  endforeach() # per-VOL loop
+  endforeach () # per-VOL loop
 endmacro ()
 
 macro (ADD_H5_CMP resultfile resultcode)
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME H5MKGRP_CMP-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5mkgrp> ${ARGN})
+    add_test (NAME H5MKGRP_CMP-${resultfile} COMMAND $<TARGET_FILE:h5mkgrp> ${ARGN})
+    set_tests_properties (H5MKGRP_CMP-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
+        WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
+    )
   else ()
     add_test (
         NAME H5MKGRP_CMP-${resultfile}-clear-objects
@@ -223,7 +231,6 @@ macro (ADD_H5_CMP resultfile resultcode)
     add_test (
         NAME H5MKGRP_CMP-${resultfile}
         COMMAND "${CMAKE_COMMAND}"
-            -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
             -D "TEST_PROGRAM=$<TARGET_FILE:h5mkgrp>"
             -D "TEST_ARGS:STRING=${ARGN}"
             -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
@@ -233,6 +240,7 @@ macro (ADD_H5_CMP resultfile resultcode)
             -P "${HDF_RESOURCES_DIR}/runTest.cmake"
     )
     set_tests_properties (H5MKGRP_CMP-${resultfile} PROPERTIES
+        ENVIRONMENT "${CROSSCOMPILING_PATH}"
         DEPENDS H5MKGRP_CMP-${resultfile}-clear-objects
     )
     if ("H5MKGRP_CMP-${resultfile}" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")

tools/test/misc/CMakeTestsRepart.cmake

@@ -41,9 +41,9 @@ set (HDF5_REFERENCE_TEST_FILES
 )
 
 foreach (h5_file ${HDF5_REFERENCE_TEST_FILES})
-  HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "h5repart_files")
+  HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/testfiles/${h5_file}" "${PROJECT_BINARY_DIR}/${h5_file}" "h5repart_files")
 endforeach ()
-add_custom_target(h5repart_files ALL COMMENT "Copying files needed by h5repart tests" DEPENDS ${h5repart_files_list})
+add_custom_target (h5repart_files ALL COMMENT "Copying files needed by h5repart tests" DEPENDS ${h5repart_files_list})
 
 ##############################################################################
 ##############################################################################
@@ -82,9 +82,10 @@ set_tests_properties (H5REPART-clean-objects PROPERTIES FIXTURES_CLEANUP clear_t
 # repartition family member size to 20,000 bytes.
 add_test (
     NAME H5REPART-h5repart_20K
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repart> -m 20000 family_file%05d.h5 fst_family%05d.h5
+    COMMAND $<TARGET_FILE:h5repart> -m 20000 family_file%05d.h5 fst_family%05d.h5
 )
 set_tests_properties (H5REPART-h5repart_20K PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     FIXTURES_REQUIRED clear_testrepart
 )
 if ("H5REPART-h5repart_20K" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -94,9 +95,10 @@ endif ()
 # repartition family member size to 5 KB.
 add_test (
     NAME H5REPART-h5repart_5K
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repart> -m 5k family_file%05d.h5 scd_family%05d.h5
+    COMMAND $<TARGET_FILE:h5repart> -m 5k family_file%05d.h5 scd_family%05d.h5
 )
 set_tests_properties (H5REPART-h5repart_5K PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     FIXTURES_REQUIRED clear_testrepart
 )
 if ("H5REPART-h5repart_5K" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -106,9 +108,10 @@ endif ()
 # convert family file to sec2 file of 20,000 bytes
 add_test (
     NAME H5REPART-h5repart_single
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repart> -m 20000 -family_to_single family_file%05d.h5 family_to_single.h5
+    COMMAND $<TARGET_FILE:h5repart> -m 20000 -family_to_single family_file%05d.h5 family_to_single.h5
 )
 set_tests_properties (H5REPART-h5repart_single PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     FIXTURES_REQUIRED clear_testrepart
 )
 if ("H5REPART-h5repart_single" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -118,9 +121,10 @@ endif ()
 # convert family file to sec2 file of 20,000 bytes (old argument)
 add_test (
     NAME H5REPART-h5repart_sec2
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repart> -m 20000 -family_to_sec2 family_file%05d.h5 family_to_sec2.h5
+    COMMAND $<TARGET_FILE:h5repart> -m 20000 -family_to_sec2 family_file%05d.h5 family_to_sec2.h5
 )
 set_tests_properties (H5REPART-h5repart_sec2 PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     FIXTURES_REQUIRED clear_testrepart
 )
 if ("H5REPART-h5repart_sec2" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -130,9 +134,10 @@ endif ()
 # test the output files repartitioned above.
 add_test (
     NAME H5REPART-h5repart_test
-    COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5repart_test>
+    COMMAND $<TARGET_FILE:h5repart_test>
 )
 set_tests_properties (H5REPART-h5repart_test PROPERTIES
+    ENVIRONMENT "${CROSSCOMPILING_PATH}"
     DEPENDS "H5REPART-h5repart_20K;H5REPART-h5repart_5K;H5REPART-h5repart_single;H5REPART-h5repart_sec2"
     FIXTURES_REQUIRED clear_testrepart
 )

tools/test/perform/CMakeTests.cmake

@@ -16,8 +16,8 @@
 ##############################################################################
 ##############################################################################
 
-HDFTEST_COPY_FILE("${HDF5_TOOLS_TST_DIR}/h5dump/testfiles/tfilters.h5" "${PROJECT_BINARY_DIR}/tfilters.h5" "zip_perf_files")
+HDFTEST_COPY_FILE ("${HDF5_TOOLS_TST_DIR}/h5dump/testfiles/tfilters.h5" "${PROJECT_BINARY_DIR}/tfilters.h5" "zip_perf_files")
-add_custom_target(zip_perf_files ALL COMMENT "Copying files needed by zip_perf tests" DEPENDS ${zip_perf_list})
+add_custom_target (zip_perf_files ALL COMMENT "Copying files needed by zip_perf tests" DEPENDS ${zip_perf_list})
 
 #-----------------------------------------------------------------------------
 # Add Tests
@@ -51,10 +51,9 @@ if (HDF5_TEST_SERIAL)
   set_tests_properties (PERFORM_h5perform-clean-objects PROPERTIES FIXTURES_CLEANUP clear_perform)
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_h5perf_serial COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5perf_serial>)
+    add_test (NAME PERFORM_h5perf_serial COMMAND $<TARGET_FILE:h5perf_serial>)
   else ()
     add_test (NAME PERFORM_h5perf_serial COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:h5perf_serial>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -66,6 +65,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_h5perf_serial PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       TIMEOUT ${CTEST_VERY_LONG_TIMEOUT}
       FIXTURES_REQUIRED clear_perform
   )
@@ -74,10 +74,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_chunk COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:chunk>)
+    add_test (NAME PERFORM_chunk COMMAND $<TARGET_FILE:chunk>)
   else ()
     add_test (NAME PERFORM_chunk COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:chunk>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -89,6 +88,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_chunk PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       FIXTURES_REQUIRED clear_perform
   )
   if ("PERFORM_chunk" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -96,10 +96,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_iopipe COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:iopipe>)
+    add_test (NAME PERFORM_iopipe COMMAND $<TARGET_FILE:iopipe>)
   else ()
     add_test (NAME PERFORM_iopipe COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:iopipe>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -111,6 +110,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_iopipe PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       FIXTURES_REQUIRED clear_perform
   )
   if ("PERFORM_iopipe" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -118,10 +118,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_overhead COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:overhead>)
+    add_test (NAME PERFORM_overhead COMMAND $<TARGET_FILE:overhead>)
   else ()
     add_test (NAME PERFORM_overhead COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:overhead>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -133,6 +132,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_overhead PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       FIXTURES_REQUIRED clear_perform
   )
   if ("PERFORM_overhead" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -140,10 +140,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_perf_meta COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:perf_meta>)
+    add_test (NAME PERFORM_perf_meta COMMAND $<TARGET_FILE:perf_meta>)
   else ()
     add_test (NAME PERFORM_perf_meta COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:perf_meta>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -155,6 +154,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_perf_meta PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       FIXTURES_REQUIRED clear_perform
   )
   if ("PERFORM_perf_meta" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -162,10 +162,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_zip_perf_help COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:zip_perf> "-h")
+    add_test (NAME PERFORM_zip_perf_help COMMAND $<TARGET_FILE:zip_perf> "-h")
   else ()
     add_test (NAME PERFORM_zip_perf_help COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:zip_perf>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -177,6 +176,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_zip_perf_help PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       FIXTURES_REQUIRED clear_perform
   )
   if ("PERFORM_zip_perf_help" MATCHES "${HDF5_DISABLE_TESTS_REGEX}")
@@ -184,10 +184,9 @@ if (HDF5_TEST_SERIAL)
   endif ()
 
   if (HDF5_ENABLE_USING_MEMCHECKER)
-    add_test (NAME PERFORM_zip_perf COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:zip_perf> tfilters.h5)
+    add_test (NAME PERFORM_zip_perf COMMAND $<TARGET_FILE:zip_perf> tfilters.h5)
   else ()
     add_test (NAME PERFORM_zip_perf COMMAND "${CMAKE_COMMAND}"
-        -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
         -D "TEST_PROGRAM=$<TARGET_FILE:zip_perf>"
         -D "TEST_ARGS:STRING="
         -D "TEST_EXPECT=0"
@@ -199,6 +198,7 @@ if (HDF5_TEST_SERIAL)
     )
   endif ()
   set_tests_properties (PERFORM_zip_perf PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
       DEPENDS "PERFORM_zip_perf_help"
       FIXTURES_REQUIRED clear_perform
   )

utils/tools/h5dwalk/CMakeLists.txt

@@ -5,7 +5,7 @@ project (HDF5_UTILS_TOOLS_H5DWALK C)
 # Add the h5dwalk and test executables
 # --------------------------------------------------------------------
 add_executable (h5dwalk ${HDF5_UTILS_TOOLS_H5DWALK_SOURCE_DIR}/h5dwalk.c)
-#add_custom_target(generate_demo ALL
+#add_custom_target (generate_demo ALL
 #  DEPENDS "${HDF5_TOOLS_ROOT_DIR}/test/demo_destfiles.test"
 #)
 target_include_directories (h5dwalk PRIVATE "${HDF5_TOOLS_ROOT_DIR}/lib;${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};${CIRCLE_INCLUDE_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>")

utils/tools/test/h5dwalk/CMakeTests.cmake

@@ -16,8 +16,7 @@
 ##############################################################################
 ##############################################################################
 
-  file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
+file (MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
-
 
 ##############################################################################
 ##############################################################################
@@ -25,32 +24,33 @@
 ##############################################################################
 ##############################################################################
 
-  macro (ADD_H5_TEST resultfile resultcode)
+macro (ADD_H5_TEST resultfile resultcode)
-    # If using memchecker add tests without using scripts
+  # If using memchecker add tests without using scripts
-    if (HDF5_ENABLE_USING_MEMCHECKER)
+  if (HDF5_ENABLE_USING_MEMCHECKER)
-      message("Entered ADD_H5_TEST - 0")
+    message("Entered ADD_H5_TEST - 0")
-      add_test (NAME H5DWALK-${resultfile} COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $<TARGET_FILE:h5dwalk> ${ARGN})
+    add_test (NAME H5DWALK-${resultfile} COMMAND $<TARGET_FILE:h5dwalk> ${ARGN})
-      set_tests_properties (H5DWALK-${resultfile} PROPERTIES
+    if ("${resultcode}" STREQUAL "1")
-		WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles")
+      set_tests_properties (H5DWALK-${resultfile} PROPERTIES WILL_FAIL "true")
-      if ("${resultcode}" STREQUAL "1")
-        set_tests_properties (H5DWALK-${resultfile} PROPERTIES WILL_FAIL "true")
-      endif ()
-    else ()
-      # Remove any output file left over from previous test run
-      add_test (
-          NAME H5DWALK-${resultfile}
-          COMMAND "${CMAKE_COMMAND}"
-              -D "TEST_EMULATOR=${CMAKE_CROSSCOMPILING_EMULATOR}"
-              -D "TEST_PROGRAM=$<TARGET_FILE:h5dwalk>"
-              -D "TEST_ARGS=${ARGN}"
-              -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
-              -D "TEST_OUTPUT=${resultfile}.out"
-              -D "TEST_EXPECT=${resultcode}"
-              -D "TEST_REFERENCE=${resultfile}.h5dwalk"
-              -D "TEST_LIBRARY_DIRECTORY=${LL_PATH}"
-              -P "${HDF_RESOURCES_DIR}/runTest.cmake"
-      )
     endif ()
-  endmacro ()
+  else ()
+    # Remove any output file left over from previous test run
+    add_test (
+        NAME H5DWALK-${resultfile}
+        COMMAND "${CMAKE_COMMAND}"
+            -D "TEST_PROGRAM=$<TARGET_FILE:h5dwalk>"
+            -D "TEST_ARGS=${ARGN}"
+            -D "TEST_FOLDER=${PROJECT_BINARY_DIR}/testfiles"
+            -D "TEST_OUTPUT=${resultfile}.out"
+            -D "TEST_EXPECT=${resultcode}"
+            -D "TEST_REFERENCE=${resultfile}.h5dwalk"
+            -D "TEST_LIBRARY_DIRECTORY=${LL_PATH}"
+            -P "${HDF_RESOURCES_DIR}/runTest.cmake"
+    )
+  endif ()
+  set_tests_properties (H5DWALK-${resultfile} PROPERTIES
+      ENVIRONMENT "${CROSSCOMPILING_PATH}"
+      WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/testfiles"
+  )
+endmacro ()
 
-  ADD_H5_TEST(help-1 0 -h)
+ADD_H5_TEST(help-1 0 -h)