rust-coverage.toml

[tasks.workspace-members-coverage]
description = "Runs the ci-flow for every workspace member."
category = "Test"
workspace = false
env = { "CARGO_MAKE_MEMBER_TASK" = "${CARGO_MAKE_CORE_TASK_NAMESPACE_PREFIX}coverage" }
run_task = "do-on-members"

[tasks.workspace-coverage]
description = "Runs coverage task for all members and packages all of them (by default the codecov flow)."
category = "Test"
dependencies = ["workspace-members-coverage", "workspace-coverage-pack"]

[tasks.workspace-coverage-pack]
description = "Publishes all member coverage reports."
category = "Test"
linux_alias = "codecov"

[tasks.pre-coverage]
category = "Test"

[tasks.coverage]
description = "Runs coverage (by default using kcov)."
category = "Test"
env = { "RUSTFLAGS" = "-C link-dead-code" }
run_task = [
  { name = "coverage-tarpaulin", condition = { platforms = [
    "linux",
  ], env = { "CARGO_MAKE_COVERAGE_PROVIDER" = "tarpaulin" } } },
  { name = "coverage-kcov", condition = { platforms = [
    "linux",
  ] } },
]

[tasks.coverage-kcov]
description = "Installs (if missing) and runs coverage using kcov (not supported on windows)"
category = "Test"
dependencies = ["setup-sudo-env"]
condition = { env_set = [
  "CARGO_MAKE_KCOV_VERSION",
], platforms = [
  "linux",
  "mac",
] }
script_runner = "bash"
env = { "CARGO_MAKE_KCOV_INCLUDE_PATTERN" = "${CARGO_MAKE_WORKING_DIRECTORY}/src/" }
install_script = '''
if [ "${CARGO_MAKE_SUDO_ENABLED}" == "false" ]; then
    echo "Skipping kcov installation as 'sudo' is disabled."
    exit 0
fi

KCOV_INSTALLATION_DIRECTORY=""
KCOV_BINARY_DIRECTORY=""
if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
    mkdir -p ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    cd ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    KCOV_INSTALLATION_DIRECTORY="$(pwd)/"
    cd -
    echo "Kcov Installation Directory: ${KCOV_INSTALLATION_DIRECTORY}"
    KCOV_BINARY_DIRECTORY="${KCOV_INSTALLATION_DIRECTORY}/build/src/"
    echo "Kcov Binary Directory: ${KCOV_BINARY_DIRECTORY}"
fi

# get help info to fetch all supported command line arguments
KCOV_HELP_INFO=`${KCOV_BINARY_DIRECTORY}kcov --help` || true

# check needed arguments are supported, else install
if [[ $KCOV_HELP_INFO != *"--include-pattern"* ]] || [[ $KCOV_HELP_INFO != *"--exclude-line"* ]] || [[ $KCOV_HELP_INFO != *"--exclude-region"* ]]; then
    # check we are on a supported platform
    if [ "$(uname)" == "Linux" ]; then
        if [ "$(grep -Ei 'debian|buntu|mint' /etc/*release)" ]; then
            echo "Installing/Upgrading kcov..."
            sudo apt-get update || true
            sudo apt-get install -y libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc binutils-dev
        fi
    elif [ "$(uname)" == "Darwin" ]; then
        for brew_install in zlib bash cmake pkgconfig wget ; do
            if brew info ${brew_install} | grep "Not installed" ; then
                brew install ${brew_install}
            else
                echo "skipping ${brew_install} already installed"
            fi
        done
    fi

    mkdir -p ${CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY}
    cd ${CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY}
    KCOV_DOWNLOAD_DIRECTORY=$(pwd)

    wget https://github.com/SimonKagstrom/kcov/archive/v${CARGO_MAKE_KCOV_VERSION}.zip
    unzip v${CARGO_MAKE_KCOV_VERSION}.zip
    cd kcov-${CARGO_MAKE_KCOV_VERSION}
    mkdir -p build
    cd ./build
    cmake ..
    make

    # if custom installation directory, leave kcov as local
    if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
        cd ${KCOV_DOWNLOAD_DIRECTORY}/kcov-${CARGO_MAKE_KCOV_VERSION}
        mv ./* ${KCOV_INSTALLATION_DIRECTORY}
    else
        sudo make install
        cd ../..
        rm -rf kcov-${CARGO_MAKE_KCOV_VERSION}
    fi
fi
'''
script = '''
echo "Working Directory: ${CARGO_MAKE_WORKING_DIRECTORY}"

KCOV_BINARY_DIRECTORY=""
if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
    cd ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    KCOV_INSTALLATION_DIRECTORY="$(pwd)/"
    cd -
    echo "Kcov Installation Directory: ${KCOV_INSTALLATION_DIRECTORY}"
    KCOV_BINARY_DIRECTORY="${KCOV_INSTALLATION_DIRECTORY}/build/src/"
    echo "Kcov Binary Directory: ${KCOV_BINARY_DIRECTORY}"
fi

TARGET_DIRECTORY="target/coverage"
if [ -n "$CARGO_MAKE_COVERAGE_REPORT_DIRECTORY" ]; then
    TARGET_DIRECTORY="$CARGO_MAKE_COVERAGE_REPORT_DIRECTORY"
fi
echo "Target Directory: ${TARGET_DIRECTORY}"
mkdir -p "${TARGET_DIRECTORY}"

BINARY_DIRECTORY=target/debug
if [ -n "$CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY" ]; then
    BINARY_DIRECTORY="${CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY}/debug"
fi
BINARY_DIRECTORY=${BINARY_DIRECTORY}/deps

KCOV_EXCLUDE_LINE_ARG=""
if [ -n "$CARGO_MAKE_KCOV_EXCLUDE_LINE" ]; then
    KCOV_EXCLUDE_LINE_ARG="--exclude-line=${CARGO_MAKE_KCOV_EXCLUDE_LINE}"
fi

KCOV_EXCLUDE_REGION_ARG=""
if [ -n "$CARGO_MAKE_KCOV_EXCLUDE_REGION" ]; then
    KCOV_EXCLUDE_REGION_ARG="--exclude-region=${CARGO_MAKE_KCOV_EXCLUDE_REGION}"
fi

echo "Running tests from directory: ${BINARY_DIRECTORY}"

# Evaluate variables that may be in the expression
# This allows us to do double expansion on a non-variable second expansion
CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX="$(sh -c "echo \"${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER}\"")"
echo "Test binary filter regex: ${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX}"

TEST_FILES=''
for test_file in $(find "${BINARY_DIRECTORY}" -maxdepth 1 -type f | grep -e "${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX}"); do
    keep=1
    for debug_file in $(find "${BINARY_DIRECTORY}/.." -maxdepth 1 -type f); do
        $(cmp -s "$debug_file" "$test_file") && keep=0 && break
    done
    if [ $keep -eq 1 ]; then
        [ -n "$TEST_FILES" ] && TEST_FILES="$TEST_FILES $test_file" || TEST_FILES="$test_file"
    fi
done
echo "Test Files:"
echo "${TEST_FILES}"

TEST_OPTIONS="--test-threads 1"
if [ "${CARGO_MAKE_TEST_USE_MULTI_TEST_PHASES}" == "true" ]; then
    export RUST_TEST_THREADS="1"
    if [ "${CARGO_MAKE_RUST_CHANNEL}" == "nightly" ]; then
        TEST_OPTIONS="${TEST_OPTIONS} --include-ignored -Zunstable-options"
    fi
fi
TEST_OPTIONS="${TEST_OPTIONS} ${CARGO_MAKE_KCOV_TEST_ARGUMENTS}"

TIMEOUT_COMMAND=""
if [ -n "${CARGO_MAKE_KCOV_TEST_TIMEOUT_VALUE}" ]; then
    TIMEOUT_COMMAND="timeout ${CARGO_MAKE_KCOV_TEST_TIMEOUT_VALUE} "
fi

i=0
for file in $TEST_FILES
do
    ((i=i+1))
    echo "Running coverage for file: $file"
    ${TIMEOUT_COMMAND} ${KCOV_BINARY_DIRECTORY}kcov --include-pattern=${CARGO_MAKE_KCOV_INCLUDE_PATTERN} ${KCOV_EXCLUDE_LINE_ARG} ${KCOV_EXCLUDE_REGION_ARG} "${TARGET_DIRECTORY}/${i}" "$file" ${TEST_OPTIONS} || true
done

rm -f ./core
'''

[tasks.coverage-tarpaulin]
description = "Runs coverage using tarpaulin rust crate (linux only)"
category = "Test"

[tasks.coverage-tarpaulin.linux]
command = "cargo"
args = ["tarpaulin", "--out", "Xml"]

[tasks.post-coverage]
category = "Test"

[tasks.coverage-flow]
description = "Runs the full coverage flow."
category = "Test"
dependencies = ["pre-coverage", "coverage", "post-coverage"]

[tasks.codecov]
description = "Runs codecov script to upload coverage results to codecov."
category = "Test"
condition = { env_not_set = [
  "CARGO_MAKE_SKIP_CODECOV",
], platforms = [
  "linux",
  "mac",
] }
script_runner = "bash"
script = '''
#!/usr/bin/env bash
bash <(curl -s https://codecov.io/bash)
'''

[tasks.codecov-flow]
description = "Runs the full coverage flow and uploads the results to codecov."
category = "Test"
condition = { platforms = ["linux", "mac"] }
dependencies = ["coverage-flow", "codecov"]

[tasks.ci-coverage-flow]
description = "Runs the coverage flow and uploads the results to codecov."
category = "CI"
condition = { platforms = [
  "linux",
], env_true = [
  "CARGO_MAKE_CI",
  "CARGO_MAKE_RUN_CODECOV",
] }
run_task = "codecov-flow"