Fix PR review comments

Author: mjc

src/create/file_naming.rs

@@ -122,7 +122,16 @@ fn allocate_recovery_blocks(
                 };
             }
 
-            assert!(blocks > 0 && file_number > 0);
+            if blocks == 0 || file_number == 0 {
+                return allocate_recovery_blocks(
+                    recovery_file_count,
+                    recovery_block_count,
+                    first_recovery_block,
+                    RecoveryFileScheme::Uniform,
+                    largest_file_size,
+                    block_size,
+                );
+            }
 
             exponent = first_recovery_block;
             let mut count = 1;
@@ -375,6 +384,17 @@ mod tests {
         assert_eq!(allocations[5].count, 0);
     }
 
+    #[test]
+    fn limited_scheme_falls_back_when_cap_exhausts_files() {
+        let allocations = allocate_recovery_blocks(1, 10, 0, RecoveryFileScheme::Limited, 4, 1);
+
+        assert_eq!(allocations.len(), 2);
+        assert_eq!(allocations[0].exponent, 0);
+        assert_eq!(allocations[0].count, 10);
+        assert_eq!(allocations[1].exponent, 10);
+        assert_eq!(allocations[1].count, 0);
+    }
+
     /// Test count_digits helper
     /// Reference: par2cmdline-turbo/src/par2creator.cpp lines 604-615
     #[test]

src/packets/mod.rs

@@ -229,6 +229,22 @@ fn scan_for_next_magic<R: Read>(reader: &mut R) -> std::io::Result<Option<[u8; 8
     }
 }
 
+fn resync_to_next_magic<R: Read + Seek>(reader: &mut R, rewind_bytes: i64) -> bool {
+    if rewind_bytes != 0
+        && reader
+            .seek(std::io::SeekFrom::Current(-rewind_bytes))
+            .is_err()
+    {
+        return false;
+    }
+
+    if scan_for_next_magic(reader).ok().flatten().is_none() {
+        return false;
+    }
+
+    reader.seek(std::io::SeekFrom::Current(-8)).is_ok()
+}
+
 /// Parse packets with optional recovery slice inclusion
 ///
 /// When `include_recovery_slices` is false, recovery slice packet headers are still
@@ -261,12 +277,9 @@ pub fn parse_packets_with_options<R: Read + Seek>(
                 break;
             }
             Err(PacketParseError::InvalidMagic(_)) => {
-                // Bad magic - try to find next valid packet by scanning forward
-                if scan_for_next_magic(reader).ok().flatten().is_some() {
-                    // Found magic, but we need to rewind 8 bytes so the next parse reads the header
-                    if reader.seek(std::io::SeekFrom::Current(-8)).is_err() {
-                        break;
-                    }
+                // PacketHeader::parse consumed 64 bytes. Rewind 63 bytes so
+                // resync still checks the byte immediately after the bad start.
+                if resync_to_next_magic(reader, 63) {
                     continue;
                 } else {
                     break;
@@ -285,12 +298,7 @@ pub fn parse_packets_with_options<R: Read + Seek>(
                 }
                 Err(_) => {
                     // Validation failed - try to find next valid packet
-                    if scan_for_next_magic(reader).ok().flatten().is_some() {
-                        // Found magic, rewind 8 bytes
-                        if reader.seek(std::io::SeekFrom::Current(-8)).is_err() {
-                            break;
-                        }
-                    } else {
+                    if !resync_to_next_magic(reader, 0) {
                         break;
                     }
                 }
@@ -303,10 +311,7 @@ pub fn parse_packets_with_options<R: Read + Seek>(
             Ok(data) => data,
             Err(_) => {
                 // Failed to read packet body - try to find next valid packet
-                if scan_for_next_magic(reader).ok().flatten().is_some() {
-                    if reader.seek(std::io::SeekFrom::Current(-8)).is_err() {
-                        break;
-                    }
+                if resync_to_next_magic(reader, 0) {
                     continue;
                 } else {
                     break;
@@ -724,6 +729,20 @@ mod tests {
             assert_eq!(pos, 20); // 12 bytes before magic + 8 magic bytes
         }
 
+        #[test]
+        fn invalid_magic_resync_checks_next_byte() {
+            let mut data = vec![0xFF; 64];
+            data[1..9].copy_from_slice(MAGIC_BYTES);
+            let mut cursor = Cursor::new(&data);
+
+            let result = PacketHeader::parse(&mut cursor);
+            assert!(matches!(result, Err(PacketParseError::InvalidMagic(_))));
+            assert_eq!(cursor.position(), 64);
+
+            assert!(resync_to_next_magic(&mut cursor, 63));
+            assert_eq!(cursor.position(), 1);
+        }
+
         #[test]
         fn corrupt_packet_recovery() {
             // Test that we can recover from a corrupt packet by finding the next valid magic

src/repair/context.rs

@@ -197,28 +197,27 @@ impl RepairContext {
     /// Purge PAR2 files without a repair context, with optional output.
     pub fn purge_par_files_for_with_output(par2_file: &str, show_output: bool) -> Result<()> {
         let par2_path = Path::new(par2_file);
-        let par2_dir = par2_path
+        let _par2_dir = par2_path
             .parent()
             .ok_or_else(|| RepairError::InvalidPath(par2_path.to_path_buf()))?;
 
         if show_output {
             println!("\nPurge par files.");
         }
 
-        if let Ok(entries) = std::fs::read_dir(par2_dir) {
-            for entry in entries.flatten() {
-                let path = entry.path();
-                if path
-                    .extension()
-                    .and_then(|ext| ext.to_str())
-                    .is_some_and(|ext| ext.eq_ignore_ascii_case("par2"))
-                {
-                    delete_file(&path)?;
-
-                    if show_output {
-                        println!("Remove \"{}\".", entry.file_name().to_string_lossy());
-                    }
-                }
+        for path in crate::par2_files::collect_par2_files(par2_path) {
+            if !path.exists() {
+                continue;
+            }
+
+            delete_file(&path)?;
+
+            if show_output {
+                let file_name = path
+                    .file_name()
+                    .map(|name| name.to_string_lossy())
+                    .unwrap_or_else(|| path.as_os_str().to_string_lossy());
+                println!("Remove \"{}\".", file_name);
             }
         }
 

tests/test_create_integration.rs

@@ -26,6 +26,19 @@ fn create_test_file(path: &Path, size: usize, pattern: u8) -> std::io::Result<()
     fs::write(path, data)
 }
 
+/// Helper to create unique 4-byte blocks for tiny-block repair tests.
+///
+/// Repair tests deliberately use tiny 4-byte blocks. A repeated-byte fixture lets
+/// repair tools find duplicate "good" blocks in the damaged source file instead
+/// of exercising recovery slices.
+fn create_indexed_block_file(path: &Path, block_count: u32) -> std::io::Result<()> {
+    let mut data = Vec::with_capacity(block_count as usize * 4);
+    for block in 0..block_count {
+        data.extend_from_slice(&block.to_le_bytes());
+    }
+    fs::write(path, data)
+}
+
 /// Helper to run par2cmdline-turbo verify command
 fn run_par2_verify(par2_file: &Path) -> std::io::Result<bool> {
     let output = Command::new("par2").arg("verify").arg(par2_file).output()?;
@@ -219,8 +232,7 @@ fn test_create_then_corrupt_and_repair_with_par2cmdline() {
     let test_file = temp.path().join("test.dat");
     let par2_file = temp.path().join("test.par2");
 
-    // Create test file
-    create_test_file(&test_file, 4096, 0xDD).unwrap();
+    create_indexed_block_file(&test_file, 1024).unwrap();
 
     // Create PAR2 files using our implementation
     let reporter = Box::new(par2rs::create::ConsoleCreateReporter::new(true)); // quiet mode
@@ -397,7 +409,7 @@ fn repair_using_only_volume_files_succeeds() {
     let test_file = temp.path().join("test.dat");
     let par2_file = temp.path().join("test.par2");
 
-    create_test_file(&test_file, 4096, 0xEF).unwrap();
+    create_indexed_block_file(&test_file, 1024).unwrap();
 
     let reporter = Box::new(par2rs::create::ConsoleCreateReporter::new(true));
     let mut context = par2rs::create::CreateContextBuilder::new()

tests/test_repair_context.rs

@@ -450,8 +450,10 @@ fn test_repair_context_purge_par_files_keeps_backups() {
 
     let par2_file = dir.path().join("test.par2");
     let par2_vol = dir.path().join("test.vol0+1.par2");
+    let foreign_par2 = dir.path().join("foreign.par2");
     fs::write(&par2_file, b"dummy par2").unwrap();
     fs::write(&par2_vol, b"dummy volume").unwrap();
+    fs::write(&foreign_par2, b"foreign").unwrap();
 
     let packets = vec![
         Packet::Main(create_main_packet(vec![file_id])),
@@ -466,6 +468,7 @@ fn test_repair_context_purge_par_files_keeps_backups() {
     assert!(backup_file.exists());
     assert!(!par2_file.exists());
     assert!(!par2_vol.exists());
+    assert!(foreign_par2.exists());
 }
 
 #[test]
@@ -477,10 +480,12 @@ fn test_repair_context_purge_multiple_par2_files() {
     let par2_main = dir.path().join("test.par2");
     let par2_vol1 = dir.path().join("test.vol01+02.par2");
     let par2_vol2 = dir.path().join("test.vol03+04.par2");
+    let foreign_par2 = dir.path().join("other.par2");
 
     fs::write(&par2_main, b"main").unwrap();
     fs::write(&par2_vol1, b"vol1").unwrap();
     fs::write(&par2_vol2, b"vol2").unwrap();
+    fs::write(&foreign_par2, b"foreign").unwrap();
 
     let packets = vec![
         Packet::Main(create_main_packet(vec![file_id])),
@@ -492,10 +497,11 @@ fn test_repair_context_purge_multiple_par2_files() {
     let result = context.purge_files(par2_main.to_str().unwrap());
     assert!(result.is_ok());
 
-    // All PAR2 files should be deleted
+    // All PAR2 files from the same set should be deleted.
     assert!(!par2_main.exists());
     assert!(!par2_vol1.exists());
     assert!(!par2_vol2.exists());
+    assert!(foreign_par2.exists());
 }
 
 #[test]