# Mutants no test can kill, with the reason each is equivalent to the code it
# replaces.
#
# THE BAR IS IMPOSSIBILITY, NOT COST (infra `374e1971`, settled 2026-08-31). A
# mutant a test could kill, where nobody has written that test, stays a visible
# survivor with a GoingsOn task against it however unappealing the test looks.
# An exclusion list that also absorbs "not worth it" reports zero while real
# coverage gaps sit underneath it, which is the one thing the number is for.
#
# The two in-memory size guards are the worked example of the other direction.
# `data.len() > cap` and `total_in > cap` survived every run because the cap was
# a 4 GiB constant and `>`, `>=` and `==` agree at every size a fixture can
# reach. That is cost, not impossibility: the cap became a per-client field
# (`synckit@7bc19e6`) and two tests now stand on both sides of it. Neither is in
# this file.
#
# The patterns are regexes matched against the WHOLE listing line, `file:line:col`
# included, so `+`, `*` and `|` need escaping. A bare `||` is an empty
# alternation and silently excludes every mutant in the crate.
#
# Both entries carry a position because the description alone is ambiguous:
# cargo-mutants names a mutant by its operator and enclosing function and
# nothing else, and each of these functions holds other `<` comparisons that are
# caught. A stale anchor stops matching and the mutant returns as a visible
# survivor, which is the safe direction. Re-derive by diffing
# `cargo mutants --list` with and without this file.

exclude_re = [
    # `next_part < start.part_count` in the part-filling loop. Every part but
    # the last is exactly `part_size`, so the loop never sends the final part;
    # `staged.len() >= part_size` can hold at `next_part == start.part_count`
    # only when the ciphertext is an exact multiple of the part size, and the
    # extra iteration then sends byte-identical bytes to the same URL before the
    # function returns down the resume branch regardless. No observation
    # distinguishes it.
    "src/client/blob.rs:632:58: replace < with <= in SyncKitClient::stream_blob_parts",

    # `next_chunk < h.chunk_count` in the chunk-peeling loop. One chunk past the
    # count breaks on the next line against an empty buffer, before anything is
    # decrypted or appended. The bound is written as the count because that is
    # what the count means, not because it is what stops the loop.
    "src/client/blob.rs:940:30: replace < with <= in SyncKitClient::blob_download",
]