name: hdf5 dev CI

# Controls when the action will run. Triggers the workflow on push or pull request
on:
  workflow_dispatch:
  push:
  pull_request:
    branches: [ develop, hdf5_1_12, hdf5_1_10, hdf5_1_8 ]
    paths-ignore:
      - '.github/CODEOWNERS'
      - '.github/FUNDING.yml'
      - 'doc/**'
      - 'release_docs/**'
      - 'ACKNOWLEDGEMENTS'
      - 'COPYING**'
      - '**.md'
    
# A workflow run is made up of one or more jobs that can run sequentially or
# in parallel. We just have one job, but the matrix items defined below will
# run in parallel.
jobs:

  # A workflow that builds the library and runs all the tests
  build_and_test:

    strategy:

      # The current matrix has three dimensions:
      #
      # * config name
      # * thread-safety on/off
      # * release vs. debug build
      #
      # Most configuration information is added via the 'include' mechanism,
      # which will append the key-value pairs in the configuration where the
      # names match.

      matrix:

        name:
          - "Windows MSVC CMake"
          - "Ubuntu gcc CMake"
          - "Ubuntu gcc Autotools"
          - "Ubuntu gcc Autotools parallel (build only)"
          - "MacOS Clang CMake"

        thread_safety:
          - enabled: true
            text: " TS"
          - enabled: false
            text: ""

        build_mode:
          - text: " REL"
            cmake: "Release"
            autotools: "production"
          - text: " DBG"
            cmake: "Debug"
            autotools: "debug"

        # This is where we list the bulk of the options for each configuration.
        # The key-value pair values are usually appropriate for being CMake or
        # Autotools configure values, so be aware of that.

        include:

          # Windows w/ MSVC + CMake
          #
          # No Fortran, parallel, or VFDs that rely on POSIX things
          - name: "Windows MSVC CMake"
            os: windows-2022
            toolchain: ""
            cpp: ON
            fortran: OFF
            java: ON
            parallel: OFF
            mirror_vfd: OFF
            direct_vfd: OFF
            generator: "-G \"Visual Studio 17 2022\" -A x64"
            run_tests: true

          # Linux (Ubuntu) w/ gcc + CMake
          #
          # We might think about adding Clang, but MacOS already tests that
          # so it's not critical
          - name: "Ubuntu gcc CMake"
            os: ubuntu-latest
            cpp: ON
            fortran: ON
            java: ON
            parallel: OFF
            mirror_vfd: ON
            direct_vfd: ON
            toolchain: "config/toolchain/GCC.cmake"
            generator: "-G Ninja"
            run_tests: true

          # Linux (Ubuntu) w/ gcc + Autotools
          #
          # Keep this identical to the CMake configs. Note the difference in
          # the values.
          - name: "Ubuntu gcc Autotools"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v114
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: true

          # Parallel Linux (Ubuntu) w/ gcc + Autotools
          #
          # The GitHub runners are inadequate for running parallel HDF5 tests,
          # so we catch most issues in daily testing. What we have here is just
          # a compile check to make sure nothing obvious is broken.
          - name: "Ubuntu gcc Autotools parallel (build only)"
            os: ubuntu-latest
            cpp: disable
            fortran: enable
            java: disable
            parallel: enable
            mirror_vfd: disable
            direct_vfd: disable
            deprec_sym: enable
            default_api: v114
            toolchain: ""
            generator: "autogen"
            flags: "CC=mpicc"
            run_tests: false

          # MacOS w/ Clang + CMake
          #
          # We could also build with the Autotools via brew installing them,
          # but that seems unnecessary
          - name: "MacOS Clang CMake"
            os: macos-latest
            cpp: ON
            fortran: OFF
            java: ON
            parallel: OFF
            mirror_vfd: ON
            direct_vfd: OFF
            toolchain: "config/toolchain/clang.cmake"
            generator: "-G Ninja"
            run_tests: true


          #
          # SPECIAL AUTOTOOLS BUILDS
          #
          # These do not run tests and are not built into the matrix and instead
          # become NEW configs as their name would clobber one of the matrix
          # names (so make sure the names are UNIQUE).
          #

          - name: "Ubuntu gcc Autotools v1.6 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v16
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.8 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v18
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.10 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v110
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools v1.12 default API (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v112
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools no deprecated symbols (build only)"
            os: ubuntu-latest
            cpp: enable
            fortran: enable
            java: enable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: disable
            default_api: v114
            toolchain: ""
            generator: "autogen"
            flags: ""
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools -Werror (build only) DBG"
            os: ubuntu-latest
            cpp: enable
            fortran: disable
            java: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v114
            toolchain: ""
            generator: "autogen"
            flags: "CFLAGS=-Werror"
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "DBG"
                cmake: "Debug"
                autotools: "debug"

          - name: "Ubuntu gcc Autotools -Werror (build only) REL"
            os: ubuntu-latest
            cpp: enable
            fortran: disable
            java: disable
            parallel: disable
            mirror_vfd: enable
            direct_vfd: enable
            deprec_sym: enable
            default_api: v114
            toolchain: ""
            generator: "autogen"
            flags: "CFLAGS=-Werror"
            run_tests: false
            thread_safety:
              - enabled: false
                text: ""
            build_mode:
              - text: "REL"
                cmake: "Release"
                autotools: "production"

    # Sets the job's name from the properties
    name: "${{ matrix.name }}${{ matrix.build_mode.text }}${{ matrix.thread_safety.text }}"

    # Don't run the action if the commit message says to skip CI
    if: "!contains(github.event.head_commit.message, 'skip-ci')"

    # The type of runner that the job will run on
    runs-on: ${{ matrix.os }}

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:

      #
      # SETUP
      #

      - name: Install CMake Dependencies (Linux)
        run: sudo apt-get install ninja-build
        if: matrix.os == 'ubuntu-latest'

      - name: Install Autotools Dependencies (Linux, serial)
        run: |
           sudo apt update
           sudo apt install automake autoconf libtool libtool-bin
           sudo apt install gcc-11 g++-11 gfortran-11
           echo "CC=gcc-11" >> $GITHUB_ENV
           echo "CXX=g++-11" >> $GITHUB_ENV
           echo "FC=gfortran-11" >> $GITHUB_ENV
        if: (matrix.generator == 'autogen') && (matrix.parallel != 'enable')

      - name: Install Autotools Dependencies (Linux, parallel)
        run: |
           sudo apt update
           sudo apt install automake autoconf libtool libtool-bin
           sudo apt install openmpi-bin openmpi-common
           echo "CC=mpicc" >> $GITHUB_ENV
           echo "FC=mpif90" >> $GITHUB_ENV
        if: (matrix.generator == 'autogen') && (matrix.parallel == 'enable')

      - name: Install Dependencies (Windows)
        run: choco install ninja
        if: matrix.os == 'windows-latest'

      - name: Install Dependencies (macOS)
        run: brew install ninja
        if: matrix.os == 'macos-latest'

      - name: Set environment for MSVC (Windows)
        run: |
          # Set these environment variables so CMake picks the correct compiler
          echo "CXX=cl.exe" >> $GITHUB_ENV
          echo "CC=cl.exe" >> $GITHUB_ENV
        if:  matrix.os == 'windows-latest'
    
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - name: Get Sources
        uses: actions/checkout@v3

      #
      # AUTOTOOLS CONFIGURE
      #

      - name: Autotools Configure
        run: |
          sh ./autogen.sh
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          ${{ matrix.flags }} $GITHUB_WORKSPACE/configure --enable-build-mode=${{ matrix.build_mode.autotools }} --${{ matrix.deprec_sym }}-deprecated-symbols --with-default-api-version=${{ matrix.default_api }} --enable-shared --${{ matrix.parallel }}-parallel --${{ matrix.cpp }}-cxx --${{ matrix.fortran }}-fortran --${{ matrix.java }}-java --${{ matrix.mirror_vfd }}-mirror-vfd --${{ matrix.direct_vfd }}-direct-vfd
        shell: bash
        if: (matrix.generator == 'autogen') && (! matrix.thread_safe.enabled)

      - name: Autotools Configure (Thread-Safe)
        run: |
          sh ./autogen.sh
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          ${{ matrix.flags }} $GITHUB_WORKSPACE/configure --enable-build-mode=${{ matrix.build_mode.autotools }} --enable-shared --enable-threadsafe --disable-hl --${{ matrix.parallel }}-parallel --${{ matrix.mirror_vfd }}-mirror-vfd --${{ matrix.direct_vfd }}-direct-vfd
        shell: bash
        if: (matrix.generator == 'autogen') && (matrix.thread_safe.enabled)

      #
      # CMAKE CONFIGURE
      #

      - name: CMake Configure
        run: |
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          cmake ${{ matrix.generator }} -DCMAKE_BUILD_TYPE=${{ matrix.build_mode.cmake }} -DCMAKE_TOOLCHAIN_FILE=${{ matrix.toolchain }} -DBUILD_SHARED_LIBS=ON -DHDF5_ENABLE_ALL_WARNINGS=ON -DHDF5_ENABLE_PARALLEL:BOOL=${{ matrix.parallel }} -DHDF5_BUILD_CPP_LIB:BOOL=${{ matrix.cpp }} -DHDF5_BUILD_FORTRAN=${{ matrix.fortran }} -DHDF5_BUILD_JAVA=${{ matrix.java }} -DHDF5_ENABLE_MIRROR_VFD:BOOL=${{ matrix.mirror_vfd }} -DHDF5_ENABLE_DIRECT_VFD:BOOL=${{ matrix.direct_vfd }} $GITHUB_WORKSPACE
        shell: bash
        if: (matrix.generator != 'autogen') && (! matrix.thread_safe.enabled)


      - name: CMake Configure (Thread-Safe)
        run: |
          mkdir "${{ runner.workspace }}/build"
          cd "${{ runner.workspace }}/build"
          cmake ${{ matrix.generator }} -DCMAKE_BUILD_TYPE=${{ matrix.build_mode.cmake }} -DCMAKE_TOOLCHAIN_FILE=${{ matrix.toolchain }} -DBUILD_SHARED_LIBS=ON -DHDF5_ENABLE_ALL_WARNINGS=ON -DHDF5_ENABLE_THREADSAFE:BOOL=ON -DHDF5_ENABLE_PARALLEL:BOOL=${{ matrix.parallel }} -DHDF5_BUILD_HL_LIB:BOOL=OFF -DHDF5_ENABLE_MIRROR_VFD:BOOL=${{ matrix.mirror_vfd }} -DHDF5_ENABLE_DIRECT_VFD:BOOL=${{ matrix.direct_vfd }} $GITHUB_WORKSPACE
        shell: bash
        if: (matrix.generator != 'autogen') && (matrix.thread_safe.enabled)

      #
      # BUILD
      #

      - name: Autotools Build
        run: make
        working-directory: ${{ runner.workspace }}/build
        if: matrix.generator == 'autogen'

      - name: CMake Build
        run: cmake --build . --config ${{ matrix.build_mode.cmake }}
        working-directory: ${{ runner.workspace }}/build
        if: matrix.generator != 'autogen'

      #
      # RUN TESTS
      #

      - name: Autotools Run Tests
        run: make check
        working-directory: ${{ runner.workspace }}/build
        if: (matrix.generator == 'autogen') && (matrix.run_tests)

      - name: CMake Run Tests
        run: ctest --build . -C ${{ matrix.build_mode.cmake }} -V
        working-directory: ${{ runner.workspace }}/build
        # Skip Debug MSVC while we investigate H5L Java test timeouts
        if: (matrix.generator != 'autogen') && (matrix.run_tests) && ! ((matrix.name == 'Windows MSVC CMake') && (matrix.build_mode.cmake == 'Debug'))