crc-fast 1.10.0

name: Tests

on:
  push:
  pull_request:
  workflow_dispatch:

jobs:
  check-previous-run:
    name: Check for previous successful run
    runs-on: ubuntu-latest
    outputs:
      should_skip: ${{ steps.check.outputs.should_skip }}
    steps:
      - name: Check if commit was already tested
        id: check
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          echo "Current commit: ${{ github.sha }}"
          echo "Current ref: ${{ github.ref }}"
          
          # Check if there's a previous successful workflow run for this exact commit
          PREVIOUS_RUN=$(gh api \
            -H "Accept: application/vnd.github+json" \
            "/repos/${{ github.repository }}/actions/workflows/tests.yml/runs?status=success&per_page=5" \
            --jq '.workflow_runs[] | select(.head_sha == "${{ github.sha }}") | .id' \
            | head -n 1)
          
          if [ -n "$PREVIOUS_RUN" ] && [ "$PREVIOUS_RUN" != "${{ github.run_id }}" ]; then
            echo "Found previous successful run: $PREVIOUS_RUN"
            echo "should_skip=true" >> $GITHUB_OUTPUT
          else
            echo "No previous successful run found for this commit"
            echo "should_skip=false" >> $GITHUB_OUTPUT
          fi

  test-aarch64:
    name: Test aarch64
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    strategy:
      matrix:
        os: [ubuntu-22.04-arm, ubuntu-24.04-arm, macos-14, macos-15, macos-26, macos-latest, windows-11-arm]
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          components: rustfmt, clippy
          cache-key: ${{ matrix.os }}-${{ matrix.rust-toolchain }}-v2
      - name: Check
        run: cargo check --all-features
      - name: Architecture check
        run: cargo run --features cli --bin arch-check
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Format
        run: cargo fmt -- --check
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Clippy
        run: cargo clippy --all-features -- -D warnings
      - name: Test
        run: cargo test --all-features

  test-x86_64:
    name: Test x86_64
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    strategy:
      matrix:
        os: [ ubuntu-latest, ubuntu-22.04, ubuntu-24.04, macos-15-intel, windows-2022, windows-2025, windows-latest ]
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          components: rustfmt, clippy
          cache-key: ${{ matrix.os }}-${{ matrix.rust-toolchain }}-v2
      - name: Check
        run: cargo check --all-features
      - name: Architecture check
        run: cargo run --features cli --bin arch-check
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Format
        run: cargo fmt -- --check
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Clippy
        run: cargo clippy --all-features -- -D warnings
      - name: Test
        run: cargo test --all-features

  test-x86-linux:
    name:  Test x86 Linux
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ubuntu-latest
    strategy:
      matrix:
        target: [i586-unknown-linux-gnu, i686-unknown-linux-gnu]
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          components: rustfmt, clippy
      - name: Set up cross
        run: cargo install cross --locked --version 0.2.5
      - name: Check
        run: cross check --all-features --target ${{ matrix.target }}
      - name: Architecture check
        run: cross run --features cli --bin arch-check --target ${{ matrix.target }}
      - name: Test
        run: cross test --all-features --target ${{ matrix.target }}

  test-x86-windows:
    name: Test x86 Windows
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: windows-2022
    strategy:
      matrix:
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          target: i686-pc-windows-msvc
          components: rustfmt, clippy
          cache-key: windows-x86-${{ matrix.rust-toolchain }}
      - name: Check
        run: cargo check --all-features --target i686-pc-windows-msvc
      - name: Architecture check
        run: cargo run --features cli --bin arch-check --target i686-pc-windows-msvc
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Format
        run: cargo fmt -- --check
      - if: ${{ matrix.rust-toolchain != 'nightly' }}
        name: Clippy
        run: cargo clippy --all-features --target i686-pc-windows-msvc -- -D warnings
      - name: Test
        run: cargo test --all-features --target i686-pc-windows-msvc

  test-software:
    name: Test software fallback
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ubuntu-latest
    strategy:
      matrix:
        target: [powerpc-unknown-linux-gnu, powerpc64-unknown-linux-gnu]
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          components: rustfmt, clippy
      - name: Set up cross
        run: cargo install cross --locked --version 0.2.5
      - name: Check
        run: cross check --all-features --target ${{ matrix.target }}
      - name: Architecture check
        run: cross run --features cli --bin arch-check --target ${{ matrix.target }}
      - name: Test
        run: cross test --all-features --target ${{ matrix.target }}

  miri-test-x86_64:
    name: Miri Test x86_64
    needs: [check-previous-run, test-x86_64]
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9
        with:
          toolchain: nightly
          components: miri
      - name: Detect CPU cores
        id: cores
        run: |
          CORES=$(nproc)
          echo "count=$CORES" >> $GITHUB_OUTPUT
          echo "use_nextest=$([[ $CORES -ge 2 ]] && echo 'true' || echo 'false')" >> $GITHUB_OUTPUT
      - name: Install nextest
        if: steps.cores.outputs.use_nextest == 'true'
        run: cargo install cargo-nextest --locked
      - name: Setup Miri
        run: cargo miri setup
      - name: Run Miri tests (parallel)
        if: steps.cores.outputs.use_nextest == 'true'
        run: cargo miri nextest run --all-features -j${{ steps.cores.outputs.count }}
      - name: Run Miri tests (serial)
        if: steps.cores.outputs.use_nextest == 'false'
        run: cargo miri test --all-features

  test-no-std:
    name: Test no_std
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ubuntu-latest
    strategy:
      matrix:
        target:
          - thumbv7em-none-eabihf  # ARM Cortex-M4F/M7F
          - thumbv8m.main-none-eabihf  # ARM Cortex-M33/M35P
          - riscv32imac-unknown-none-elf  # RISC-V 32-bit
        rust-toolchain:
          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - "stable"
          - "nightly"
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          target: ${{ matrix.target }}
          components: rustfmt, clippy
          cache-key: ${{ matrix.target }}-${{ matrix.rust-toolchain }}-v2
      - name: Check no_std (no features)
        run: cargo check --target ${{ matrix.target }} --no-default-features --features panic-handler --lib
      - name: Check no_std with alloc
        run: cargo check --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib
      - name: Check no_std with cache
        run: cargo check --target ${{ matrix.target }} --no-default-features --features cache,panic-handler --lib
      - name: Run no_std tests (on host with std test harness)
        run: cargo test --test no_std_tests

  test-wasm:
    name: Test WASM
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ubuntu-latest
    strategy:
      matrix:
        include:
          # WASM 1.0/2.0 (32-bit) - all toolchains
          - target: wasm32-unknown-unknown
            rust-toolchain: "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - target: wasm32-unknown-unknown
            rust-toolchain: "stable"
          - target: wasm32-unknown-unknown
            rust-toolchain: "nightly"
          # WASI preview 1 (32-bit) - all toolchains
          - target: wasm32-wasip1
            rust-toolchain: "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized
          - target: wasm32-wasip1
            rust-toolchain: "stable"
          - target: wasm32-wasip1
            rust-toolchain: "nightly"
          # WASI preview 2 (32-bit) - nightly only (experimental)
          - target: wasm32-wasip2
            rust-toolchain: "nightly"
          # Note: wasm64-unknown-unknown removed - not consistently available in nightly
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: ${{ matrix.rust-toolchain }}
          target: ${{ matrix.target }}
          components: rustfmt, clippy
          cache-key: ${{ matrix.target }}-${{ matrix.rust-toolchain }}-v2
      - name: Check WASM (no features)
        run: cargo check --target ${{ matrix.target }} --no-default-features --features panic-handler --lib
      - name: Check WASM with alloc
        run: cargo check --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib
      - name: Check WASM with cache
        run: cargo check --target ${{ matrix.target }} --no-default-features --features cache,panic-handler --lib
      - name: Build WASM release
        run: cargo build --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib --release
      - name: Run WASM tests (on host with std test harness)
        run: cargo test --test wasm_tests
      - if: ${{ matrix.target == 'wasm32-unknown-unknown' && matrix.rust-toolchain == 'stable' }}
        name: Install wasm-pack
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
      - if: ${{ matrix.target == 'wasm32-unknown-unknown' && matrix.rust-toolchain == 'stable' }}
        name: Build WASM package with wasm-pack
        run: wasm-pack build --target web --no-default-features --features alloc,panic-handler

  fuzz-test:
    name: Fuzz Testing
    needs: check-previous-run
    if: needs.check-previous-run.outputs.should_skip != 'true'
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-24.04, ubuntu-24.04-arm]
        fuzz-target:
          - digest_crc32_autosar
          - digest_crc32_bzip2
          - digest_crc32_iscsi
          - digest_crc32_iso_hdlc
          - digest_crc64_ecma_182
          - digest_crc64_nvme
          - checksum_crc32_autosar
          - checksum_crc32_bzip2
          - checksum_crc32_iscsi
          - checksum_crc32_iso_hdlc
          - checksum_crc64_ecma_182
          - checksum_crc64_nvme
    steps:
      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust
      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0
        with:
          toolchain: nightly
          cache-key: ${{ matrix.os }}-nightly-fuzz
      - name: Install cargo-fuzz
        run: cargo install cargo-fuzz
      - name: Run fuzzer
        run: |
          cargo fuzz run ${{ matrix.fuzz-target }} -- \
            -max_total_time=60 \
            -rss_limit_mb=2048 \
            -timeout=10 \
            -print_final_stats=1
        continue-on-error: true
      - name: Upload artifacts on crash
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: fuzz-artifacts-${{ matrix.os }}-${{ matrix.fuzz-target }}
          path: fuzz/artifacts/${{ matrix.fuzz-target }}/

  tests-complete:
    name: All tests complete
    needs: [check-previous-run, test-aarch64, test-x86_64, test-x86-linux, test-x86-windows, test-software, miri-test-x86_64, test-no-std, test-wasm, fuzz-test]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Check test results
        run: |
          echo "Checking test results..."
          echo "Previous run check: ${{ needs.check-previous-run.result }}"
          echo "Should skip: ${{ needs.check-previous-run.outputs.should_skip }}"
          
          if [ "${{ needs.check-previous-run.outputs.should_skip }}" == "true" ]; then
            echo "✓ Tests were skipped because this commit was already tested successfully"
            exit 0
          fi
          
          # Check if any test job failed
          if [ "${{ needs.test-aarch64.result }}" == "failure" ] || \
             [ "${{ needs.test-x86_64.result }}" == "failure" ] || \
             [ "${{ needs.test-x86-linux.result }}" == "failure" ] || \
             [ "${{ needs.test-x86-windows.result }}" == "failure" ] || \
             [ "${{ needs.test-software.result }}" == "failure" ] || \
             [ "${{ needs.miri-test-x86_64.result }}" == "failure" ] || \
             [ "${{ needs.test-no-std.result }}" == "failure" ] || \
             [ "${{ needs.test-wasm.result }}" == "failure" ] || \
             [ "${{ needs.fuzz-test.result }}" == "failure" ]; then
            echo "✗ One or more test jobs failed"
            exit 1
          fi
          
          echo "✓ All test jobs passed"