Enable more clippy warnings

Author: mbuesch

Cargo.toml

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 [workspace]
-members = [ "disktest", "disktest-lib" , "disktest-rawio"]
+members = [ "disktest", "disktest-lib" , "disktest-rawio" ]
 resolver = "3"
 
 [workspace.package]
@@ -10,17 +10,17 @@ homepage = "https://bues.ch/h/disktest"
 repository = "https://github.com/mbuesch/disktest"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
-authors = ["Michael Büsch <m@bues.ch>"]
-categories = ["command-line-utilities", "filesystem", "hardware-support"]
-keywords = ["disk", "HDD", "SSD", "flash", "SD-card"]
+authors = [ "Michael Büsch <m@bues.ch>" ]
+categories = [ "command-line-utilities", "filesystem", "hardware-support" ]
+keywords = [ "disk", "HDD", "SSD", "flash", "SD-card" ]
 edition = "2024"
 rust-version = "1.85"
 version = "2.0.0"
 
 [workspace.dependencies]
 anyhow = "1"
 chrono = "0.4"
-clap = { version = "4", features = ["derive", "color", "wrap_help"] }
+clap = { version = "4", features = [ "derive", "color", "wrap_help" ] }
 libc = "0.2"
 movavg = "2"
 rand = "0.10"
@@ -34,6 +34,36 @@ winapi = "0.3"
 disktest-lib = { version = "2", path = "./disktest-lib" }
 disktest-rawio = { version = "2", path = "./disktest-rawio" }
 
+[workspace.lints.clippy]
+# Lints from `cargo` group
+cargo = "warn"
+multiple-crate-versions = { level = "allow", priority = 1 }
+
+# Lints from `pedantic` group
+#pedantic = "warn"
+default_trait_access = { level = "allow", priority = 1 }
+implicit_clone = { level = "allow", priority = 1 }
+manual_string_new = { level = "allow", priority = 1 }
+missing-errors-doc = { level = "allow", priority = 1 }
+missing-panics-doc = { level = "allow", priority = 1 }
+must_use_candidate = { level = "allow", priority = 1 }
+similar-names = { level = "allow", priority = 1 }
+struct-excessive-bools = { level = "allow", priority = 1 }
+unnecessary_wraps = { level = "allow", priority = 1 }
+
+# Lints from `restriction` group
+clone_on_ref_ptr = "warn"
+dbg_macro = "warn"
+mem_forget = "warn"
+precedence_bits = "warn"
+todo = "warn"
+try_err = "warn"
+undocumented_unsafe_blocks = "warn"
+unimplemented = "warn"
+unseparated_literal_suffix = "warn"
+unused_result_ok = "warn"
+unused_trait_names = "warn"
+
 [profile.dev]
 lto = "thin"
 panic = "abort"

disktest-lib/Cargo.toml

@@ -27,7 +27,7 @@ signal-hook = { workspace = true }
 [dev-dependencies]
 tempfile = { workspace = true }
 
-[lints.clippy]
-undocumented_unsafe_blocks = "warn"
+[lints]
+workspace = true
 
 # vim: ts=4 sw=4 expandtab

disktest-lib/src/bufcache.rs

@@ -34,11 +34,11 @@ impl BufCache {
 
     pub fn push(&mut self, cons_id: u32, buf: Vec<u8>) {
         let Some(snd) = self.snd.get(&cons_id) else {
-            panic!("BufCache: Consumer {} does not exist.", cons_id);
+            panic!("BufCache: Consumer {cons_id} does not exist.");
         };
         if let Err(e) = snd.send(buf) {
             if self.quiet_level < DisktestQuiet::NoWarn {
-                eprintln!("BufCache: Failed to send: {}", e);
+                eprintln!("BufCache: Failed to send: {e}");
             }
         }
     }

disktest-lib/src/disktest.rs

@@ -10,10 +10,10 @@
 //
 
 use crate::stream_aggregator::{DtStreamAgg, DtStreamAggChunk};
-use crate::util::{Hhmmss, prettybytes};
+use crate::util::{Hhmmss as _, prettybytes};
 use anyhow as ah;
 use chrono::prelude::*;
-use disktest_rawio::{DEFAULT_SECTOR_SIZE, RawIo, RawIoOsIntf, RawIoResult};
+use disktest_rawio::{DEFAULT_SECTOR_SIZE, RawIo, RawIoOsIntf as _, RawIoResult};
 use movavg::MovAvg;
 use std::cmp::min;
 use std::path::{Path, PathBuf};
@@ -87,7 +87,7 @@ impl DisktestFile {
             // If bytes have been written, try to drop the operating system caches.
             if drop_count > 0 {
                 if let Err(e) = io.drop_file_caches(drop_offset, drop_count) {
-                    return Err(ah::format_err!("Cache drop error: {}", e));
+                    return Err(ah::format_err!("Cache drop error: {e}"));
                 }
             } else {
                 io.close()?;
@@ -155,7 +155,7 @@ impl DisktestFile {
         }
     }
 
-    /// Get a reference to the PathBuf in use.
+    /// Get a reference to the `PathBuf` in use.
     fn get_path(&self) -> &PathBuf {
         &self.path
     }
@@ -168,7 +168,7 @@ impl Drop for DisktestFile {
                 eprintln!("WARNING: File not closed. Closing now...");
             }
             if let Err(e) = self.close() {
-                panic!("Failed to drop operating system caches: {}", e);
+                panic!("Failed to drop operating system caches: {e}");
             }
         }
     }
@@ -188,7 +188,7 @@ pub struct Disktest {
 }
 
 impl Disktest {
-    /// Unlimited max_bytes.
+    /// Unlimited `max_bytes`.
     pub const UNLIMITED: u64 = u64::MAX;
 
     /// Create a new Disktest instance.
@@ -199,14 +199,14 @@ impl Disktest {
     ///   that is written to disk.
     ///   If unsure, use `Default::default()`.
     /// - seed: The seed for the random data stream generator.
-    /// - round_id: The disk test round. Every round gets a unique data stream.
+    /// - `round_id`: The disk test round. Every round gets a unique data stream.
     ///   If unsure, use `0` (first round).
-    /// - invert_pattern: Bitwise invert the random data stream.
+    /// - `invert_pattern`: Bitwise invert the random data stream.
     ///   If unsure, use `false` (don't invert).
-    /// - nr_threads: The number of threads to spawn when generating the random data stream.
+    /// - `nr_threads`: The number of threads to spawn when generating the random data stream.
     ///   The special value `0` means: Use all CPUs available in the system.
     ///   If unsure, use `1` (One CPU).
-    /// - quiet_level: The console verbosity of the Disktest code. See [DisktestQuiet].
+    /// - `quiet_level`: The console verbosity of the Disktest code. See [`DisktestQuiet`].
     /// - abort: If this optional flag is set to `true` (e.g. by another thread) the Disktest
     ///   process will abort as soon as possible.
     ///   If unsure, use `None`.
@@ -402,7 +402,7 @@ impl Disktest {
             println!("Writing stopped. Syncing...");
         }
         if let Err(e) = file.sync() {
-            return Err(ah::format_err!("Sync failed: {}", e));
+            return Err(ah::format_err!("Sync failed: {e}"));
         }
 
         self.log(
@@ -414,8 +414,7 @@ impl Disktest {
 
         if let Err(e) = file.close() {
             return Err(ah::format_err!(
-                "Failed to drop operating system caches: {}",
-                e
+                "Failed to drop operating system caches: {e}"
             ));
         }
         if success && self.quiet_level < DisktestQuiet::NoInfo {
@@ -429,7 +428,7 @@ impl Disktest {
     pub fn write(&mut self, file: DisktestFile, seek: u64, max_bytes: u64) -> ah::Result<u64> {
         let mut file = file;
         let mut bytes_left = max_bytes;
-        let mut bytes_written = 0u64;
+        let mut bytes_written = 0_u64;
 
         let write_chunk_size = self.init(&mut file, "Writing", seek, max_bytes)?;
         loop {
@@ -490,7 +489,7 @@ impl Disktest {
             true,
         );
         if let Err(e) = file.close() {
-            return Err(ah::format_err!("Failed to close device: {}", e));
+            return Err(ah::format_err!("Failed to close device: {e}"));
         }
         Ok(())
     }
@@ -506,7 +505,7 @@ impl Disktest {
     ) -> ah::Error {
         if let Err(e) = self.verify_finalize(file, false, bytes_read) {
             if self.quiet_level < DisktestQuiet::NoWarn {
-                eprintln!("{}", e);
+                eprintln!("{e}");
             }
         }
         for (i, buffer_byte) in buffer.iter().enumerate().take(read_count) {
@@ -517,9 +516,8 @@ impl Disktest {
                         "Data MISMATCH at {}!",
                         prettybytes(pos, true, true, true)
                     );
-                } else {
-                    return ah::format_err!("Data MISMATCH at byte {}!", pos);
                 }
+                return ah::format_err!("Data MISMATCH at byte {pos}!");
             }
         }
         panic!("Internal error: verify_failed() no mismatch.");
@@ -529,7 +527,7 @@ impl Disktest {
     pub fn verify(&mut self, file: DisktestFile, seek: u64, max_bytes: u64) -> ah::Result<u64> {
         let mut file = file;
         let mut bytes_left = max_bytes;
-        let mut bytes_read = 0u64;
+        let mut bytes_read = 0_u64;
 
         let readbuf_len = self.init(&mut file, "Verifying", seek, max_bytes)? as usize;
         let mut buffer = vec![0; readbuf_len];
@@ -580,7 +578,7 @@ impl Disktest {
                         e
                     ));
                 }
-            };
+            }
 
             if self.abort_requested() {
                 let _ = self.verify_finalize(&mut file, false, bytes_read);
@@ -597,7 +595,7 @@ mod tests {
     use super::*;
     use crate::generator::{GeneratorChaCha8, GeneratorChaCha12, GeneratorChaCha20, GeneratorCrc};
     use std::fs::OpenOptions;
-    use std::io::{Seek, SeekFrom, Write};
+    use std::io::{Seek as _, SeekFrom, Write as _};
     use std::path::PathBuf;
     use tempfile::tempdir;
 
@@ -620,7 +618,7 @@ mod tests {
 
         let mk_filepath = |num| {
             let mut path = PathBuf::from(tdir_path);
-            path.push(format!("tmp-{}.img", num));
+            path.push(format!("tmp-{num}.img"));
             path
         };
 

disktest-lib/src/generator.rs

@@ -21,7 +21,7 @@ pub use crate::generator::chacha::GeneratorChaCha20;
 pub use crate::generator::crc::GeneratorCrc;
 
 pub trait NextRandom {
-    /// Get the size of the next() output with count = 1, in bytes.
+    /// Get the size of the `next()` output with count = 1, in bytes.
     fn get_base_size(&self) -> usize;
 
     /// Generate the next chunks.

disktest-lib/src/generator/chacha.rs

@@ -81,24 +81,25 @@ macro_rules! GeneratorChaCha {
 
             #[test]
             fn test_cmp_result() {
-                let mut a = $Generator::new(&[1, 2, 3]);
                 fn reduce(acc: u32, (i, x): (usize, &u8)) -> u32 {
                     acc.rotate_left(i as u32) ^ (*x as u32)
                 }
 
-                let mut buf = vec![0u8; $Generator::BASE_SIZE * (1024 + 512)];
+                let mut a = $Generator::new(&[1, 2, 3]);
+
+                let mut buf = vec![0_u8; $Generator::BASE_SIZE * (1024 + 512)];
                 a.next(&mut buf, 1024 + 512);
                 assert_eq!(buf.iter().enumerate().fold(0, reduce), $testresult0);
 
-                let mut buf = vec![0u8; $Generator::BASE_SIZE * (1024 + 512)];
+                let mut buf = vec![0_u8; $Generator::BASE_SIZE * (1024 + 512)];
                 a.next(&mut buf, 1024 + 512);
                 assert_eq!(buf.iter().enumerate().fold(0, reduce), $testresult1);
 
-                let mut buf = vec![0u8; $Generator::BASE_SIZE * (1024 + 512) * 2];
+                let mut buf = vec![0_u8; $Generator::BASE_SIZE * (1024 + 512) * 2];
                 a.next(&mut buf, (1024 + 512) * 2);
                 assert_eq!(buf.iter().enumerate().fold(0, reduce), $testresult2);
 
-                let mut buf = vec![0u8; $Generator::BASE_SIZE * (1024 + 512) * 3];
+                let mut buf = vec![0_u8; $Generator::BASE_SIZE * (1024 + 512) * 3];
                 a.next(&mut buf, (1024 + 512) * 3);
                 assert_eq!(buf.iter().enumerate().fold(0, reduce), $testresult3);
             }
@@ -110,10 +111,10 @@ macro_rules! GeneratorChaCha {
                 let mut res_a: Vec<Vec<u8>> = vec![];
                 let mut res_b: Vec<Vec<u8>> = vec![];
                 for _ in 0..2 {
-                    let mut buf = vec![0u8; $Generator::BASE_SIZE];
+                    let mut buf = vec![0_u8; $Generator::BASE_SIZE];
                     a.next(&mut buf, 1);
                     res_a.push(buf);
-                    let mut buf = vec![0u8; $Generator::BASE_SIZE];
+                    let mut buf = vec![0_u8; $Generator::BASE_SIZE];
                     b.next(&mut buf, 1);
                     res_b.push(buf);
                 }
@@ -130,10 +131,10 @@ macro_rules! GeneratorChaCha {
                 let mut res_a: Vec<Vec<u8>> = vec![];
                 let mut res_b: Vec<Vec<u8>> = vec![];
                 for _ in 0..2 {
-                    let mut buf = vec![0u8; $Generator::BASE_SIZE];
+                    let mut buf = vec![0_u8; $Generator::BASE_SIZE];
                     a.next(&mut buf, 1);
                     res_a.push(buf);
-                    let mut buf = vec![0u8; $Generator::BASE_SIZE];
+                    let mut buf = vec![0_u8; $Generator::BASE_SIZE];
                     b.next(&mut buf, 1);
                     res_b.push(buf);
                 }
@@ -147,13 +148,13 @@ macro_rules! GeneratorChaCha {
             fn test_concat_equal() {
                 let mut a = $Generator::new(&[1, 2, 3]);
                 let mut b = $Generator::new(&[1, 2, 3]);
-                let mut buf_a = vec![0u8; $Generator::BASE_SIZE * 2];
+                let mut buf_a = vec![0_u8; $Generator::BASE_SIZE * 2];
                 a.next(&mut buf_a[0..$Generator::BASE_SIZE], 1);
                 a.next(
                     &mut buf_a[$Generator::BASE_SIZE..$Generator::BASE_SIZE * 2],
                     1,
                 );
-                let mut buf_b = vec![0u8; $Generator::BASE_SIZE * 2];
+                let mut buf_b = vec![0_u8; $Generator::BASE_SIZE * 2];
                 b.next(&mut buf_b, 2);
                 assert_eq!(buf_a, buf_b);
             }
@@ -163,9 +164,9 @@ macro_rules! GeneratorChaCha {
                 let mut a = $Generator::new(&[1, 2, 3]);
                 let mut b = $Generator::new(&[1, 2, 3]);
                 b.seek($Generator::BASE_SIZE as u64 * 2).unwrap();
-                let mut bdata = vec![0u8; $Generator::BASE_SIZE];
+                let mut bdata = vec![0_u8; $Generator::BASE_SIZE];
                 b.next(&mut bdata, 1);
-                let mut adata = vec![0u8; $Generator::BASE_SIZE];
+                let mut adata = vec![0_u8; $Generator::BASE_SIZE];
                 a.next(&mut adata, 1);
                 assert_ne!(adata, bdata);
                 a.next(&mut adata, 1);
@@ -183,30 +184,30 @@ GeneratorChaCha!(
     GeneratorChaCha20,
     ChaCha20Rng,
     tests_chacha20,
-    331195744,
-    1401252284,
-    1567136089,
-    3153433807
+    331_195_744,
+    1_401_252_284,
+    1_567_136_089,
+    3_153_433_807
 );
 
 GeneratorChaCha!(
     GeneratorChaCha12,
     ChaCha12Rng,
     tests_chacha12,
-    477482776,
-    774733417,
-    473700519,
-    3620480628
+    477_482_776,
+    774_733_417,
+    473_700_519,
+    3_620_480_628
 );
 
 GeneratorChaCha!(
     GeneratorChaCha8,
     ChaCha8Rng,
     tests_chacha8,
-    3691419247,
-    1996469034,
-    1245532037,
-    1660157839
+    3_691_419_247,
+    1_996_469_034,
+    1_245_532_037,
+    1_660_157_839
 );
 
 // vim: ts=4 sw=4 expandtab