ci.yml

---
name: CI
permissions: {}

on:
  pull_request:
  push:
    branches:
      - master

concurrency:
  group: "${{ github.workflow }}-${{ github.ref }}"
  cancel-in-progress: true

env:
  OPENCPPCOVERAGE_VERSION: '0.9.9.0'
  PYTHON_VERSION: '3.14'

jobs:
  build:
    name: Build (${{ matrix.name }})
    permissions:
      contents: read
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: ${{ matrix.shell }}
    strategy:
      fail-fast: false
      matrix:
        include:
          - name: Linux-GCC
            os: ubuntu-latest
            shell: bash
            kind: unix
            cc: gcc
            cxx: g++
            gcov_executable: gcov
          - name: Linux-Clang
            os: ubuntu-latest
            shell: bash
            kind: unix
            cc: clang
            cxx: clang++
            # Clang writes LLVM coverage notes, so gcovr needs llvm-cov's gcov compatibility mode.
            gcov_executable: llvm-cov gcov
          - name: macOS
            os: macos-latest
            shell: bash
            kind: unix
            cc: clang
            cxx: clang++
            gcov_executable: gcov
          - name: Windows-MinGW-UCRT64
            os: windows-latest
            shell: msys2 {0}
            kind: msys2
            cc: gcc
            cxx: g++
            msystem: ucrt64
            toolchain: ucrt-x86_64
            gcov_executable: gcov
          - name: Windows-MSVC
            os: windows-2022
            shell: pwsh
            kind: msvc
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3
        with:
          submodules: recursive

      - name: Setup Dependencies Linux
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            build-essential \
            clang \
            cmake \
            libinput-dev \
            libsdl2-dev \
            libx11-dev \
            libxtst-dev \
            llvm \
            ninja-build \
            pkg-config
          kernel_modules_package="linux-modules-extra-$(uname -r)"
          if apt-cache show "${kernel_modules_package}" >/dev/null 2>&1; then
            sudo apt-get install -y "${kernel_modules_package}"
          else
            echo "::warning::${kernel_modules_package} is unavailable; relying on the runner image kernel modules."
          fi
          sudo tee /etc/udev/rules.d/99-libvirtualhid-ci.rules >/dev/null <<'EOF'
          KERNEL=="hidraw*", ATTRS{name}=="libvirtualhid*", MODE="0666", TAG+="uaccess"
          SUBSYSTEMS=="input", ATTRS{name}=="libvirtualhid*", MODE="0666", TAG+="uaccess"
          EOF
          sudo udevadm control --reload-rules
          for module in uhid uinput; do
            if ! sudo modprobe "${module}"; then
              echo "::warning::Unable to load ${module}; tests requiring /dev/${module} will fail unless the device already exists."
            fi
          done
          for node in /dev/uhid /dev/uinput; do
            if [[ -e "${node}" ]]; then
              sudo chmod a+rw "${node}"
            else
              echo "::error::${node} does not exist after module setup."
              exit 1
            fi
          done

      - name: Setup Dependencies macOS
        if: runner.os == 'macOS'
        run: |
          brew install \
            cmake \
            ninja

      - name: Setup Dependencies Windows MinGW
        if: matrix.kind == 'msys2'
        uses: msys2/setup-msys2@66cd2cce69caa17b53920067426061ca1de3a884  # v2.32.0
        with:
          msystem: ${{ matrix.msystem }}
          update: true
          install: >-
            mingw-w64-${{ matrix.toolchain }}-cmake
            mingw-w64-${{ matrix.toolchain }}-ninja
            mingw-w64-${{ matrix.toolchain }}-toolchain

      - name: Setup Dependencies Windows MSVC
        if: matrix.kind == 'msvc'
        run: |
          choco install opencppcoverage --version=${{ env.OPENCPPCOVERAGE_VERSION }} --yes --no-progress

          $openCppCoverageDir = "${env:ProgramFiles}\OpenCppCoverage"
          if (!(Test-Path (Join-Path $openCppCoverageDir "OpenCppCoverage.exe"))) {
            $openCppCoverageDir = "${env:ProgramFiles(x86)}\OpenCppCoverage"
          }
          if (!(Test-Path (Join-Path $openCppCoverageDir "OpenCppCoverage.exe"))) {
            throw "OpenCppCoverage.exe was not found after Chocolatey install."
          }

          $openCppCoverageDir | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

      - name: Setup python
        id: setup-python
        if: matrix.kind != 'msvc'
        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405  # v6.2.0
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: Setup uv
        if: matrix.kind != 'msvc'
        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39  # v8.2.0
        with:
          enable-cache: true

      - name: Sync Python tools
        if: matrix.kind != 'msvc'
        env:
          MSYS2_PATH_TYPE: inherit
          UV_PYTHON: ${{ steps.setup-python.outputs.python-path }}
        run: |
          uv sync --project third-party/lizardbyte-common --locked --only-group test-c \
            --no-python-downloads \
            --no-install-project

      - name: Configure
        if: matrix.kind != 'msvc'
        env:
          CC: ${{ matrix.cc }}
          CXX: ${{ matrix.cxx }}
        run: |
          cmake \
            -DBUILD_DOCS=OFF \
            -DBUILD_EXAMPLES=ON \
            -DBUILD_TESTS=ON \
            -DCMAKE_BUILD_TYPE:STRING=Debug \
            -B cmake-build-ci \
            -G Ninja \
            -S .

      - name: Configure MSVC
        if: matrix.kind == 'msvc'
        run: |
          cmake `
            -DBUILD_DOCS=OFF `
            -DBUILD_EXAMPLES=ON `
            -DBUILD_TESTS=ON `
            -A x64 `
            -B cmake-build-ci `
            -G "Visual Studio 17 2022" `
            -S .

      - name: Build
        if: matrix.kind != 'msvc'
        run: cmake --build cmake-build-ci -- -j2

      - name: Build MSVC
        if: matrix.kind == 'msvc'
        run: cmake --build cmake-build-ci --config Debug --parallel 2

      - name: Prepare report directory
        run: cmake -E make_directory cmake-build-ci/reports

      - name: Run tests
        id: test
        if: matrix.kind != 'msvc'
        working-directory: cmake-build-ci/tests
        run: ./test_libvirtualhid --gtest_color=yes --gtest_output=xml:../reports/junit.xml

      - name: Run tests MSVC
        id: test_msvc
        if: matrix.kind == 'msvc'
        run: |
          $openCppCoverage = (Get-Command OpenCppCoverage.exe -ErrorAction SilentlyContinue).Source
          if (!$openCppCoverage) {
            $candidates = @(
              "${env:ProgramFiles}\OpenCppCoverage\OpenCppCoverage.exe",
              "${env:ProgramFiles(x86)}\OpenCppCoverage\OpenCppCoverage.exe"
            )
            $openCppCoverage = $candidates | Where-Object { Test-Path $_ } | Select-Object -First 1
          }
          if (!$openCppCoverage) {
            throw "OpenCppCoverage.exe was not found."
          }

          & $openCppCoverage `
            --sources "$env:GITHUB_WORKSPACE\src" `
            "--export_type=cobertura:$env:GITHUB_WORKSPACE\cmake-build-ci\reports\coverage.xml" `
            --working_dir "$env:GITHUB_WORKSPACE\cmake-build-ci\tests" `
            -- `
            "$env:GITHUB_WORKSPACE\cmake-build-ci\tests\Debug\test_libvirtualhid.exe" `
            --gtest_color=yes `
            "--gtest_output=xml:$env:GITHUB_WORKSPACE\cmake-build-ci\reports\junit.xml"

      - name: Normalize MSVC coverage paths
        if: >-
          always() &&
          matrix.kind == 'msvc' &&
          (steps.test_msvc.outcome == 'success' || steps.test_msvc.outcome == 'failure')
        run: |
          $coveragePath = Join-Path $env:GITHUB_WORKSPACE "cmake-build-ci\reports\coverage.xml"
          if (!(Test-Path $coveragePath)) {
            return
          }

          [xml] $coverage = Get-Content $coveragePath
          $workspace = $env:GITHUB_WORKSPACE.Replace('\', '/')
          foreach ($node in $coverage.SelectNodes('//*[@filename]')) {
            $filename = $node.GetAttribute('filename').Replace('\', '/')
            if ($filename.StartsWith("${workspace}/")) {
              $filename = $filename.Substring($workspace.Length + 1)
            }

            $node.SetAttribute('filename', $filename)
          }

          foreach ($source in $coverage.SelectNodes('//source')) {
            $source.InnerText = '.'
          }

          $coverage.Save($coveragePath)

      - name: Generate gcov report
        id: test_report
        if: >-
          always() &&
          matrix.kind != 'msvc' &&
          (steps.test.outcome == 'success' || steps.test.outcome == 'failure')
        working-directory: cmake-build-ci
        env:
          GCOV_EXECUTABLE: ${{ matrix.gcov_executable }}
          MSYS2_PATH_TYPE: inherit
        run: |
          uv run --project ../third-party/lizardbyte-common --locked --no-sync gcovr . -r ../src \
            --gcov-executable "${GCOV_EXECUTABLE}" \
            --exclude-noncode-lines \
            --exclude-throw-branches \
            --exclude-unreachable-branches \
            --verbose \
            --xml-pretty \
            -o reports/coverage.xml

      - name: Run gamepad adapter example
        if: matrix.kind != 'msvc'
        run: |
          if [[ "${RUNNER_OS}" == "Windows" ]]; then
            ./cmake-build-ci/examples/gamepad_adapter.exe
          else
            ./cmake-build-ci/examples/gamepad_adapter
          fi

      - name: Run gamepad adapter example MSVC
        if: matrix.kind == 'msvc'
        run: .\cmake-build-ci\examples\Debug\gamepad_adapter.exe

      - name: Install
        if: matrix.kind != 'msvc'
        run: cmake --install cmake-build-ci --prefix cmake-build-ci/install

      - name: Install MSVC
        if: matrix.kind == 'msvc'
        run: cmake --install cmake-build-ci --config Debug --prefix cmake-build-ci/install

      - name: Upload install artifact
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
        with:
          name: install-${{ matrix.name }}
          path: cmake-build-ci/install
          if-no-files-found: error

      - name: Upload report artifact
        if: >-
          always() &&
          (
            steps.test_report.outcome == 'success' ||
            steps.test_msvc.outcome == 'success' ||
            steps.test_msvc.outcome == 'failure'
          )
        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
        with:
          name: reports-${{ matrix.name }}
          path: cmake-build-ci/reports
          if-no-files-found: error

  codecov:
    name: Codecov-${{ matrix.flag }}
    if: >-
      always() &&
      (needs.build.result == 'success' || needs.build.result == 'failure') &&
      startsWith(github.repository, 'LizardByte/')
    needs: build
    permissions:
      contents: read
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
          - build_name: Linux-GCC
            flag: Linux-GCC
            has_coverage: true
          - build_name: Linux-Clang
            flag: Linux-Clang
            has_coverage: true
          - build_name: macOS
            flag: macOS
            has_coverage: true
          - build_name: Windows-MinGW-UCRT64
            flag: Windows-MinGW-UCRT64
            has_coverage: true
          - build_name: Windows-MSVC
            flag: Windows-MSVC
            has_coverage: true
    steps:
      - name: Checkout
        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10  # v6.0.3

      - name: Download report artifact
        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
        with:
          name: reports-${{ matrix.build_name }}
          path: _reports

      - name: Debug coverage file
        if: matrix.has_coverage
        run: cat _reports/coverage.xml

      - name: Upload test coverage
        if: matrix.has_coverage
        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
        with:
          disable_search: true
          fail_ci_if_error: true
          files: ./_reports/coverage.xml
          report_type: coverage
          flags: ${{ matrix.flag }}
          token: ${{ secrets.CODECOV_TOKEN }}
          verbose: true

      - name: Upload test results
        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
        with:
          disable_search: true
          fail_ci_if_error: true
          files: ./_reports/junit.xml
          report_type: test_results
          flags: ${{ matrix.flag }}
          token: ${{ secrets.CODECOV_TOKEN }}
          verbose: true