From 71686f140706bcc0bc6ebbf0d626aec477e5ce4f Mon Sep 17 00:00:00 2001
From: Matthew Jackson <1085847+MattJackson@users.noreply.github.com>
Date: Fri, 31 Jul 2026 15:08:37 -0700
Subject: [PATCH] Lint the test code, and fix the 74 findings it had been
 hiding
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every other repo's CI now runs clippy with --all-targets. libfreemkv,
the crate the other seven build against and the one held up as the
reference workflow, was the last one still linting the library only — so
its ~3,000 tests, by far the largest body of test code in the project,
had never been linted at all. Turning the flag on surfaced 74 findings.

Most were mechanical and applied with clippy --fix. The rest, by hand:

- Four discarded Results in decrypt.rs. css::descramble_region returns a
  Result and four CSS tests threw it away, so a descramble that FAILED
  would have surfaced as a confusing buffer-comparison mismatch instead
  of the actual error. They expect() now.
- A dead `kp` field on the PlantedWalk fixture. The test deliberately
  asserts Kp as the explicit AES-G3(dk, 1) relation from [C] §3.2.4
  rather than against a stored value — its doc comment says so — which
  makes the field not just unused but a trap: the obvious "fix" of
  asserting against it would quietly weaken the test to comparing the
  fixture with itself. Removed.
- Two hand-rolled ICB counters in the HD-DVD fixtures, a needless mut,
  three vec!s that only ever needed arrays, a filter_map whose every arm
  was Some, and a Vec::new()+push chain.
- Doc list indentation in mkv.rs and mp4/read.rs, which was mis-rendering
  in the generated docs.
- A five-[u8; 16]-tuple return type named FourLevelParts.

Three lints are allowed at the specific sites, with reasons, because
they are wrong for this domain: the underscores in the bitstream-header
literals mark BITFIELD boundaries, not digit groups, so regrouping them
uniformly would satisfy the lint by destroying the only thing they
encode; and in three table-validation loops the loop variable is the
domain value under test (a DTS SFREQ code, an AMODE value, a palette
entry number), which is what the assertion messages name.
---
 .github/workflows/ci.yml   |  5 ++++-
 src/aacs/derive.rs         |  9 +++++++--
 src/aacs/index_select.rs   |  2 +-
 src/aacs/variant.rs        |  3 ---
 src/decrypt.rs             |  8 ++++----
 src/disc/hddvd.rs          | 30 ++++++++++++++++++------------
 src/disc/mod.rs            | 16 ++++++++--------
 src/ifo.rs                 |  5 +++++
 src/keysource.rs           |  2 +-
 src/labels/bdmt.rs         |  8 ++++----
 src/labels/mod.rs          |  2 +-
 src/labels/text.rs         |  2 +-
 src/mpls.rs                | 15 ++++++++-------
 src/mux/codec/ac3.rs       |  2 +-
 src/mux/codec/dts.rs       |  7 ++++++-
 src/mux/codec/hevc.rs      |  7 ++++++-
 src/mux/codec/mpegaudio.rs |  2 +-
 src/mux/demux_thread.rs    |  4 +---
 src/mux/disc.rs            |  9 ++++++---
 src/mux/driver.rs          | 16 ++++++++--------
 src/mux/ebml.rs            |  5 +++++
 src/mux/m2ts_mux/mod.rs    | 17 +++++++++--------
 src/mux/mkv.rs             |  1 +
 src/mux/mp4/audio.rs       | 15 +++++++++++++++
 src/mux/mp4/mod.rs         |  9 +++++++--
 src/mux/mp4/read.rs        | 26 ++++++++++++++++++--------
 src/mux/resolve.rs         | 23 ++++++++++++-----------
 src/mux/select.rs          |  8 ++++----
 src/mux/ts.rs              |  6 +++---
 src/udf.rs                 |  2 +-
 30 files changed, 166 insertions(+), 100 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 92e7f4c..91836f4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -41,7 +41,10 @@ jobs:
       # would always fail on a fresh runner because there's no committed
       # lockfile to lock against. The binary crates (freemkv, autorip,
       # bdemu) track Cargo.lock and DO use --locked.
-      - run: cargo clippy -- -D warnings
+      # --all-targets so TEST code is linted too. Without it this crate — the
+      # reference implementation for the other seven — was the only one whose
+      # tests had never been linted at all, and it was hiding 74 findings.
+      - run: cargo clippy --all-targets -- -D warnings
         working-directory: libfreemkv
 
   test:
diff --git a/src/aacs/derive.rs b/src/aacs/derive.rs
index c428dd9..22d8a43 100644
--- a/src/aacs/derive.rs
+++ b/src/aacs/derive.rs
@@ -1344,9 +1344,14 @@ mod position_recovery_tests {
         mkb
     }
 
+    /// `(dkey, mk, pk, cvalue, mk_dv)` — the five 16-byte AACS keys the
+    /// four-level fixture plants. Named so the return type says what it is
+    /// rather than repeating `[u8; 16]` five times.
+    type FourLevelParts = ([u8; 16], [u8; 16], [u8; 16], [u8; 16], [u8; 16]);
+
     /// The planted slot-2 material from the four-level fixture, reusable for
-    /// the malformed-MKB shapes below: `(dkey, mk, pk, cvalue, mk_dv)`.
-    fn four_level_parts() -> ([u8; 16], [u8; 16], [u8; 16], [u8; 16], [u8; 16]) {
+    /// the malformed-MKB shapes below.
+    fn four_level_parts() -> FourLevelParts {
         let p = plant_four_level_mkb();
         let cvalues = mkb_find_cvalues(&p.mkb).expect("cvalues");
         let mut cv = [0u8; 16];
diff --git a/src/aacs/index_select.rs b/src/aacs/index_select.rs
index 0b41e0d..d91b4c7 100644
--- a/src/aacs/index_select.rs
+++ b/src/aacs/index_select.rs
@@ -189,7 +189,7 @@ mod tests {
         let unit_packets = (ALIGNED_UNIT_LEN as u64 / SOURCE_PACKET_LEN) as u32; // 32
         // Start so the unit covers [80, 80+31] = [80, 111]: overlaps at 100.
         let off = 80u64 * SOURCE_PACKET_LEN;
-        assert!(80 + unit_packets - 1 >= 100, "sanity: unit tails into seg");
+        assert!(80 + unit_packets > 100, "sanity: unit tails into seg");
         assert_eq!(
             unit_disposition(off, &segs, Some(5)),
             UnitDisposition::Index(5)
diff --git a/src/aacs/variant.rs b/src/aacs/variant.rs
index ec78425..d33ca40 100644
--- a/src/aacs/variant.rs
+++ b/src/aacs/variant.rs
@@ -1707,8 +1707,6 @@ mod tests {
         records: Vec<MkbRecord>,
         /// The device key that covers slot 1 with zero descent.
         dk: DeviceKey,
-        /// The Processing Key the walk must produce for it.
-        kp: [u8; 16],
         /// The Media Key the full chain must reach from that Processing Key.
         km: [u8; 16],
         /// The `0x0c` C block of slot 1 — the cvalue the walk must select.
@@ -1833,7 +1831,6 @@ mod tests {
                 uv: UV_REAL,
                 u_mask_shift: U_MASK_SHIFT,
             },
-            kp,
             km,
             c_block1,
         }
diff --git a/src/decrypt.rs b/src/decrypt.rs
index c509584..1a27d88 100644
--- a/src/decrypt.rs
+++ b/src/decrypt.rs
@@ -837,7 +837,7 @@ mod tests {
         // descramble-and-rekey lives in `css::descramble_region` (the recovery
         // seam calls it); the region change must re-crack region B's key.
         let mut ended = key_a;
-        css::descramble_region(&mut buf, &mut ended);
+        css::descramble_region(&mut buf, &mut ended).expect("descramble");
 
         assert_eq!(
             &buf[0x80..2048],
@@ -986,7 +986,7 @@ mod tests {
         let (mut sector, plaintext) = make_css_sector(&title_key, &seed, 0xA5);
         // CSS descramble lives in `css::descramble_region` (the recovery seam
         // calls it); `decrypt_sectors` only flags CSS sectors for recovery.
-        css::descramble_region(&mut sector, &mut title_key);
+        css::descramble_region(&mut sector, &mut title_key).expect("descramble");
         assert_eq!(
             &sector[0x80..2048],
             &plaintext[0x80..2048],
@@ -1016,7 +1016,7 @@ mod tests {
         let mut buf = s0;
         buf.extend_from_slice(&s1);
         let mut title_key = title_key;
-        css::descramble_region(&mut buf, &mut title_key);
+        css::descramble_region(&mut buf, &mut title_key).expect("descramble");
         assert_eq!(
             &buf[0x80..2048],
             &p0[0x80..2048],
@@ -1095,7 +1095,7 @@ mod tests {
 
         // Cache primed to key_a only — exactly what the one-shot scan crack yields.
         let mut title_key = key_a;
-        css::descramble_region(&mut buf, &mut title_key);
+        css::descramble_region(&mut buf, &mut title_key).expect("descramble");
 
         assert_eq!(
             &buf[0x80..2048],
diff --git a/src/disc/hddvd.rs b/src/disc/hddvd.rs
index 425c175..2f7d700 100644
--- a/src/disc/hddvd.rs
+++ b/src/disc/hddvd.rs
@@ -716,12 +716,15 @@ mod tests {
     /// Build a UDF with an `HVDVD_TS/` tree holding the listed `.evo` clips
     /// (name, sector count, data LBA).
     fn make_hddvd_fs(disc: &mut MemDisc, evos: &[(&str, u32, u32)]) -> crate::udf::UdfFs {
-        let mut files = Vec::new();
-        let mut icb = 100u32;
-        for (name, sectors, data_lba) in evos {
-            files.push(file(name, icb, *data_lba, sectors * 2048, true));
-            icb += 1;
-        }
+        // ICBs are handed out from 100 upward, one per EVO, so the index IS
+        // the offset from that base.
+        let files: Vec<_> = evos
+            .iter()
+            .enumerate()
+            .map(|(i, (name, sectors, data_lba))| {
+                file(name, 100 + i as u32, *data_lba, sectors * 2048, true)
+            })
+            .collect();
         let root = DirSpec {
             name: String::new(),
             icb_lba: 10,
@@ -1337,12 +1340,15 @@ mod tests {
         evos: &[(&str, u32, u32)],
         xpl: &[u8],
     ) -> crate::udf::UdfFs {
-        let mut hv_files = Vec::new();
-        let mut icb = 100u32;
-        for (name, sectors, data_lba) in evos {
-            hv_files.push(file(name, icb, *data_lba, sectors * 2048, true));
-            icb += 1;
-        }
+        // ICBs are handed out from 100 upward, one per EVO, so the index IS
+        // the offset from that base.
+        let hv_files: Vec<_> = evos
+            .iter()
+            .enumerate()
+            .map(|(i, (name, sectors, data_lba))| {
+                file(name, 100 + i as u32, *data_lba, sectors * 2048, true)
+            })
+            .collect();
         let root = DirSpec {
             name: String::new(),
             icb_lba: 10,
diff --git a/src/disc/mod.rs b/src/disc/mod.rs
index 9f73662..aa2fe2e 100644
--- a/src/disc/mod.rs
+++ b/src/disc/mod.rs
@@ -3432,7 +3432,7 @@ mod tests {
     fn merged_extents_unions_sorts_and_merges() {
         // [300,310) ; [100,150) ; [150,200) adjacent→merges with prev ;
         // [120,160) overlaps [100,150)&[150,200) ; [500,505) disjoint.
-        let v = vec![
+        let v = [
             ext(300, 10),
             ext(100, 50),
             ext(150, 50),
@@ -3450,7 +3450,7 @@ mod tests {
     /// to a single range — no double-counting of shared content.
     #[test]
     fn merged_extents_dedups_shared_clip() {
-        let v = vec![ext(100, 50), ext(100, 50)];
+        let v = [ext(100, 50), ext(100, 50)];
         assert_eq!(merged_extents(v.iter()), vec![(100, 50)]);
     }
 
@@ -3666,7 +3666,7 @@ mod tests {
     #[test]
     fn canonical_order_pushes_oversize_play_all_behind_real_main() {
         const CAPACITY: u64 = 58_500_000_000; // 58.5 GB
-        let mut titles = vec![
+        let mut titles = [
             // Title 1 in the raw MPLS order — virtual play-all
             title_with(
                 "00020.mpls",
@@ -3694,7 +3694,7 @@ mod tests {
     #[test]
     fn canonical_order_preserves_natural_ranking_on_normal_disc() {
         const CAPACITY: u64 = 60_000_000_000;
-        let mut titles = vec![
+        let mut titles = [
             title_with("00100.mpls", 600.0, 500_000_000, 1), // 10 min menu (small)
             title_with("00800.mpls", 7320.0, 55_000_000_000, 1), // 2h02m main feature
             title_with("00200.mpls", 1800.0, 2_000_000_000, 1), // 30 min extra
@@ -3717,7 +3717,7 @@ mod tests {
     #[test]
     fn title_index_0_is_main_feature_dvd_the_dash_t_1_contract() {
         const DVD9: u64 = 7_900_000_000; // dual-layer DVD
-        let mut titles = vec![
+        let mut titles = [
             title_with("VTS_01_menu", 120.0, 200_000_000, 1), // 2m menu/setup loop
             title_with("VTS_02_main", 6540.0, 6_300_000_000, 1), // 1h49m main feature
             title_with("VTS_03_extra", 900.0, 800_000_000, 1), // 15m extra
@@ -3871,7 +3871,7 @@ mod tests {
         let feature = title_sized(57_000_000_000, 7860.0, 11); // 2h11m, 11 chapters
         let bonus = title_sized(1_200_000_000, 600.0, 1); // 10m, 1 clip
         let decoy = title_sized(400_000_000, 5460.0, 91); // 1h31m but tiny (reused)
-        let mut v = vec![bonus, decoy, feature];
+        let mut v = [bonus, decoy, feature];
         v.sort_by(|a, b| Disc::canonical_title_order(a, b, capacity));
         assert_eq!(
             v[0].size_bytes, 57_000_000_000,
@@ -4610,14 +4610,14 @@ mod tests {
         assert!(super::aligned_unit_keys_validate(
             &[(7, uk)],
             None,
-            &[enc.clone()],
+            std::slice::from_ref(&enc),
             ContentFormat::BdTs
         ));
         // Wrong key -> cannot de-scramble a scrambled sample -> reject.
         assert!(!super::aligned_unit_keys_validate(
             &[(7, [0x00u8; 16])],
             None,
-            &[enc.clone()],
+            std::slice::from_ref(&enc),
             ContentFormat::BdTs
         ));
         // Empty key set against a scrambled sample -> reject.
diff --git a/src/ifo.rs b/src/ifo.rs
index 6b3ad28..222ec9e 100644
--- a/src/ifo.rs
+++ b/src/ifo.rs
@@ -2201,6 +2201,11 @@ mod tests {
     /// `[padding, Y, Cb, Cr]`. Every byte of every entry is distinct here, so
     /// a wrong stride, a wrong base or a shifted component shows up.
     #[test]
+    // The loop variable is the DOMAIN VALUE being checked (a palette entry number), not a
+    // cursor into a collection: it is what the assertion message names and
+    // what the table is keyed by. `.iter().enumerate()` would rename the
+    // thing under test to `i` and read worse.
+    #[allow(clippy::needless_range_loop)]
     fn pgc_palette_entries_read_at_correct_stride() {
         let mut pal = [[0u8; 4]; 16];
         for (i, c) in pal.iter_mut().enumerate() {
diff --git a/src/keysource.rs b/src/keysource.rs
index 34f0e8d..c609ee5 100644
--- a/src/keysource.rs
+++ b/src/keysource.rs
@@ -1306,7 +1306,7 @@ mod tests {
                         break;
                     }
                     let abs = (lba - self.ext_start) / ALIGNED_UNIT_SECTORS + i as u32;
-                    if abs % 2 == 0 {
+                    if abs.is_multiple_of(2) {
                         chunk.fill(0x11); // CPI-clear (0x11 & 0xC0 == 0), no TS sync
                     } else {
                         chunk.fill(0xAB); // scrambled body (no TS sync)
diff --git a/src/labels/bdmt.rs b/src/labels/bdmt.rs
index adbe37b..d305228 100644
--- a/src/labels/bdmt.rs
+++ b/src/labels/bdmt.rs
@@ -370,10 +370,10 @@ mod tests {
             if let Some(d) = desc {
                 meta.descriptions.insert(lang.to_string(), d);
             }
-            if meta.disc_number.is_none() {
-                if let Some(d) = ds {
-                    meta.disc_number = Some(d);
-                }
+            if meta.disc_number.is_none()
+                && let Some(d) = ds
+            {
+                meta.disc_number = Some(d);
             }
         }
 
diff --git a/src/labels/mod.rs b/src/labels/mod.rs
index 0836aec..9ce3eff 100644
--- a/src/labels/mod.rs
+++ b/src/labels/mod.rs
@@ -1333,7 +1333,7 @@ mod gap_fill_tests {
         // duplicate. Stream_number is computed from the EXISTING
         // labels' max(stream_number) per type so orphans (when they
         // do fire) sort cleanly at the tail.
-        let labels = vec![
+        let labels = [
             label(StreamLabelType::Audio, 1, "eng", "TrueHD"),
             label(StreamLabelType::Audio, 2, "fra", "AC-3"),
         ];
diff --git a/src/labels/text.rs b/src/labels/text.rs
index c08a6d0..a9f1fa2 100644
--- a/src/labels/text.rs
+++ b/src/labels/text.rs
@@ -169,7 +169,7 @@ mod tests {
     /// Mutation: skip the final `if !current.is_empty()` emit → trailing run lost.
     #[test]
     fn large_buffer_trailing_run_emitted() {
-        let buf: Vec<u8> = (0..1000u32).map(|i| (0x41u8 + (i % 26) as u8)).collect();
+        let buf: Vec<u8> = (0..1000u32).map(|i| 0x41u8 + (i % 26) as u8).collect();
         let got = extract_ascii_strings(&buf, 1);
         // All printable, so one big run at the end.
         assert!(!got.is_empty());
diff --git a/src/mpls.rs b/src/mpls.rs
index 503f7da..d52852c 100644
--- a/src/mpls.rs
+++ b/src/mpls.rs
@@ -1521,13 +1521,14 @@ mod tests {
     /// consumed to keep the cursor aligned but never retained.
     #[test]
     fn full_stn_table_block_alignment() {
-        let mut entries: Vec<Vec<u8>> = Vec::new();
-        entries.push(build_stream_entry_video(0x1011, 0x1B, 6, 1, None));
-        entries.push(build_stream_entry_audio(0x1100, 0x83, 6, 1, b"eng"));
-        entries.push(build_stream_entry_audio(0x1101, 0x86, 3, 1, b"fra"));
-        entries.push(build_stream_entry_pg(0x1200, 0x90, b"eng"));
-        entries.push(build_stream_entry_pg(0x1201, 0x90, b"fra"));
-        entries.push(build_stream_entry_pg(0x1202, 0x90, b"deu"));
+        let mut entries: Vec<Vec<u8>> = vec![
+            build_stream_entry_video(0x1011, 0x1B, 6, 1, None),
+            build_stream_entry_audio(0x1100, 0x83, 6, 1, b"eng"),
+            build_stream_entry_audio(0x1101, 0x86, 3, 1, b"fra"),
+            build_stream_entry_pg(0x1200, 0x90, b"eng"),
+            build_stream_entry_pg(0x1201, 0x90, b"fra"),
+            build_stream_entry_pg(0x1202, 0x90, b"deu"),
+        ];
         for i in 0..4u16 {
             entries.push(build_stream_entry_pg(0x1400 + i, 0x91, b"eng"));
         }
diff --git a/src/mux/codec/ac3.rs b/src/mux/codec/ac3.rs
index 4ac4da5..3a7378a 100644
--- a/src/mux/codec/ac3.rs
+++ b/src/mux/codec/ac3.rs
@@ -1738,7 +1738,7 @@ mod tests {
     /// byte 5 = bsid 16 so the E-AC-3 paths are taken. CRC finalized so the frame
     /// passes the decodability gate.
     fn make_eac3_frame(strmtyp: u8, substreamid: u8, size: usize) -> Vec<u8> {
-        assert!(size >= MIN_FRAME_BYTES && size % 2 == 0);
+        assert!(size >= MIN_FRAME_BYTES && size.is_multiple_of(2));
         let frmsiz = size / 2 - 1;
         let mut f = vec![0u8; size];
         f[0] = 0x0B;
diff --git a/src/mux/codec/dts.rs b/src/mux/codec/dts.rs
index b9540ef..f56f632 100644
--- a/src/mux/codec/dts.rs
+++ b/src/mux/codec/dts.rs
@@ -921,7 +921,7 @@ mod tests {
         let core = make_dts_core(512);
         let garbage = vec![0xE4, 0x3F, 0xE3, 0x90, 0xCC, 0x6C]; // real Bourne head bytes
         let mut garbage = garbage;
-        garbage.extend(std::iter::repeat(0xAB).take(300));
+        garbage.extend(std::iter::repeat_n(0xAB, 300));
         let next = make_dts_core(512);
         let mut buf = core.clone();
         buf.extend_from_slice(&garbage);
@@ -1931,6 +1931,11 @@ mod tests {
     }
 
     #[test]
+    // The loop variable is the DOMAIN VALUE being checked (a DTS SFREQ code), not a
+    // cursor into a collection: it is what the assertion message names and
+    // what the table is keyed by. `.iter().enumerate()` would rename the
+    // thing under test to `i` and read worse.
+    #[allow(clippy::needless_range_loop)]
     fn sr_validity_table_marks_reserved_codes() {
         // The core-header sample-rate validity table must have ZERO (reject) at
         // exactly the reserved SFREQ codes {0,4,5,9,10} and a real rate
diff --git a/src/mux/codec/hevc.rs b/src/mux/codec/hevc.rs
index 56381a6..3b8d45e 100644
--- a/src/mux/codec/hevc.rs
+++ b/src/mux/codec/hevc.rs
@@ -1456,6 +1456,11 @@ mod tests {
     /// offset on any real stream that sets it — mislabelling every picture's
     /// coding type.
     #[test]
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn nonzero_num_extra_slice_header_bits_shifts_the_slice_type_offset() {
         use super::super::coding::CodingType;
 
@@ -2690,7 +2695,7 @@ mod tests {
             }
         }
         fn put_bit(&mut self, b: u32) {
-            if self.nbits % 8 == 0 {
+            if self.nbits.is_multiple_of(8) {
                 self.bytes.push(0);
             }
             if b & 1 != 0 {
diff --git a/src/mux/codec/mpegaudio.rs b/src/mux/codec/mpegaudio.rs
index db48e45..dfe429b 100644
--- a/src/mux/codec/mpegaudio.rs
+++ b/src/mux/codec/mpegaudio.rs
@@ -154,7 +154,7 @@ mod tests {
     /// 0xFF 0xFB 0x90 0x00 — the canonical MP3 frame header.
     fn mp3_frame(payload: usize) -> Vec<u8> {
         let mut f = vec![0xFF, 0xFB, 0x90, 0x00];
-        f.extend(std::iter::repeat(0xAA).take(payload));
+        f.extend(std::iter::repeat_n(0xAA, payload));
         f
     }
 
diff --git a/src/mux/demux_thread.rs b/src/mux/demux_thread.rs
index 557c3c2..0e99830 100644
--- a/src/mux/demux_thread.rs
+++ b/src/mux/demux_thread.rs
@@ -417,9 +417,7 @@ mod tests {
         let (_dt, rx) =
             DemuxThread::spawn_zero_copy(pf_rx, rc_tx, (), None, Some(ts), None).unwrap();
 
-        pf_tx
-            .send(Err(std::io::Error::new(std::io::ErrorKind::Other, "boom")))
-            .unwrap();
+        pf_tx.send(Err(std::io::Error::other("boom"))).unwrap();
         drop(pf_tx);
 
         let batches = collect_batches(&rx, Duration::from_secs(5));
diff --git a/src/mux/disc.rs b/src/mux/disc.rs
index 450ce8d..4f5a1fb 100644
--- a/src/mux/disc.rs
+++ b/src/mux/disc.rs
@@ -1880,7 +1880,7 @@ mod tests {
             // would straddle AACS unit boundaries and decrypt under the wrong
             // alignment.
             assert!(
-                count as u32 % ALIGN == 0 || (count as u32) < ALIGN,
+                (count as u32).is_multiple_of(ALIGN) || (count as u32) < ALIGN,
                 "read count {count} is neither a whole number of units nor a sub-unit tail"
             );
         }
@@ -2457,7 +2457,10 @@ mod tests {
                 let h = halve_batch_size(size);
                 assert!(h >= 1, "halve({size}) must never be 0");
                 assert!(h <= size, "halve({size}) = {h} must not grow");
-                assert!(h < 6 || h % 3 == 0, "halve({size}) = {h} is unit-unaligned");
+                assert!(
+                    h < 6 || h.is_multiple_of(3),
+                    "halve({size}) = {h} is unit-unaligned"
+                );
             }
         }
 
@@ -2483,7 +2486,7 @@ mod tests {
                 let d = double_batch_size(size, 4096);
                 assert!(d >= size, "double({size}) = {d} must not shrink");
                 assert!(
-                    d < 6 || d % 3 == 0,
+                    d < 6 || d.is_multiple_of(3),
                     "double({size}) = {d} is unit-unaligned"
                 );
             }
diff --git a/src/mux/driver.rs b/src/mux/driver.rs
index b10209c..2e5d975 100644
--- a/src/mux/driver.rs
+++ b/src/mux/driver.rs
@@ -1043,15 +1043,15 @@ mod tests {
 
     impl Stream for FakeStream {
         fn read(&mut self) -> std::io::Result<Option<PesFrame>> {
-            if let Some((halt, after)) = &self.cancel_halt {
-                if self.reads >= *after {
-                    halt.cancel();
-                }
+            if let Some((halt, after)) = &self.cancel_halt
+                && self.reads >= *after
+            {
+                halt.cancel();
             }
-            if let Some(after) = self.halt_err_at_read {
-                if self.reads >= after {
-                    return Err(crate::error::Error::Halted.into());
-                }
+            if let Some(after) = self.halt_err_at_read
+                && self.reads >= after
+            {
+                return Err(crate::error::Error::Halted.into());
             }
             let f = self.frames.pop_front();
             if f.is_some() {
diff --git a/src/mux/ebml.rs b/src/mux/ebml.rs
index 418da52..c469fbb 100644
--- a/src/mux/ebml.rs
+++ b/src/mux/ebml.rs
@@ -1479,6 +1479,11 @@ mod tests {
     /// end_master without a multi-terabyte buffer, which is why this is
     /// tested at the encoder.
     #[test]
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn fixed_width_vint8_is_big_endian_over_the_full_payload() {
         assert_eq!(
             fixed_width_vint8(0x00AA_BB_CC_DD_EE_FF_11),
diff --git a/src/mux/m2ts_mux/mod.rs b/src/mux/m2ts_mux/mod.rs
index b8d4a8f..d58379b 100644
--- a/src/mux/m2ts_mux/mod.rs
+++ b/src/mux/m2ts_mux/mod.rs
@@ -766,7 +766,7 @@ mod tests {
         // First two packets: PAT, PMT. At least one video packet after.
         assert_eq!(pids[0], PID_PAT);
         assert_eq!(pids[1], PID_PMT);
-        assert!(pids.iter().any(|p| *p == PID_VIDEO));
+        assert!(pids.contains(&PID_VIDEO));
     }
 
     #[test]
@@ -810,8 +810,8 @@ mod tests {
 
         assert_ts_well_formed(&sink);
         let pids = extract_pids(&sink);
-        assert!(pids.iter().any(|p| *p == PID_VIDEO));
-        assert!(pids.iter().any(|p| *p == PID_AUDIO));
+        assert!(pids.contains(&PID_VIDEO));
+        assert!(pids.contains(&PID_AUDIO));
     }
 
     #[test]
@@ -1129,10 +1129,11 @@ mod tests {
                 continue;
             }
             total_video += 1;
-            if let Some(af) = af_body(pkt) {
-                if !af.is_empty() && (af[0] & 0x10) != 0 {
-                    pcr_indices.push(video_idx);
-                }
+            if let Some(af) = af_body(pkt)
+                && !af.is_empty()
+                && (af[0] & 0x10) != 0
+            {
+                pcr_indices.push(video_idx);
             }
             video_idx += 1;
         }
@@ -1582,7 +1583,7 @@ mod tests {
         }
         let pids = extract_pids(&sink);
         assert!(
-            !pids.iter().any(|p| *p == PID_AUDIO),
+            !pids.contains(&PID_AUDIO),
             "no audio track configured → no audio PID emitted"
         );
     }
diff --git a/src/mux/mkv.rs b/src/mux/mkv.rs
index 5e0a938..b28f8ad 100644
--- a/src/mux/mkv.rs
+++ b/src/mux/mkv.rs
@@ -2024,6 +2024,7 @@ mod tests {
     ///     so a shipped DVD rip marked every P/B frame as a seek point;
     ///   - the reader ignored ReferenceBlock and read the always-0 reserved bit,
     ///     so EVERY BlockGroup frame read back as a non-keyframe.
+    ///
     /// Downstream that silently dropped all video on `mkv://`(MPEG-2)→`m2ts://`
     /// (TsMuxer drops non-key video until the first keyframe) and made
     /// `mkv://`→`mkv://` / `stdio://` fail E6008 (MkvMuxer opens a cluster only
diff --git a/src/mux/mp4/audio.rs b/src/mux/mp4/audio.rs
index 7a24a30..fc7efdd 100644
--- a/src/mux/mp4/audio.rs
+++ b/src/mux/mp4/audio.rs
@@ -522,6 +522,11 @@ mod tests {
 
     /// A synthetic legacy AC-3 header: syncword, crc, fscod=0 (48k),
     /// frmsizecod, bsid=8, bsmod=0, acmod=7 (3/2), lfeon=1 → 5.1.
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn ac3_frame_5_1() -> Vec<u8> {
         let mut f = vec![0x0B, 0x77, 0x00, 0x00];
         // byte4: fscod(2)=0 | frmsizecod(6)=0b010110 (22)
@@ -556,6 +561,11 @@ mod tests {
 
     /// A synthetic Annex-E (E-AC-3) syncframe: bsid=16, fscod=0 (48 kHz),
     /// numblkscod=3 (6 blocks), acmod=7 (3/2), lfeon=1 → 5.1, frmsiz=63 (128 B).
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn eac3_frame_5_1() -> Vec<u8> {
         // E-AC-3: syncword | strmtyp/substreamid/frmsiz | fscod/numblks/acmod/lfeon | bsid
         let mut f = vec![0x0B, 0x77];
@@ -840,6 +850,11 @@ mod tests {
     }
 
     #[test]
+    // The loop variable is the DOMAIN VALUE being checked (a DTS AMODE value), not a
+    // cursor into a collection: it is what the assertion message names and
+    // what the table is keyed by. `.iter().enumerate()` would rename the
+    // thing under test to `i` and read worse.
+    #[allow(clippy::needless_range_loop)]
     fn ddts_channel_layout_speaker_count_matches_declared_channels() {
         // The `ddts` box carries BOTH a channel count and a 16-bit speaker mask,
         // and a decoder may trust either. They must agree for all 16 AMODEs.
diff --git a/src/mux/mp4/mod.rs b/src/mux/mp4/mod.rs
index 139d518..83c5d87 100644
--- a/src/mux/mp4/mod.rs
+++ b/src/mux/mp4/mod.rs
@@ -1226,6 +1226,11 @@ mod tests {
     }
 
     // A minimal AC-3 5.1 frame the audio parser accepts.
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn ac3_frame() -> Vec<u8> {
         vec![
             0x0B,
@@ -1503,11 +1508,11 @@ mod tests {
         t.duration_secs = 7200.0;
         let r = estimate_reserve(&t, &[0, 1]);
         assert!(
-            r % (4 << 20) == 0,
+            r.is_multiple_of(4 << 20),
             "reserve is 4 MiB-aligned + 4 MiB buffer"
         );
         assert!(
-            r >= 12 << 20 && r <= 20 << 20,
+            (12 << 20..=20 << 20).contains(&r),
             "≈12-16 MB for a 2h feature, got {r}"
         );
 
diff --git a/src/mux/mp4/read.rs b/src/mux/mp4/read.rs
index 34f41c2..1bc700c 100644
--- a/src/mux/mp4/read.rs
+++ b/src/mux/mp4/read.rs
@@ -1087,6 +1087,11 @@ mod tests {
     }
 
     #[test]
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn write_then_read_round_trip() {
         // Mux a small A/V title to an in-memory MP4, then demux it back and
         // check the streams, codec_private, and sample payloads survive.
@@ -1453,6 +1458,11 @@ mod tests {
     /// one of any of them round-trips through this crate unnoticed while making
     /// the file unplayable elsewhere.
     #[test]
+    // The underscores in these literals mark BITFIELD boundaries in the
+    // bitstream header being built (e.g. a 5-bit field then a 3-bit field),
+    // not thousands-style digit groups. Regrouping them uniformly would
+    // satisfy the lint by destroying the only thing they encode.
+    #[allow(clippy::unusual_byte_groupings)]
     fn moov_tree_carries_the_mandatory_track_header_and_media_boxes() {
         use crate::disc::{
             AudioChannels, AudioStream, Codec, DiscTitle, FrameRate, HdrFormat, LabelPurpose,
@@ -2148,8 +2158,8 @@ mod tests {
         mdia.extend_from_slice(&mdhd);
         mdia.extend_from_slice(&hdlr);
         mdia.extend_from_slice(&minf);
-        let trak = mp4_box(b"trak", &mp4_box(b"mdia", &mdia));
-        trak
+
+        mp4_box(b"trak", &mp4_box(b"mdia", &mdia))
     }
 
     #[test]
@@ -2449,10 +2459,10 @@ mod tests {
     }
 
     /// A `VisualSampleEntry` body with DISTINCT width and height, plus optional
-    /// child boxes (ISO/IEC 14496-12 §12.1.3): 6 reserved + 2 data_reference_index
-    /// + 16 pre_defined/reserved, then width(2) at 24 and height(2) at 26, then 50
-    /// more bytes of resolution / frame_count / compressorname / depth / pre_defined
-    /// to the 78-byte fixed part.
+    /// child boxes (ISO/IEC 14496-12 §12.1.3). The fixed part is 78 bytes:
+    /// 6 reserved, 2 data_reference_index, 16 pre_defined/reserved, width(2) at
+    /// offset 24, height(2) at 26, then 50 more bytes of resolution,
+    /// frame_count, compressorname, depth and pre_defined.
     fn visual_entry(width: u16, height: u16, children: &[u8]) -> Vec<u8> {
         let mut b = vec![0u8; 78];
         b[24..26].copy_from_slice(&width.to_be_bytes());
@@ -2492,7 +2502,7 @@ mod tests {
 
         // And a VisualSampleEntry too short to hold the fixed part is refused
         // rather than read out of a shorter buffer.
-        let short = stsd_with(b"avc1", &vec![0u8; 40]);
+        let short = stsd_with(b"avc1", &[0u8; 40]);
         assert!(
             parse_stsd(&short).is_none(),
             "a truncated VisualSampleEntry has no dimensions to read"
@@ -2519,7 +2529,7 @@ mod tests {
         assert_eq!(info.height, 0, "an audio entry declares no height");
 
         // Too short for the 28-byte fixed part: fall back to stereo, not to 0.
-        let short = stsd_with(b"ac-3", &vec![0u8; 12]);
+        let short = stsd_with(b"ac-3", &[0u8; 12]);
         let info = parse_stsd(&short).expect("a short audio entry still names a codec");
         assert_eq!(
             info.channels, 2,
diff --git a/src/mux/resolve.rs b/src/mux/resolve.rs
index 181ba11..518787a 100644
--- a/src/mux/resolve.rs
+++ b/src/mux/resolve.rs
@@ -4258,7 +4258,7 @@ mod tests {
                 let sb = s.start_byte();
                 if unit_byte >= sb && unit_byte < sb + s.byte_len() {
                     let n = (unit_byte - sb) / crate::aacs::content::ALIGNED_UNIT_LEN as u64;
-                    let key = if n % 2 == 0 {
+                    let key = if n.is_multiple_of(2) {
                         FMTS_INDEX_KEYS[(s.index - 1) as usize]
                     } else {
                         FMTS_ALT_KEY
@@ -4281,16 +4281,17 @@ mod tests {
             buf: &mut [u8],
             recovery: bool,
         ) -> crate::error::Result<usize> {
-            if let Some((a, b)) = self.fault_span {
-                if lba >= a && lba < b {
-                    self.probe_reads += 1;
-                    self.maybe_cancel();
-                    return Err(crate::error::Error::DiscRead {
-                        sector: lba as u64,
-                        status: None,
-                        sense: None,
-                    });
-                }
+            if let Some((a, b)) = self.fault_span
+                && lba >= a
+                && lba < b
+            {
+                self.probe_reads += 1;
+                self.maybe_cancel();
+                return Err(crate::error::Error::DiscRead {
+                    sector: lba as u64,
+                    status: None,
+                    sense: None,
+                });
             }
             if lba < FMTS_CONTENT_LBA {
                 self.meta_reads += 1;
diff --git a/src/mux/select.rs b/src/mux/select.rs
index c23c670..c288b5f 100644
--- a/src/mux/select.rs
+++ b/src/mux/select.rs
@@ -232,10 +232,10 @@ mod tests {
     fn pids(t: &DiscTitle) -> Vec<u16> {
         t.streams
             .iter()
-            .filter_map(|s| match s {
-                Stream::Video(v) => Some(v.pid),
-                Stream::Audio(a) => Some(a.pid),
-                Stream::Subtitle(s) => Some(s.pid),
+            .map(|s| match s {
+                Stream::Video(v) => v.pid,
+                Stream::Audio(a) => a.pid,
+                Stream::Subtitle(s) => s.pid,
             })
             .collect()
     }
diff --git a/src/mux/ts.rs b/src/mux/ts.rs
index ef2542a..3fd6085 100644
--- a/src/mux/ts.rs
+++ b/src/mux/ts.rs
@@ -1539,7 +1539,7 @@ mod tests {
         // 0xAA filler and the embedded 00 00 01 sequence must be absent — the
         // malformed PES header contributed ZERO bytes to the elementary stream.
         assert!(
-            !pes.data.iter().any(|&b| b == 0xAA),
+            !pes.data.contains(&0xAA),
             "garbage PES-header bytes must not appear in the elementary stream"
         );
         assert!(
@@ -2124,7 +2124,7 @@ mod tests {
         assert_eq!(out.len(), 1);
         // None of the 0xEE AF-only bytes may appear.
         assert!(
-            !out[0].data.iter().any(|&b| b == 0xEE),
+            !out[0].data.contains(&0xEE),
             "AF-only packet bytes must never be appended as ES"
         );
         assert_eq!(out[0].data, vec![0x01, 0x02, 0x03, 0x04]);
@@ -2165,7 +2165,7 @@ mod tests {
         assert_eq!(out.len(), 1);
         assert_eq!(out[0].data, vec![0x77, 0x88]);
         assert!(
-            !out[0].data.iter().any(|&b| b == 0xBB),
+            !out[0].data.contains(&0xBB),
             "adaptation-field stuffing must not appear in the ES"
         );
     }
diff --git a/src/udf.rs b/src/udf.rs
index c3951bc..932943b 100644
--- a/src/udf.rs
+++ b/src/udf.rs
@@ -1946,7 +1946,7 @@ mod tests {
         let icb = build_entry_ads(266, 0, 16, &[(1, 2048, HOLE_LBA), (0, 2048, DATA_LBA)], &[]);
         disc.put_bytes(PART_START + 12, &icb);
 
-        let mut fs = super::read_filesystem(&mut disc).expect("volume mounts");
+        let fs = super::read_filesystem(&mut disc).expect("volume mounts");
         let lba = fs
             .file_start_lba(&mut disc, "/VIDEO_TS.IFO")
             .expect("a file whose first descriptor is a hole still has data");