test: prepare some functions

Author: KSXGitHub

tests/_utils.rs

@@ -116,6 +116,130 @@ impl SampleWorkspace {
 
         SampleWorkspace(temp)
     }
+
+    /// Set up a temporary directory for tests.
+    ///
+    /// The tree in this tests have a diverse types of files, both shared (hardlinks)
+    /// and unique (non-hardlinks).
+    pub fn complex_tree_with_shared_and_unique_files(
+        files_per_branch: usize,
+        bytes_per_file: usize,
+    ) -> Self {
+        use std::fs::{create_dir_all, hard_link, write as write_file};
+
+        let whole = files_per_branch;
+        let half = files_per_branch / 2;
+        let quarter = files_per_branch / 4;
+        let half_quarter = files_per_branch / 8;
+        let temp = Temp::new_dir().expect("create working directory for sample workspace");
+
+        temp.join("no-hardlinks")
+            .pipe(create_dir_all)
+            .expect("create no-hardlinks");
+        temp.join("some-hardlinks")
+            .pipe(create_dir_all)
+            .expect("create some-hardlinks");
+        temp.join("only-hardlinks/exclusive")
+            .pipe(create_dir_all)
+            .expect("create only-hardlinks/exclusive");
+        temp.join("only-hardlinks/mixed")
+            .pipe(create_dir_all)
+            .expect("create only-hardlinks/mixed");
+        temp.join("only-hardlinks/external")
+            .pipe(create_dir_all)
+            .expect("create only-hardlinks/external");
+
+        // Create files in no-hardlinks.
+        // There will be no files with nlink > 1.
+        (0..files_per_branch).par_bridge().for_each(|index| {
+            let file_name = format!("file-{index}.txt");
+            let file_path = temp.join("no-hardlinks").join(file_name);
+            if let Err(error) = write_file(&file_path, "a".repeat(bytes_per_file)) {
+                panic!("Failed to write {bytes_per_file} bytes into {file_path:?}: {error}");
+            }
+        });
+
+        // Create files in some-hardlinks.
+        // Let's divide the files into 8 equal groups.
+        // Each file in the first group will have 2 exclusive links.
+        // Each file in the second group will have 1 exclusive link.
+        // Each file in the third and fourth groups will have no links.
+        // Each file in the remaining groups is PLANNED to have 1 external link from only-hardlinks/mixed.
+        (0..whole).par_bridge().for_each(|file_index| {
+            let file_name = format!("file-{file_index}.txt");
+            let file_path = temp.join("some-hardlinks").join(file_name);
+            if let Err(error) = write_file(&file_path, "a".repeat(bytes_per_file)) {
+                panic!("Failed to write {bytes_per_file} bytes into {file_path:?}: {error}");
+            }
+
+            let link_count =
+                ((file_index < quarter) as usize) + ((file_index < half_quarter) as usize);
+
+            for link_index in 0..link_count {
+                let link_name = format!("link{link_index}-file{file_index}.txt");
+                let link_path = temp.join("some-hardlinks").join(link_name);
+                if let Err(error) = hard_link(&file_path, &link_path) {
+                    panic!("Failed to link {file_path:?} to {link_path:?}: {error}");
+                }
+            }
+        });
+
+        // Create files in only-hardlinks/exclusive.
+        // Each file in this directory will have 1 exclusive link.
+        (0..whole).par_bridge().for_each(|index| {
+            let file_name = format!("file-{index}.txt");
+            let file_path = temp.join("only-hardlinks/exclusive").join(file_name);
+            if let Err(error) = write_file(&file_path, "a".repeat(bytes_per_file)) {
+                panic!("Failed to write {bytes_per_file} bytes into {file_path:?}: {error}");
+            }
+            let link_name = format!("link-{index}.txt");
+            let link_path = temp.join("only-hardlinks/exclusive").join(link_name);
+            if let Err(error) = hard_link(&file_path, &link_path) {
+                panic!("Failed to link {file_path:?} to {link_path:?}: {error}");
+            }
+        });
+
+        // Create links in only-hardlinks/mixed.
+        // Let's divide the PLANNED links into 2 equal groups.
+        // Each link in the first group is PLANNED to shared with only-hardlinks/external.
+        // Each link in the second group is exclusive.
+        (half..whole).par_bridge().for_each(|index| {
+            let file_name = format!("link0-{index}.txt");
+            let file_path = temp.join("only-hardlinks/mixed").join(file_name);
+            if let Err(error) = write_file(&file_path, "a".repeat(bytes_per_file)) {
+                panic!("Failed to write {bytes_per_file} bytes to {file_path:?}: {error}");
+            }
+
+            let link_name = format!("link1-{index}.txt");
+            let link_path = temp.join("only-hardlinks/mixed").join(link_name);
+            if let Err(error) = hard_link(&file_path, &link_path) {
+                panic!("Failed to link {file_path:?} to {link_path:?}: {error}");
+            }
+        });
+
+        // Create links in only-hardlinks/external
+        // Let's divide the links into 2 equal groups.
+        // The first group will share with only-hardlinks/mixed.
+        // The second group will share with some-hardlinks.
+        (0..whole).par_bridge().for_each(|index| {
+            let link_name = format!("linkX-{index}.txt");
+            let link_path = temp.join("only-hardlinks/external").join(link_name);
+
+            let file_path = if index <= half {
+                let file_name = format!("link0-{index}.txt"); // file name from only-hardlinks/mixed
+                temp.join("only-hardlinks/mixed").join(file_name)
+            } else {
+                let file_name = format!("file-{index}.txt"); // file name from some-hardlinks
+                temp.join("some-hardlinks").join(file_name)
+            };
+
+            if let Err(error) = hard_link(&file_path, &link_path) {
+                panic!("Failed to link {file_path:?} to {link_path:?}: {error}");
+            }
+        });
+
+        SampleWorkspace(temp)
+    }
 }
 
 /// Make the snapshot of a [`TreeReflection`] testable.