make clippy happy

Author: KillingSpark

benches/decode_all.rs

@@ -3,7 +3,7 @@ use ruzstd::decoding::FrameDecoder;
 
 fn criterion_benchmark(c: &mut Criterion) {
     let mut fr = FrameDecoder::new();
-    let mut target_slice = &mut vec![0u8; 1024 * 1024 * 200];
+    let target_slice = &mut vec![0u8; 1024 * 1024 * 200];
     let src = include_bytes!("../decodecorpus_files/z000033.zst");
 
     c.bench_function("decode_all_slice", |b| {

src/bin/zstd.rs

@@ -34,17 +34,14 @@ fn decompress(flags: &[String], file_paths: &[String]) {
     }
 
     if flags.len() != 2 {
-        eprintln!(
-            "No flags other than -d and -c are currently implemented. Flags used: {:?}",
-            flags
-        );
+        eprintln!("No flags other than -d and -c are currently implemented. Flags used: {flags:?}");
         return;
     }
 
     let mut frame_dec = ruzstd::decoding::FrameDecoder::new();
 
     for path in file_paths {
-        eprintln!("File: {}", path);
+        eprintln!("File: {path}");
         let mut f = File::open(path).unwrap();
 
         let mut tracker = StateTracker {
@@ -146,7 +143,7 @@ impl<R: Read> Read for PercentPrintReader<R> {
         if progress > self.last_percent {
             self.last_percent = progress;
             eprint!("\r");
-            eprint!("{} % done", progress);
+            eprint!("{progress} % done");
         }
         Ok(new_bytes)
     }
@@ -215,7 +212,7 @@ fn do_something(data: &[u8], s: &mut StateTracker) {
     let percentage = (s.file_pos * 100) / s.file_size;
     if percentage as i8 != s.old_percentage {
         eprint!("\r");
-        eprint!("{} % done", percentage);
+        eprint!("{percentage} % done");
         s.old_percentage = percentage as i8;
     }
 }

src/bin/zstd_stream.rs

@@ -18,15 +18,12 @@ fn main() {
     }
 
     if flags.len() != 2 {
-        eprintln!(
-            "No flags other than -d and -c are currently implemented. Flags used: {:?}",
-            flags
-        );
+        eprintln!("No flags other than -d and -c are currently implemented. Flags used: {flags:?}");
         return;
     }
 
     for path in file_paths {
-        eprintln!("File: {}", path);
+        eprintln!("File: {path}");
         let f = File::open(path).unwrap();
         let mut buf_read = std::io::BufReader::new(f);
 

src/bit_io/bit_reader.rs

@@ -116,8 +116,7 @@ impl core::fmt::Display for GetBitsError {
             } => {
                 write!(
                     f,
-                    "Cant serve this request. The reader is limited to {} bits, requested {} bits",
-                    limit, num_requested_bits,
+                    "Cant serve this request. The reader is limited to {limit} bits, requested {num_requested_bits} bits",
                 )
             }
             GetBitsError::NotEnoughRemainingBits {
@@ -126,8 +125,7 @@ impl core::fmt::Display for GetBitsError {
             } => {
                 write!(
                     f,
-                    "Can\'t read {} bits, only have {} bits left",
-                    requested, remaining,
+                    "Can\'t read {requested} bits, only have {remaining} bits left",
                 )
             }
         }

src/decoding/errors.rs

@@ -435,8 +435,7 @@ fn weights() {
                         let code2_shifted = code2 >> (num_bits2 - num_bits);
                         assert_ne!(
                             code, code2_shifted,
-                            "{:b},{num_bits:} is prefix of {:b},{num_bits2:}",
-                            code, code2
+                            "{code:b},{num_bits:} is prefix of {code2:b},{num_bits2:}"
                         );
                     }
                 }

src/huff0/huff0_encoder.rs

@@ -43,7 +43,7 @@ fn test_decode_corpus_files() {
         if !p.ends_with(".zst") {
             continue;
         }
-        println!("Trying file: {}", p);
+        println!("Trying file: {p}");
 
         let mut content = fs::File::open(f.path()).unwrap();
 
@@ -125,7 +125,7 @@ fn test_decode_corpus_files() {
         }
 
         if counter > 0 {
-            println!("Result differs in at least {} bytes from original", counter);
+            println!("Result differs in at least {counter} bytes from original");
             success = false;
             fail_counter_diff += 1;
         }
@@ -140,8 +140,8 @@ fn test_decode_corpus_files() {
         let dur = end_time.as_micros() as usize;
         let speed = result.len() / if dur == 0 { 1 } else { dur };
         let speed_read = file_size as usize / if dur == 0 { 1 } else { dur };
-        println!("SPEED: {}", speed);
-        println!("SPEED_read: {}", speed_read);
+        println!("SPEED: {speed}");
+        println!("SPEED_read: {speed_read}");
         speeds.push(speed);
         speeds_read.push(speed_read);
     }
@@ -150,25 +150,19 @@ fn test_decode_corpus_files() {
     println!("Summary:");
     println!("###################");
     println!(
-        "Total: {}, Success: {}, WrongSize: {}, WrongBytecount: {}, WrongChecksum: {}, Diffs: {}",
-        total_counter,
-        success_counter,
-        fail_counter_size,
-        fail_counter_bytes_read,
-        fail_counter_chksum,
-        fail_counter_diff
+        "Total: {total_counter}, Success: {success_counter}, WrongSize: {fail_counter_size}, WrongBytecount: {fail_counter_bytes_read}, WrongChecksum: {fail_counter_chksum}, Diffs: {fail_counter_diff}"
     );
     println!("Failed files: ");
     for f in &failed {
-        println!("{}", f);
+        println!("{f}");
     }
 
     let speed_len = speeds.len();
     let sum_speed: usize = speeds.into_iter().sum();
     let avg_speed = sum_speed / speed_len;
     let avg_speed_bps = avg_speed * 1_000_000;
     if avg_speed_bps < 1000 {
-        println!("Average speed: {} B/s", avg_speed_bps);
+        println!("Average speed: {avg_speed_bps} B/s");
     } else if avg_speed_bps < 1_000_000 {
         println!("Average speed: {} KB/s", avg_speed_bps / 1000);
     } else {
@@ -180,7 +174,7 @@ fn test_decode_corpus_files() {
     let avg_speed_read = sum_speed_read / speed_read_len;
     let avg_speed_read_bps = avg_speed_read * 1_000_000;
     if avg_speed_read_bps < 1000 {
-        println!("Average speed reading: {} B/s", avg_speed_read_bps);
+        println!("Average speed reading: {avg_speed_read_bps} B/s");
     } else if avg_speed_bps < 1_000_000 {
         println!("Average speed reading: {} KB/s", avg_speed_read_bps / 1000);
     } else {

src/tests/decode_corpus.rs

@@ -118,7 +118,7 @@ fn test_dict_decoding() {
         if !p.ends_with(".zst") {
             continue;
         }
-        println!("Trying file: {}", p);
+        println!("Trying file: {p}");
 
         let mut content = fs::File::open(f.path()).unwrap();
 
@@ -198,7 +198,7 @@ fn test_dict_decoding() {
         }
 
         if counter > 0 {
-            println!("Result differs in at least {} bytes from original", counter);
+            println!("Result differs in at least {counter} bytes from original");
             success = false;
             fail_counter_diff += 1;
         }
@@ -213,8 +213,8 @@ fn test_dict_decoding() {
         let dur = end_time.as_micros() as usize;
         let speed = result.len() / if dur == 0 { 1 } else { dur };
         let speed_read = file_size as usize / if dur == 0 { 1 } else { dur };
-        println!("SPEED: {}", speed);
-        println!("SPEED_read: {}", speed_read);
+        println!("SPEED: {speed}");
+        println!("SPEED_read: {speed_read}");
         speeds.push(speed);
         speeds_read.push(speed_read);
     }
@@ -223,24 +223,19 @@ fn test_dict_decoding() {
     println!("Summary:");
     println!("###################");
     println!(
-        "Total: {}, Success: {}, WrongSize: {}, WrongBytecount: {}, Diffs: {}",
-        total_counter,
-        success_counter,
-        fail_counter_size,
-        fail_counter_bytes_read,
-        fail_counter_diff
+        "Total: {total_counter}, Success: {success_counter}, WrongSize: {fail_counter_size}, WrongBytecount: {fail_counter_bytes_read}, Diffs: {fail_counter_diff}"
     );
     println!("Failed files: ");
     for f in &failed {
-        println!("{}", f);
+        println!("{f}");
     }
 
     let speed_len = speeds.len();
     let sum_speed: usize = speeds.into_iter().sum();
     let avg_speed = sum_speed / speed_len;
     let avg_speed_bps = avg_speed * 1_000_000;
     if avg_speed_bps < 1000 {
-        println!("Average speed: {} B/s", avg_speed_bps);
+        println!("Average speed: {avg_speed_bps} B/s");
     } else if avg_speed_bps < 1_000_000 {
         println!("Average speed: {} KB/s", avg_speed_bps / 1000);
     } else {
@@ -252,7 +247,7 @@ fn test_dict_decoding() {
     let avg_speed_read = sum_speed_read / speed_read_len;
     let avg_speed_read_bps = avg_speed_read * 1_000_000;
     if avg_speed_read_bps < 1000 {
-        println!("Average speed reading: {} B/s", avg_speed_read_bps);
+        println!("Average speed reading: {avg_speed_read_bps} B/s");
     } else if avg_speed_bps < 1_000_000 {
         println!("Average speed reading: {} KB/s", avg_speed_read_bps / 1000);
     } else {

src/tests/dict_test.rs

@@ -27,7 +27,7 @@ fn test_encode_corpus_files_uncompressed_our_decompressor() {
             continue;
         }
 
-        println!("Trying file: {:?}", path);
+        println!("Trying file: {path:?}");
         let input = fs::read(entry.path()).unwrap();
         let mut compressed_file: Vec<u8> = Vec::new();
         let mut compressor = FrameCompressor::new(crate::encoding::CompressionLevel::Fastest);
@@ -82,7 +82,7 @@ fn test_encode_corpus_files_uncompressed_original_decompressor() {
         if path.extension() == Some(OsStr::new("zst")) {
             continue;
         }
-        println!("Trying file: {:?}", path);
+        println!("Trying file: {path:?}");
         let input = fs::read(entry.path()).unwrap();
 
         let mut compressed_file: Vec<u8> = Vec::new();
@@ -143,7 +143,7 @@ fn test_encode_corpus_files_compressed_our_decompressor() {
         if path.extension() == Some(OsStr::new("zst")) {
             continue;
         }
-        println!("Trying file: {:?}", path);
+        println!("Trying file: {path:?}");
         let input = fs::read(entry.path()).unwrap();
 
         let mut compressed_file: Vec<u8> = Vec::new();
@@ -199,7 +199,7 @@ fn test_encode_corpus_files_compressed_original_decompressor() {
         if path.extension() == Some(OsStr::new("zst")) {
             continue;
         }
-        println!("Trying file: {:?}", path);
+        println!("Trying file: {path:?}");
         let input = fs::read(entry.path()).unwrap();
 
         let mut compressed_file: Vec<u8> = Vec::new();

src/tests/encode_corpus.rs

@@ -259,7 +259,7 @@ fn test_specific_file() {
     let original_f = fs::File::open("./decodecorpus_files/z000088").unwrap();
     let original: Vec<u8> = original_f.bytes().map(|x| x.unwrap()).collect();
 
-    std::println!("Results for file: {}", path);
+    std::println!("Results for file: {path}");
 
     if original.len() != result.len() {
         std::println!(
@@ -285,7 +285,7 @@ fn test_specific_file() {
         }
     }
     if counter > 0 {
-        std::println!("Result differs in at least {} bytes from original", counter);
+        std::println!("Result differs in at least {counter} bytes from original");
     }
 }