ci.yml

name: CI

on:
  # Every PR
  pull_request:
  # Once merged into `master`, and on `ci-full` to enable testing a full run
  push:
    branches:
    - master
    - ci-full
  # Every monday at 09:00 in the morning
  schedule:
  - cron: '0 9 * * MON'

permissions:
  contents: read

env:
  # Disable incremental compilation
  CARGO_BUILD_INCREMENTAL: false
  # Set prettier + more verbose terminal output
  CARGO_TERM_COLOR: always
  CARGO_TERM_VERBOSE: true
  RUST_BACKTRACE: 1
  # Faster compilation, error on warnings and only document current crate
  RUSTFLAGS: "--codegen=debuginfo=0 --deny=warnings"
  RUSTDOCFLAGS: "--deny=warnings"
  # Minimum deployment targets.
  # Follows `rustc --target=x86_64-apple-darwin --print deployment-target`
  MACOSX_DEPLOYMENT_TARGET: 10.12
  # Follows `rustc --target=x86_64-apple-ios --print deployment-target`
  IPHONEOS_DEPLOYMENT_TARGET: 10.0
  # We only support compiling Objective-C code with clang
  CC: clang
  CXX: clang++

  # Crates that we want to run `rustdoc` and `clippy` on
  #
  # This excludes `header-translator`, `test-assembly`, `tests` and `test-ui`.
  PUBLIC_CRATES: >-
    --package=block-sys
    --package=block2
    --package=icrate
    --package=objc-sys
    --package=objc2
    --package=objc2-encode
    --package=objc2-proc-macros
  # The current nightly Rust version that our CI uses
  CURRENT_NIGHTLY: nightly-2023-11-22
  # Various features that we'd usually want to test with
  #
  # Note: The `exception` feature is not enabled here, since it requires
  # compiling C code, even if just running a `check`/`clippy` build.
  INTERESTING_FEATURES: malloc,block,verify,unstable-private
  UNSTABLE_FEATURES: unstable-autoreleasesafe,unstable-c-unwind
  LATEST_MACOS_FEATURE: unstable-frameworks-macos-14
  # Required when we want to use a different runtime than the default `apple`
  OTHER_RUNTIME: --no-default-features --features=std
  # https://doc.rust-lang.org/cargo/guide/cargo-home.html#caching-the-cargo-home-in-ci
  # Note: We don't cache `~/.cargo/bin`, that is done separately when needed.
  CARGO_CACHE_PATH: |
    ~/.cargo/registry/index/
    ~/.cargo/registry/cache/
    ~/.cargo/git/db/
  # Only enable time-consuming checks when about to do a new release
  #
  # This condition is duplicated a few places, since there's no good way to
  # deduplicate such information in GitHub Actions...
  FULL: ${{ (github.head_ref == 'new-versions' || github.ref_name == 'ci-full') && true || '' }}

jobs:
  fmt:
    name: Check formatting
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Use system Rust
      run: cargo --version

    - name: cargo fmt
      # This runs on the entire repository, including submodules
      run: cargo fmt -- --check

  lint:
    name: Lint ${{ matrix.name }}
    runs-on: ubuntu-latest

    strategy:
      # These jobs are "cheap" to run, will likely run in parallel anyhow, and
      # it can be useful to know exactly which parts failed.
      fail-fast: false
      matrix:
        include:
        - name: macOS 64bit
          target: aarch64-apple-darwin
          # Ideally this would use $LATEST_MACOS_FEATURE, but this causes clippy to
          # use too much memory for the CI runner
          args: >-
            $PUBLIC_CRATES
            --features=$INTERESTING_FEATURES
            --features=unstable-frameworks-macos-12
        - name: iOS 32bit
          target: armv7s-apple-ios
          build-std: true
          args: >-
            -Zbuild-std
            $PUBLIC_CRATES
            --features=$INTERESTING_FEATURES
            --features=unstable-frameworks-ios
        - name: GNUStep + exceptions
          target: x86_64-unknown-linux-gnu
          args: >-
            $PUBLIC_CRATES
            $OTHER_RUNTIME --features=gnustep-1-9
            --features=$INTERESTING_FEATURES,catch-all
            --features=unstable-frameworks-gnustep
        - name: header-translator
          target: x86_64-unknown-linux-gnu
          args: -pheader-translator
        - name: test-assembly
          target: x86_64-unknown-linux-gnu
          args: -ptest-assembly

    env:
      CARGO_BUILD_TARGET: ${{ matrix.target }}

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ env.CURRENT_NIGHTLY }}
        components: clippy ${{ matrix.build-std && ', rust-src' || '' }}
        targets: ${{ (!matrix.build-std) && matrix.target || null }}

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: cargo doc
      run: cargo doc --no-deps --document-private-items ${{ matrix.args }}

    - name: cargo clippy
      # Temporarily allow diverging_sub_expression until we figure out how to silence them in declare_class!
      run: cargo clippy --all-targets ${{ matrix.args }} -- --allow=clippy::diverging_sub_expression

  msrv:
    name: Check MSRV
    runs-on: ubuntu-latest

    env:
      CARGO_BUILD_TARGET: x86_64-apple-darwin

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: '1.60'
        targets: x86_64-apple-darwin

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: cargo check
      run: >-
        cargo check
        $PUBLIC_CRATES
        --features=$INTERESTING_FEATURES
        --features=$LATEST_MACOS_FEATURE
      env:
        RUSTFLAGS: "--codegen=debuginfo=0" # Removed --deny=warnings

  ui:
    name: Compiler UI
    runs-on: macos-latest
    needs:
    - fmt
    - lint

    env:
      TRYBUILD: overwrite

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ env.CURRENT_NIGHTLY }}
        components: rust-src

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Run UI tests
      run: cargo run --features=run --bin=test-ui

    - name: Check diff
      if: ${{ always() }}
      run: git diff --exit-code

  assembly:
    name: Assembly tests
    runs-on: ubuntu-latest
    needs:
    - fmt
    - lint

    env:
      TEST_OVERWRITE: 1

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ env.CURRENT_NIGHTLY }}
        components: rust-src

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Run macOS x86_64 assembly tests
      run: cargo run --bin=test-assembly -- -Z build-std --target=x86_64-apple-darwin

    - name: Run all assembly tests
      if: ${{ env.FULL }}
      run: ./helper-scripts/run-assembly-tests.sh

    - name: Check diff
      if: ${{ always() }}
      run: git diff --exit-code

  header-translator:
    name: Verify header translator output
    runs-on: macos-13
    needs:
    - fmt
    - lint

    env:
      DEVELOPER_DIR: /Applications/Xcode_15.0.1.app/Contents/Developer

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Use system Rust
      run: cargo --version

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Run header translator
      run: cargo run --bin=header-translator

    - name: Verify that no files changed
      run: git diff --exit-code --submodule=diff

  check-icrate-features:
    # if: ${{ env.FULL }}
    # This will take ~40 minutes
    if: ${{ github.head_ref == 'new-versions' || github.ref_name == 'ci-full' }}
    name: Check icrate features
    runs-on: macos-12
    needs:
    - fmt
    - lint

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Use system Rust
      run: cargo --version

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Check `icrate` with each feature enabled separately
      run: cargo run --bin=check_icrate_features

  test-macos:
    name: Test macOS 12
    runs-on: macos-12
    needs:
    - fmt
    # Currently the slowest check, so let's get it started as soon as possible
    # - lint

    env:
      ARGS: --no-default-features --features=std,apple

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: stable

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Test without features
      run: cargo test $ARGS $PUBLIC_CRATES -ptests

    - name: Test all frameworks
      run: cargo test $ARGS $PUBLIC_CRATES -ptests --features=$INTERESTING_FEATURES,unstable-frameworks-macos-12

  test-apple:
    # if: ${{ env.FULL }}
    if: ${{ github.head_ref == 'new-versions' || github.ref_name == 'ci-full' }}
    name: ${{ matrix.name }}
    runs-on: ${{ matrix.os || 'macos-latest' }}
    needs:
    - fmt
    - lint

    strategy:
      # MacOS instances are rate-limited, which means that whenever we can
      # avoid doing work, we should!
      fail-fast: true
      matrix:
        include:
        - name: Test macOS 13
          os: macos-13
          frameworks: macos-13
        - name: Test macOS 11
          os: macos-11
          frameworks: macos-11
        - name: Build macOS AArch64
          target: aarch64-apple-darwin
          frameworks: macos-11
        - name: Test macOS old SDK
          # Oldest macOS version we support
          sdk: "10.12"
          frameworks: macos-10-12
        - name: Test macOS nightly
          nightly: true
          frameworks: macos-11
        - name: Build macOS 32bit
          target: i686-apple-darwin
          nightly: true
          build-std: true
          # Newest SDK that supports 32-bit
          sdk: "10.13"
          frameworks: macos-10-13
        - name: Build iOS simulator ARM64
          target: aarch64-apple-ios-sim
          frameworks: ios
        - name: Build iOS ARM64
          target: aarch64-apple-ios
          frameworks: ios
        - name: Build iOS ARMv7s
          target: armv7s-apple-ios
          nightly: true
          build-std: true
          frameworks: ios
        - name: Build iOS 32bit x86
          target: i386-apple-ios
          nightly: true
          build-std: true
          frameworks: ios

    env:
      CARGO_BUILD_TARGET: ${{ matrix.target || 'x86_64-apple-darwin' }}
      # Modern macOS can only run the target that they're built for.
      # So we pass `--no-run` when building for other targets.
      ARGS: >-
        --no-default-features --features=std,apple
        ${{ matrix.build-std && '-Zbuild-std -Zdoctest-xcompile' }}
        ${{ matrix.target && '--no-run' }}

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ matrix.nightly && env.CURRENT_NIGHTLY || 'stable' }}
        components: ${{ matrix.build-std && 'rust-src' }}
        target: ${{ (!matrix.build-std) && matrix.target || null }}

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Cache SDK
      id: sdk-cache
      if: matrix.sdk
      uses: actions/cache@v3
      with:
        path: ~/sdk
        key: sdk-test-apple-${{ matrix.name }}

    - name: Download different macOS SDK
      if: matrix.sdk && steps.sdk-cache.outputs.cache-hit != 'true'
      # macOS SDKs:
      # - https://github.com/alexey-lysiuk/macos-sdk
      # - https://github.com/phracker/MacOSX-SDKs
      # - https://github.com/hexops/sdk-macos-12.0
      #
      # iOS SDKs:
      # - https://github.com/xybp888/iOS-SDKs
      # - https://github.com/theos/sdks
      run: |
        wget https://github.com/alexey-lysiuk/macos-sdk/releases/download/${{ matrix.sdk }}/MacOSX${{ matrix.sdk }}.tar.bz2
        tar -xyf MacOSX${{ matrix.sdk }}.tar.bz2
        mv MacOSX${{ matrix.sdk }}.sdk $HOME/sdk

    - name: Setup SDK environment
      if: matrix.sdk
      # This changes a variable, so is only set when a custom SDK is used
      run: echo "SDKROOT=$HOME/sdk" >> $GITHUB_ENV

    - name: Test without features
      run: cargo test $ARGS $PUBLIC_CRATES -ptests

    - name: Test Foundation
      run: >-
        cargo test $ARGS $PUBLIC_CRATES -ptests
        --features=$INTERESTING_FEATURES,Foundation_all

    - name: Test all frameworks
      run: >-
        cargo test $ARGS $PUBLIC_CRATES -ptests
        --features=$INTERESTING_FEATURES,catch-all,unstable-frameworks-${{ matrix.frameworks }}

    - name: Test in release mode
      run: >-
        cargo test $ARGS $PUBLIC_CRATES -ptests
        --features=$INTERESTING_FEATURES,catch-all,Foundation_all --release

    - name: Test with unstable features
      if: ${{ matrix.nightly }}
      run: >-
        cargo test $ARGS $PUBLIC_CRATES -ptests
        --features=$INTERESTING_FEATURES,catch-all,Foundation_all,$UNSTABLE_FEATURES

    # TODO: Re-enable this on all of Foundation once we do some form of
    # availability checking.
    - name: Test static class and selectors
      if: ${{ !contains(matrix.frameworks, 'ios') && !contains(matrix.frameworks, 'macos-10-12') }}
      run: >-
        cargo test $ARGS $PUBLIC_CRATES -ptests
        --features=unstable-static-sel,unstable-static-class,unstable-static-nsstring
        --features=Foundation,Foundation_NSString

  test-ios:
    # if: ${{ env.FULL }}
    if: ${{ github.head_ref == 'new-versions' || github.ref_name == 'ci-full' }}
    name: Test on iOS simulator w. dinghy
    runs-on: macos-11
    needs:
    - fmt
    - lint

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: stable
        targets: x86_64-apple-ios

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Install cargo-dinghy
      uses: taiki-e/install-action@v2
      with:
        tool: cargo-dinghy@0.6

    - name: Launch XCode Simulator and prepare Dinghy
      # Note that we're not testing all configurations with dinghy, since that
      # takes a very long time to run, and hence impedes general development.
      run: |
        # Get system info
        xcrun simctl list runtimes

        # Launch the simulator
        RUNTIME_ID=$(xcrun simctl list runtimes | grep iOS | cut -d ' ' -f 7 | tail -1)
        SIM_ID=$(xcrun simctl create My-iphone7 com.apple.CoreSimulator.SimDeviceType.iPhone-7 $RUNTIME_ID)
        xcrun simctl boot $SIM_ID

        # Export simulator ID
        echo "SIM_ID=$SIM_ID" >> $GITHUB_ENV

    - name: Test
      run: >-
        cargo-dinghy --device=$SIM_ID test
        $PUBLIC_CRATES -ptests
        --features=$INTERESTING_FEATURES,catch-all
        --features=unstable-frameworks-ios

  test-gnustep:
    name: ${{ matrix.name }}
    runs-on: ${{ matrix.os || 'ubuntu-latest' }}
    needs:
    - fmt
    - lint

    strategy:
      # GNUStep tests are currently flaky, this makes it easier to see
      fail-fast: false
      matrix:
        include:
        - name: Test GNUStep with libobjc2 v1.9
          target: x86_64-unknown-linux-gnu
          runtime: gnustep-1-9
          libobjc2: "1.9"
          frameworks: gnustep
        - name: Test GNUStep with libobjc2 v2.0
          # Fails for some reason on Ubuntu 22
          os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
          runtime: gnustep-2-0
          libobjc2: "2.0"
          frameworks: gnustep
        - name: Test GNUStep with libobjc2 v2.1 on nightly
          target: x86_64-unknown-linux-gnu
          nightly: true
          runtime: gnustep-2-1
          libobjc2: "2.1"
          fuzz: true
          frameworks: gnustep
        - name: Test GNUStep 32bit
          # Ubuntu 22 image doesn't have the required C++ libraries
          # installed for 32-bit
          os: ubuntu-20.04
          target: i686-unknown-linux-gnu
          cflags: -m32
          configureflags: --target=x86-pc-linux-gnu
          runtime: gnustep-1-9
          libobjc2: "1.9"
          frameworks: gnustep-32bit

    env:
      CARGO_BUILD_TARGET: ${{ matrix.target }}
      CFLAGS: ${{ matrix.cflags }}
      CXXFLAGS: ${{ matrix.cflags }}
      ASMFLAGS: ${{ matrix.cflags }}
      LDFLAGS: ${{ matrix.cflags }}
      ARGS: --no-default-features --features=std,${{ matrix.runtime }}
      # http://wiki.gnustep.org/index.php/Building_GNUstep_under_Debian_FreeBSD#installing_gnustep-make
      RUNTIME_VERSION: gnustep-${{ matrix.libobjc2 }}

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Cache external dependencies
      id: extern-cache
      uses: actions/cache@v3
      with:
        # We could have just cached build-files, and then rerun the build tool
        # every time, letting it figure out what's changed. However, this has
        # the problem that GNUStep-Base ./configure invalidates the cache,
        # which makes it very hard to know when to rebuild and when not to.
        #
        # So instead we just place the final outputs in ~/extern, and cache
        # them there:
        # - bin/*
        # - lib/libobjc.so
        # - lib/libgnustep-base.so
        # - include/Foundation/*
        # - include/objc/*
        path: |
          ~/extern/bin
          ~/extern/lib
          ~/extern/include
        # Change this key if we start caching more things
        key: extern-${{ github.job }}-${{ matrix.name }}-v1

    - name: Setup environment
      # These add to PATH-like variables, so they can always be set
      run: |
        mkdir -p $HOME/extern/bin
        mkdir -p $HOME/extern/lib
        mkdir -p $HOME/extern/include
        echo "PATH=$HOME/extern/bin:$PATH" >> $GITHUB_ENV
        echo "LIBRARY_PATH=$HOME/extern/lib:$LIBRARY_PATH" >> $GITHUB_ENV
        echo "LD_LIBRARY_PATH=$HOME/extern/lib:$LD_LIBRARY_PATH" >> $GITHUB_ENV
        echo "CPATH=$HOME/extern/include:$CPATH" >> $GITHUB_ENV
        # Debug print these
        ls -al $HOME/extern/*

    - name: Install Clang + Valgrind
      run: |
        sudo apt-get update
        sudo apt-get -y install clang valgrind

    - name: Install cross compilation tools
      if: matrix.target == 'i686-unknown-linux-gnu'
      run: |
        sudo dpkg --add-architecture i386
        sudo apt-get update
        sudo apt-get -y install gcc-multilib libgcc-10-dev:i386 \
          libc6-dev:i386 libstdc++-10-dev:i386 libffi-dev:i386 \
          libxml2-dev:i386 libicu-dev:i386

    - name: Install Make and Cmake
      if: steps.extern-cache.outputs.cache-hit != 'true'
      run: sudo apt-get -y install make cmake

    - name: Install GNUStep libobjc2
      if: steps.extern-cache.outputs.cache-hit != 'true'
      run: |
        wget https://github.com/gnustep/libobjc2/archive/refs/tags/v${{ matrix.libobjc2 }}.tar.gz
        tar -xzf v${{ matrix.libobjc2 }}.tar.gz

        # Install robin-map on v2.1
        if test -d libobjc2-2.1; then
          cd libobjc2-2.1/third_party
          # Remove possibly existing `robin-map` folder
          rm -rf robin-map
          wget https://github.com/Tessil/robin-map/archive/757de829927489bee55ab02147484850c687b620.tar.gz
          tar -xzf 757de829927489bee55ab02147484850c687b620.tar.gz
          mv robin-map-757de829927489bee55ab02147484850c687b620 robin-map
          cd ../..
        fi

        mkdir -p libobjc2-${{ matrix.libobjc2 }}/build
        cd libobjc2-${{ matrix.libobjc2 }}/build
        cmake -Wno-dev -DCMAKE_INSTALL_PREFIX=$HOME/extern -DTESTS=OFF ..
        make install

    - name: Install GNUStep make
      if: steps.extern-cache.outputs.cache-hit != 'true'
      run: |
        wget https://github.com/gnustep/tools-make/archive/refs/tags/make-2_9_0.tar.gz
        tar -xzf make-2_9_0.tar.gz
        mkdir -p tools-make-make-2_9_0/build
        cd tools-make-make-2_9_0/build
        ../configure --prefix=$HOME/extern --with-library-combo=ng-gnu-gnu
        make install

    - name: Install GNUStep base library
      if: steps.extern-cache.outputs.cache-hit != 'true'
      run: |
        wget https://github.com/gnustep/libs-base/archive/refs/tags/base-1_28_0.tar.gz
        tar -xzf base-1_28_0.tar.gz
        cd libs-base-base-1_28_0
        ./configure --prefix=$HOME/extern --disable-tls --disable-xslt ${{ matrix.configureflags }}
        make install
        ls -al $HOME/extern/*

    - name: Install GNUStep GUI
      if: matrix.target == 'x86_64-unknown-linux-gnu' && steps.extern-cache.outputs.cache-hit != 'true'
      run: |
        wget https://github.com/gnustep/libs-gui/archive/refs/tags/gui-0_29_0.tar.gz
        tar -xzf gui-0_29_0.tar.gz
        cd libs-gui-gui-0_29_0
        ./configure --prefix=$HOME/extern --disable-jpeg ${{ matrix.configureflags }}
        make install
        ls -al $HOME/extern/*

    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@master
      with:
        toolchain: ${{ matrix.nightly && env.CURRENT_NIGHTLY || 'stable' }}
        targets: ${{ matrix.target }}

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Cache cargo-fuzz
      if: ${{ matrix.fuzz }}
      id: fuzz-cache
      uses: actions/cache@v3
      with:
        path: ~/.cargo/bin/cargo-fuzz
        # Change this key if we update the required cargo-fuzz version
        key: cargo-fuzz-${{ github.job }}-${{ matrix.name }}-v0-11-2

    - name: Install cargo-fuzz
      if: ${{ matrix.fuzz && steps.fuzz-cache.outputs.cache-hit != 'true' }}
      run: cargo install cargo-fuzz --version=^0.11.2

    - name: Test Foundation
      run: cargo test $ARGS --features=$INTERESTING_FEATURES,catch-all,Foundation_all

    - name: Test all frameworks
      if: ${{ env.FULL }}
      run: cargo test $ARGS --features=$INTERESTING_FEATURES,catch-all,unstable-frameworks-${{ matrix.frameworks }}

    - name: Test in release mode
      # Disabled on GNUStep 2.1 for now
      if: ${{ env.FULL && matrix.runtime != 'gnustep-2-1' }}
      run: cargo test $ARGS --features=Foundation_all --release

    - name: Run fuzzing
      if: ${{ matrix.fuzz }}
      run: |
        # Run each fuzz target for 100000 runs (approx. 5 seconds), and
        # timeout after 2 seconds.
        #
        # We specify the number of runs explicitly instead of using
        # `max_total_time`, to get more determinism.
        for fuzz_target in $(cargo-fuzz list --fuzz-dir=./crates/test-fuzz/)
        do
          cargo-fuzz run --fuzz-dir=./crates/test-fuzz/ $fuzz_target $ARGS,fuzz-all -- -runs=10000 -timeout=2 -jobs=10
        done

        # Check if the fuzzer encountered something that should be added to
        # the corpus.
        git diff --exit-code

    - name: Run benchmarks
      # Disabled since it started failing for some reason
      if: ${{ false }}
      # Difficult to install Valgrind on macOS
      # See https://github.com/LouisBrunner/valgrind-macos
      run: cargo bench $ARGS

    - name: Test with unstable features
      if: ${{ env.FULL && matrix.nightly }}
      run: cargo test $ARGS --features=$INTERESTING_FEATURES,catch-all,Foundation_all,$UNSTABLE_FEATURES

  test-compiler-rt:
    name: Test Compiler-RT
    runs-on: ubuntu-latest
    needs:
    - fmt
    - lint

    env:
      # `compiler-rt` is only relevant for these crates
      PUBLIC_CRATES: >-
        --package=block-sys
        --package=block2

    steps:
    - uses: actions/checkout@v3
      with:
        submodules: true

    - name: Use system Rust
      run: cargo --version

    - name: Cache Cargo
      uses: actions/cache@v3
      with:
        path: ${{ env.CARGO_CACHE_PATH }}
        key: cargo-${{ github.job }}-${{ matrix.name }}-${{ hashFiles('**/Cargo.lock') }}

    - name: Install clang + libBlocksRuntime
      run: |
        sudo apt-get update
        sudo apt-get -y install clang libblocksruntime-dev

    - name: Test
      run: cargo test $PUBLIC_CRATES $OTHER_RUNTIME --features=compiler-rt

    - name: Test in release mode
      run: cargo test $PUBLIC_CRATES $OTHER_RUNTIME --features=compiler-rt --release