.github/workflows/ci.yml

# For details, see README.md in this directory.

###############################################################
# C compilers
#
# - gcc
# - clang
#
# Known Issue
# - All test cases which described as 'fail' must be fixed and replaced with 'true'.
#   - gcc-11 (x32, x86) : "../lib/lz4hc.c:148: LZ4HC_countBack: Assertion `(size_t)(match - mMin) < (1U<<31)' failed."
#   - all clangs (x32, x86) : "../lib/lz4hc.c:282: int LZ4HC_InsertAndGetWiderMatch(...): Assertion `matchPtr >= lowPrefixPtr' failed."
#
name: lz4 CI
on: [push, pull_request]
permissions:
  contents: read

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

jobs:
  lz4-c-compilers:
    name: CC=${{ matrix.cc }}, ${{ matrix.os }}
    strategy:
      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix failed.
      matrix:
        include: [
          # You can access the following values via ${{ matrix.??? }}
          #
          #   pkgs         : apt-get package names.  It can include multiple package names which are delimited by space.
          #   cc           : C compiler executable.
          #   cxx          : C++ compiler executable for targets `cxxtest` and `ctocxxtest`.
          #   x32          : Set 'true' if compiler supports x32.  Otherwise, set 'false'.
          #                  Set 'fail' if it supports x32 but fails for now.  'fail' cases must be removed.
          #   x86          : Set 'true' if compiler supports x86 (-m32).  Otherwise, set 'false'.
          #                  Set 'fail' if it supports x86 but fails for now.  'fail' cases must be removed.
          #   cxxtest      : Set 'true' if it can be compiled as C++ code.  Otherwise, set 'false'.
          #   freestanding : Set 'true' if it can be compiled and execute freestanding code.  Otherwise, set 'false'.
          #                  Usually, it requires Linux, x86_64 and gcc/g++.
          #   os           : GitHub Actions YAML workflow label.  See https://github.com/actions/virtual-environments#available-environments

          # cc
          { pkgs: '',                                                   cc: cc,        cxx: c++,         x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-latest, },

          # gcc
          { pkgs: '',                                                   cc: gcc,       cxx: g++,         x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-latest, },
          { pkgs: 'gcc-13 g++-13 lib32gcc-13-dev libx32gcc-13-dev',     cc: gcc-13,    cxx: g++-13,      x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-22.04,  },
          { pkgs: 'gcc-12 g++-12 lib32gcc-12-dev libx32gcc-12-dev',     cc: gcc-12,    cxx: g++-12,      x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-22.04,  },
          { pkgs: 'gcc-11 g++-11 lib32gcc-11-dev libx32gcc-11-dev',     cc: gcc-11,    cxx: g++-11,      x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-22.04,  },
          { pkgs: 'gcc-10 g++-10 lib32gcc-10-dev libx32gcc-10-dev',     cc: gcc-10,    cxx: g++-10,      x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-22.04,  },
          { pkgs: 'gcc-9 g++-9 lib32gcc-9-dev libx32gcc-9-dev',         cc: gcc-9,     cxx: g++-9,       x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-22.04,  },
          { pkgs: 'gcc-8 g++-8 lib32gcc-8-dev libx32gcc-8-dev',         cc: gcc-8,     cxx: g++-8,       x32: 'true', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-20.04,  },
          { pkgs: 'gcc-7 g++-7 lib32gcc-7-dev libx32gcc-7-dev',         cc: gcc-7,     cxx: g++-7,       x32: 'true', x86: 'true', cxxtest: 'true',  freestanding: 'true',  os: ubuntu-20.04,  },

          # clang
          { pkgs: 'lib32gcc-13-dev libx32gcc-13-dev',                   cc: clang,     cxx: clang++,     x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-latest, },
          { pkgs: 'clang-15  lib32gcc-13-dev libx32gcc-13-dev',         cc: clang-15,  cxx: clang++-15,  x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-22.04,  },
          { pkgs: 'clang-14  lib32gcc-13-dev libx32gcc-13-dev',         cc: clang-14,  cxx: clang++-14,  x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-22.04,  },
          { pkgs: 'clang-13  lib32gcc-13-dev libx32gcc-13-dev',         cc: clang-13,  cxx: clang++-13,  x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-22.04,  },
          { pkgs: 'clang-12  lib32gcc-13-dev libx32gcc-13-dev',         cc: clang-12,  cxx: clang++-12,  x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-22.04,  },
          { pkgs: 'clang-11  lib32gcc-12-dev libx32gcc-12-dev',         cc: clang-11,  cxx: clang++-11,  x32: 'false', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-22.04,  },
          { pkgs: 'clang-10  lib32gcc-11-dev libx32gcc-11-dev',         cc: clang-10,  cxx: clang++-10,  x32: 'fail', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-20.04,  },
          { pkgs: 'clang-9   lib32gcc-11-dev libx32gcc-11-dev',         cc: clang-9,   cxx: clang++-9,   x32: 'fail', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-20.04,  },
          { pkgs: 'clang-8   lib32gcc-11-dev libx32gcc-11-dev',         cc: clang-8,   cxx: clang++-8,   x32: 'fail', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-20.04,  },
          { pkgs: 'clang-7   lib32gcc-7-dev  libx32gcc-7-dev',          cc: clang-7,   cxx: clang++-7,   x32: 'fail', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-20.04,  },
          { pkgs: 'clang-6.0 lib32gcc-11-dev libx32gcc-11-dev',         cc: clang-6.0, cxx: clang++-6.0, x32: 'fail', x86: 'true', cxxtest: 'true',  freestanding: 'false', os: ubuntu-20.04,  },
        ]

    runs-on: ${{ matrix.os }}
    env:                        # Set environment variables
      # We globally set CC and CXX to improve compatibility
      CC: ${{ matrix.cc }}
      CXX: ${{ matrix.cxx }}
      FIXME__LZ4_CI_IGNORE : ' echo Error.  But we ignore it for now.'
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib
        sudo apt-get install ${{ matrix.pkgs }}

    - name: Environment info
      run: |
        echo && type $CC && which $CC && $CC --version
        echo && type $CXX && which $CXX && $CXX --version

    - name: make
      if: always()
      run: make -j V=1

    - name: install test
      if: always()
      run: make -C tests test-install V=1

    - name: make all
      if: always()
      run: make clean; CFLAGS="-Werror -O0" make -j all V=1

    - name: make c_standards (C90)
      if: always()
      run: make clean; make -j c_standards_c90 V=1

    - name: make c_standards (C11)
      if: always()
      run: make clean; make -j c_standards_c11 V=1

    - name: c lib for c++ program
      if: ${{ matrix.cxxtest == 'true' }}
      run: make clean; make -j ctocxxtest V=1

    - name: compiled as c++ source
      if: ${{ matrix.cxxtest == 'true' }}
      run: make clean; make -j cxxtest V=1

    - name: make test-freestanding
      if: ${{ matrix.freestanding == 'true' }}
      run: make clean; make test-freestanding V=1

    - name: make -C programs default -D_FORTIFY_SOURCE=2
      if: always()
      run: make clean; CFLAGS='-fPIC' LDFLAGS='-pie -fPIE -D_FORTIFY_SOURCE=2' make -j -C programs default V=1

    - name: make -C tests test-lz4
      if: always()
      run: make clean; make -j V=1 -C tests test-lz4

    - name: make -C tests test CFLAGS='-mx32'
      if: ${{ matrix.x32 == 'true' }}
      run: make clean; CFLAGS='-mx32' make -j -C tests test V=1

    - name: make -C tests test-lz4c32
      if: ${{ matrix.x86 == 'true' }}
      run: make clean; CFLAGS='-Werror -O1' make -j -C tests test-lz4c32 V=1


    ###############################################################
    #                                                             #
    #      Remove this block when we relevant tests run properly  #
    #                                                             #

    - name: make -C tests test CFLAGS='-mx32' || echo Ignore failure for now.
      if: ${{ matrix.x32 == 'fail' }}
      run: make clean; CFLAGS='-mx32' make -C tests test V=1 || $FIXME__LZ4_CI_IGNORE

    #                                                             #
    ###############################################################


###############################################################
# LZ4 self tests
#
# - Fullbench
# - Fuzzer
# - LZ4 Frame
# - LZ4 versions
# - Custom LZ4_DISTANCE_MAX
#
  lz4-benchmark:
    name: Fullbench
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib

    - name: test-lz4
      run: make -j -C tests test-lz4 V=1

    - name: test-lz4c
      run: make -j -C tests test-lz4c V=1

    - name: test-lz4c32
      run: make -j -C tests test-lz4c32 V=1

    - name: test-fullbench
      run: make -j -C tests test-fullbench V=1

    - name: test-fullbench32
      run: make -j -C tests test-fullbench32 V=1


  lz4-fuzzer:
    name: Fuzzer test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib

    - name: setup
      run: sudo sysctl -w vm.mmap_min_addr=4096

    - name: fuzzer
      run: make -j -C tests test-fuzzer V=1

    - name: fuzzer32
      run: make -C tests test-fuzzer32 V=1


  lz4-standard-makefile-variables:
    name: LZ4 Makefile - support for standard variables
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: make standard_variables
      run: make standard_variables V=1


  lz4-versions:
    name: LZ4 versions test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib

    - name: versionsTest
      run: make -j -C tests versionsTest V=1


  lz4-abi:
    name: LZ4 inter-versions ABI compatibility test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib

    - name: abiTests
      run: make -j -C tests abiTests V=1


  lz4-frame:
    name: LZ4 frame test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib

    - name: LZ4 frame test
      run: make -j -C tests test-frametest V=1

    - name: LZ4 frame test (32-bit)
      run: make -j -C tests test-frametest32 V=1

  lz4-memory-usage:
    name: test different values of LZ4_MEMORY_USAGE
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: LZ4_MEMORY_USAGE
      run: make V=1 -C tests test-compile-with-lz4-memory-usage

  # Custom LZ4_DISTANCE_MAX ; lz4-wlib (CLI linked to dynamic library); LZ4_USER_MEMORY_FUNCTIONS
  lz4-custom-distance:
    name: Custom LZ4_DISTANCE_MAX
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: custom LZ4_DISTANCE_MAX; test LZ4_USER_MEMORY_FUNCTIONS
      run: |
        CPPFLAGS='-DLZ4_DISTANCE_MAX=8000' make V=1 check
        make clean
        make -C programs lz4-wlib V=1
        make clean
        make -C tests fullbench-wmalloc V=1  # test LZ4_USER_MEMORY_FUNCTIONS
        make clean
        CC="c++ -Wno-deprecated" make -C tests fullbench-wmalloc V=1 # stricter function signature check

  # test block device compression #1086
  lz4cli-block-device:
    name: Test lz4 compression on a block device
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: create a block device, compress it with lz4 # alternative : blindly use /dev/loop0, seems to always exist
      run: |
        make lz4
        dd if=/dev/zero of=full0.img bs=2M count=1
        BLOCK_DEVICE=$(sudo losetup --show -fP full0.img)
        sudo chmod 666 $BLOCK_DEVICE
        ./lz4 -v $BLOCK_DEVICE -c > /dev/null
        sudo losetup -d $BLOCK_DEVICE
        rm full0.img


###############################################################
# Check tools
#
# - cppcheck
# - scan-build
# - valgrind
# - ubsan
# - asan
# - unicode-lint
# - build examples
#
  lz4-cppcheck:
    name: make cppcheck
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install cppcheck

    - name: Environment info
      run: echo && type cppcheck && which cppcheck && cppcheck --version

    - name: cppcheck
      # This test script ignores the exit code of cppcheck.
      # See known issues in README.md.
      run: make V=1 clean cppcheck || echo There are some cppcheck reports but we ignore it.


  lz4-scan-build:
    name: make staticAnalyze
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install clang-tools

    - name: Environment info
      run: |
        echo && type gcc && which gcc && gcc --version
        echo && type clang && which clang && clang --version
        echo && type scan-build && which scan-build               # scan-build doesn't have any --version equivalent option
        echo && type make && which make && make -v
        echo && cat /proc/cpuinfo || echo /proc/cpuinfo is not present

    - name: make staticAnalyze
      run: make V=1 clean staticAnalyze


  lz4-valgrind:
    name: valgrind
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install valgrind

    - name: Environment info
      run: |
        echo && type cc && which cc && cc --version
        echo && type valgrind && which valgrind && valgrind --version

    - name: valgrind
      run: make V=1 -C tests test-mem


  lz4-ubsan-x64:
    name: Linux x64 ubsan
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: ubsan
      run: |
        make clean
        make V=1 usan


  lz4-ubsan-x86:
    name: Linux x86 ubsan
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib
        sudo apt-get install lib32gcc-11-dev

    - name: ubsan32
      run: |
        make clean
        CC=clang make V=1 usan32


  lz4-asan-x64:
    name: Linux x64 ASAN
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: setup
      run: sudo sysctl -w vm.mmap_min_addr=4096

    - name: check lz4
      run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j check V=1

    - name: frametest
      run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j -C tests test-frametest V=1

    - name: fuzzer
      run: make clean; CFLAGS=-fsanitize=address LDFLAGS=-fsanitize=address make -j -C tests test-fuzzer V=1

  lz4-msan-x64:
    name: Linux x64 MSAN
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: check lz4
      run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j check V=1

    - name: frametest
      run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j -C tests test-frametest V=1

    - name: fuzzer
      run: make clean; CC=clang CFLAGS=-fsanitize=memory LDFLAGS=-fsanitize=memory make -j -C tests test-fuzzer V=1

  lz4-tsan-x64:
    name: Linux x64 TSAN
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: lz4 cli
      run: make clean; CC=clang CFLAGS=-fsanitize=thread LDFLAGS=-fsanitize=thread make -j -C tests test-lz4 V=1


  unicode-lint:
    name: lint unicode in ./lib/, ./tests/ and ./programs/
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: unicode lint
      run: bash ./tests/unicode_lint.sh

  lz4-examples:
    name: make examples
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: apt-get install
      run: |
        sudo apt-get update

    - name: Environment info
      run: |
        echo && type cc && which cc && cc --version
        echo && type c++ && which c++ && c++ --version

    - name: examples
      run: make V=1 clean examples

  # lasts ~8mn
  oss-fuzz:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        sanitizer: [address, undefined, memory]
    steps:
    - name: Build Fuzzers (${{ matrix.sanitizer }})
      id: build
      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
      with:
        oss-fuzz-project-name: 'lz4'
        dry-run: false
        sanitizer: ${{ matrix.sanitizer }}
    - name: Run Fuzzers (${{ matrix.sanitizer }})
      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
      with:
        oss-fuzz-project-name: 'lz4'
        fuzz-seconds: 300
        dry-run: false
        sanitizer: ${{ matrix.sanitizer }}
    - name: Upload Crash
      uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # https://github.com/actions/upload-artifact v4.3.3
      if: failure() && steps.build.outcome == 'success'
      with:
        name: ${{ matrix.sanitizer }}-artifacts
        path: ./out/artifacts


###############################################################
# Platforms
#
# - QEMU (ARM, ARM64, PPC, PPC64LE, S390X)
# - macOS
# - Windows
#

  # QEMU
  # All tests use QEMU (static) and gcc cross compiler.
  #
  lz4-qemu-platforms:
    name: QEMU ${{ matrix.type }}
    strategy:
      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix instance failed.
      matrix:
        include: [
          # You can access the following values via ${{ matrix.??? }}
          #   type : Architecture type for `if:` statement.
          #   pkgs : apt-get package names.  You can include multiple packages which are delimited by space.
          #   xcc  : gcc cross C compiler executable.
          #   xemu : QEMU static emulator executable.
          #   os   : GitHub Actions YAML workflow label.  See https://github.com/actions/virtual-environments#available-environments

          { type: ARM,      pkgs: 'qemu-system-arm   gcc-arm-linux-gnueabi',     xcc: arm-linux-gnueabi-gcc,     xemu: qemu-arm-static,     os: ubuntu-latest, },
          { type: ARM64,    pkgs: 'qemu-system-arm   gcc-aarch64-linux-gnu',     xcc: aarch64-linux-gnu-gcc,     xemu: qemu-aarch64-static, os: ubuntu-latest, },
          { type: PPC,      pkgs: 'qemu-system-ppc   gcc-powerpc-linux-gnu',     xcc: powerpc-linux-gnu-gcc,     xemu: qemu-ppc-static,     os: ubuntu-latest, },
          { type: PPC64LE,  pkgs: 'qemu-system-ppc   gcc-powerpc64le-linux-gnu', xcc: powerpc64le-linux-gnu-gcc, xemu: qemu-ppc64le-static, os: ubuntu-latest, },
          { type: S390X,    pkgs: 'qemu-system-s390x gcc-s390x-linux-gnu',       xcc: s390x-linux-gnu-gcc,       xemu: qemu-s390x-static,   os: ubuntu-latest, },
          { type: MIPS,     pkgs: 'qemu-system-mips gcc-mips-linux-gnu',         xcc: mips-linux-gnu-gcc,        xemu: qemu-mips-static,    os: ubuntu-latest, },
          { type: M68K,     pkgs: 'qemu-system-m68k gcc-m68k-linux-gnu',         xcc: m68k-linux-gnu-gcc,        xemu: qemu-m68k-static,    os: ubuntu-latest, },
          { type: RISC-V,   pkgs: 'qemu-system-riscv64 gcc-riscv64-linux-gnu',   xcc: riscv64-linux-gnu-gcc,     xemu: qemu-riscv64-static, os: ubuntu-latest, },
          { type: SPARC,    pkgs: 'qemu-system-sparc gcc-sparc64-linux-gnu',     xcc: sparc64-linux-gnu-gcc,     xemu: qemu-sparc64-static, os: ubuntu-20.04, },
        ]

    runs-on: ${{ matrix.os }}
    env:                        # Set environment variables
      XCC: ${{ matrix.xcc }}
      XEMU: ${{ matrix.xemu }}
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: apt-get install
      run: |
        sudo apt-get update
        sudo apt-get install gcc-multilib
        sudo apt-get install qemu-utils qemu-user-static
        sudo apt-get install ${{ matrix.pkgs }}

    - name: Environment info
      run: |
        echo && type $XCC && which $XCC && $XCC --version
        echo && $XCC -v                       # Show built-in specs
        echo && type $XEMU && which $XEMU && $XEMU --version

    - name: ARM-ARM64-PPC-S390X
      if: ${{ matrix.type == 'ARM' || matrix.type == 'ARM64' || matrix.type == 'PPC' || matrix.type == 'S390X'}}
      run: make platformTest V=1  CC=$XCC QEMU_SYS=$XEMU

    - name: PPC64LE
      if: ${{ matrix.type == 'PPC64LE' }}
      run: CFLAGS=-m64 make platformTest V=1 CC=$XCC QEMU_SYS=$XEMU

    - name: MIPS-M68K-RISCV-SPARC
      if: ${{ matrix.type == 'MIPS' || matrix.type == 'M68K' || matrix.type == 'RISC-V' || matrix.type == 'SPARC' }}
      run: make platformTest V=1 CC=$XCC QEMU_SYS=$XEMU


  # macOS
  lz4-platform-macos-latest:
    name: macOS
    runs-on: macos-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: Environment info
      run: |
        echo && type cc && which cc && cc --version
        echo && type make && which make && make -v
        echo && sysctl -a | grep machdep.cpu   # cpuinfo

    - name: make default
      run: make clean; CFLAGS="-Werror -O0" make default V=1

    - name: make test
      run: make clean; CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" make -j test V=1

    - name: Ensure `make test` doesn't depend on the status of the console
      # see issue #990 for detailed explanations
      run: make -j test > /dev/null


  # Windows
  lz4-platform-windows:
    name: ${{ matrix.system.os }}
    runs-on: ${{ matrix.system.os }}
    strategy:
      fail-fast: false  # 'false' means Don't stop matrix workflows even if some matrix failed.
      matrix:
        system: [
          { os: windows-2022, build_path: ".\\build\\VS2022" },
        ]
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: Build ${{ matrix.system.os }}, Win32
      run: |
        pushd ${{ matrix.system.build_path }}
        .\\build-and-test-win32-release.bat
        popd

    - name: Build ${{ matrix.system.os }}, x64
      run: |
        pushd ${{ matrix.system.build_path }}
        .\\build-and-test-x64-release.bat
        popd


###############################################################
# Build systems (other than make)
#
# - cmake
# - meson
#

  # cmake
  lz4-build-cmake:
    name: cmake
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: Environment info
      run: |
        echo && type cmake && which cmake && cmake --version
        echo && type make && which make && make -v

    - name: cmake
      run: |
        CFLAGS="-Werror -O1" cmake -S build/cmake -B build -D CMAKE_INSTALL_PREFIX=install
        VERBOSE=1 cmake --build build --target install
        cmake -S tests/cmake -B build_test -D CMAKE_INSTALL_PREFIX=install
        VERBOSE=1 cmake --build build_test

  lz4-build-cmake-static-lib: # See https://github.com/lz4/lz4/issues/1269
    name: cmake (static lib)
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: Environment info
      run: |
        echo && type cmake && which cmake && cmake --version
        echo && type make && which make && make -v

    - name: cmake (static lib)
      run: |
        CFLAGS="-Werror -O1" cmake -S build/cmake -B build -D CMAKE_INSTALL_PREFIX=install_test_dir -DBUILD_STATIC_LIBS=ON
        VERBOSE=1 cmake --build build --target install
        cmake -S tests/cmake -B build_test -D CMAKE_INSTALL_PREFIX=install_test_dir
        VERBOSE=1 cmake --build build_test

  # Invoke cmake via Makefile
  lz4-build-make-cmake:
    name: make cmakebuild
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: make cmakebuild
      # V=1 for lz4 Makefile, VERBOSE=1 for cmake Makefile.
      run: make clean; make cmakebuild V=1 VERBOSE=1


  # Meson
  lz4-build-meson:
    name: Meson + Ninja
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - uses: actions/setup-python@82c7e631bb3cdc910f68e0081d67478d79c6982d # https://github.com/actions/setup-python v5.1.0
      with:
        python-version: '3.x'

    - name: Install
      run: |
        sudo apt-get update
        sudo apt-get install tree ninja-build
        python -m pip install --upgrade pip
        pip3 install --user meson

    - name: Environment info
      run: |
        echo && type clang && which clang && clang --version
        echo && type python && which python && python --version
        echo && type meson && which meson && meson --version

    - name: setup
      # 'run: >' replaces all newlines in the following block with spaces
      run: >
        meson setup
        --fatal-meson-warnings
        --buildtype=debug
        -Db_lundef=false
        -Dauto_features=enabled
        -Dprograms=true
        -Dcontrib=true
        -Dtests=true
        -Dexamples=true
        build/meson builddir

    - name: test
      run: |
        meson test -C builddir

    - name: staging
      run: |
        cd builddir
        DESTDIR=./staging ninja install
        tree ./staging


############################################################
# Check git tag for LZ4 releases
#
  lz4-check-tag:
    name: git version tag checking for release
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4
    - name: make -C tests checkTag
      if: startsWith(github.ref, 'refs/tags/v')   # If git tag name starts with 'v'
      run: |
        echo "tag=${GITHUB_REF#refs/*/}"
        make -C tests checkTag
        tests/checkTag ${GITHUB_REF#refs/*/}


############################################################
# Gather CI environment information.
#
  lz4-env-info:
    name: GH-Actions Virtual Env Info (${{ matrix.os }})
    strategy:
      matrix:
        include: [
          { os: ubuntu-latest,  }, # https://github.com/actions/virtual-environments/
          { os: ubuntu-22.04,   }, # https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2204-Readme.md
          { os: ubuntu-20.04,   }, # https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-Readme.md
        ]

    runs-on: ${{ matrix.os }}
    steps:
    - uses: actions/checkout@0ad4b8fadaa221de15dcec353f45205ec38ea70b # https://github.com/actions/checkout v4.1.4

    - name: init
      run: |
        sudo apt-get update

    - name: cc --version
      run: echo && type cc && which cc && cc --version

    - name: gcc --version
      run: echo && type gcc && which gcc && gcc --version

    - name: clang --version
      run: echo && type clang && which clang && clang --version

    - name: make -v
      run: echo && type make && which make && make -v

    - name: g++ --version
      run: echo && type g++ && which g++ && g++ --version

    - name: git --version
      run: echo && type git && which git && git --version

    - name: gcc packages (apt-cache)
      run: apt-cache search gcc | grep "^gcc-[0-9\.]* " | sort

    - name: lib32gcc packages for i386 (apt-cache)
      run: apt-cache search lib32gcc | grep "^lib32gcc-" | sort

    - name: libx32gcc packages for x32 (apt-cache)
      run: apt-cache search libx32gcc | grep "^libx32gcc-" | sort

    - name: gcc multilib packages (apt-cache)
      run: apt-cache search multilib | grep "gcc-" | sort

    - name: clang packages (apt-cache)
      run: apt-cache search clang | grep "^clang-[0-9\.]* " | sort

    - name: QEMU packages (apt-cache)
      run: apt-cache search qemu | grep "^qemu-system-.*QEMU full system" | sort