refactor: move unit tests to separate files

src/uu/tar/src/operations/create.rs

@@ -156,80 +156,5 @@ fn normalize_path(path: &Path, allow_absolute: bool) -> Option<PathBuf> {
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use std::io::{self, Write};
-    use tar::Archive;
-    use tempfile::{tempdir, TempDir};
-
-    struct FailFlushWriter;
-    impl Write for FailFlushWriter {
-        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-            Ok(buf.len())
-        }
-        fn flush(&mut self) -> io::Result<()> {
-            Err(io::Error::other("flush failed"))
-        }
-    }
-
-    #[test]
-    fn test_create_archive_flush_failed() {
-        let dir = TempDir::new().unwrap();
-        let file_path = dir.path().join("test.txt");
-        fs::write(&file_path, "hello").unwrap();
-
-        let output = FailFlushWriter;
-        let status_output = io::sink();
-
-        let res = create_archive(
-            output,
-            status_output,
-            &[file_path.as_path()],
-            false,
-            false,
-            CompressionMode::None,
-        );
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn test_create_archive_with_zstd() {
-        let tempdir = tempdir().unwrap();
-        let _guard = crate::operations::TestDirGuard::enter(tempdir.path());
-        fs::write("file.txt", "hello").unwrap();
-
-        create_archive(
-            fs::File::create("archive.tar.zst").unwrap(),
-            io::sink(),
-            &[Path::new("file.txt")],
-            false,
-            false,
-            CompressionMode::Zstd,
-        )
-        .unwrap();
-
-        let decoder =
-            zstd::stream::read::Decoder::new(fs::File::open("archive.tar.zst").unwrap()).unwrap();
-        let mut archive = Archive::new(decoder);
-        let mut entries = archive.entries().unwrap();
-        let entry = entries.next().unwrap().unwrap();
-        assert_eq!(entry.path().unwrap().to_str(), Some("file.txt"));
-    }
-
-    #[test]
-    fn test_create_archive_missing_file_fails() {
-        let tempdir = tempdir().unwrap();
-        let missing_path = tempdir.path().join("missing.txt");
-
-        let err = create_archive(
-            io::sink(),
-            io::sink(),
-            &[missing_path.as_path()],
-            false,
-            false,
-            CompressionMode::Zstd,
-        )
-        .unwrap_err();
-        assert!(err.to_string().contains("missing.txt"));
-    }
-}
+#[path = "create_tests.rs"]
+mod tests;

src/uu/tar/src/operations/create_tests.rs

@@ -0,0 +1,80 @@
+// This file is part of the uutils tar package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use super::*;
+use std::io::{self, Write};
+use tar::Archive;
+use tempfile::{tempdir, TempDir};
+
+struct FailFlushWriter;
+impl Write for FailFlushWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Err(io::Error::other("flush failed"))
+    }
+}
+
+#[test]
+fn test_create_archive_flush_failed() {
+    let dir = TempDir::new().unwrap();
+    let file_path = dir.path().join("test.txt");
+    fs::write(&file_path, "hello").unwrap();
+
+    let output = FailFlushWriter;
+    let status_output = io::sink();
+
+    let res = create_archive(
+        output,
+        status_output,
+        &[file_path.as_path()],
+        false,
+        false,
+        CompressionMode::None,
+    );
+    assert!(res.is_err());
+}
+
+#[test]
+fn test_create_archive_with_zstd() {
+    let tempdir = tempdir().unwrap();
+    let _guard = crate::operations::TestDirGuard::enter(tempdir.path());
+    fs::write("file.txt", "hello").unwrap();
+
+    create_archive(
+        fs::File::create("archive.tar.zst").unwrap(),
+        io::sink(),
+        &[Path::new("file.txt")],
+        false,
+        false,
+        CompressionMode::Zstd,
+    )
+    .unwrap();
+
+    let decoder =
+        zstd::stream::read::Decoder::new(fs::File::open("archive.tar.zst").unwrap()).unwrap();
+    let mut archive = Archive::new(decoder);
+    let mut entries = archive.entries().unwrap();
+    let entry = entries.next().unwrap().unwrap();
+    assert_eq!(entry.path().unwrap().to_str(), Some("file.txt"));
+}
+
+#[test]
+fn test_create_archive_missing_file_fails() {
+    let tempdir = tempdir().unwrap();
+    let missing_path = tempdir.path().join("missing.txt");
+
+    let err = create_archive(
+        io::sink(),
+        io::sink(),
+        &[missing_path.as_path()],
+        false,
+        false,
+        CompressionMode::Zstd,
+    )
+    .unwrap_err();
+    assert!(err.to_string().contains("missing.txt"));
+}

src/uu/tar/src/operations/extract.rs

@@ -65,41 +65,5 @@ pub fn extract_archive(
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::CompressionMode;
-    use std::fs;
-    use tar::Builder;
-    use tempfile::tempdir;
-
-    #[test]
-    fn test_extract_archive_with_zstd() {
-        let tempdir = tempdir().unwrap();
-        let archive_path = tempdir.path().join("archive.tar.zst");
-
-        let mut tar_bytes = Vec::new();
-        {
-            let mut builder = Builder::new(&mut tar_bytes);
-            let mut header = tar::Header::new_gnu();
-            header.set_mode(0o644);
-            header.set_size("hello".len() as u64);
-            header.set_cksum();
-            builder
-                .append_data(&mut header, "extracted.txt", std::io::Cursor::new("hello"))
-                .unwrap();
-            builder.finish().unwrap();
-        }
-        let compressed = zstd::stream::encode_all(std::io::Cursor::new(tar_bytes), 0).unwrap();
-        fs::write(&archive_path, compressed).unwrap();
-
-        let _guard = crate::operations::TestDirGuard::enter(tempdir.path());
-        let input = fs::File::open(&archive_path).unwrap();
-        let result = extract_archive(input, &archive_path, true, CompressionMode::Zstd);
-
-        result.unwrap();
-        assert_eq!(
-            fs::read_to_string(tempdir.path().join("extracted.txt")).unwrap(),
-            "hello"
-        );
-    }
-}
+#[path = "extract_tests.rs"]
+mod tests;

src/uu/tar/src/operations/extract_tests.rs

@@ -0,0 +1,41 @@
+// This file is part of the uutils tar package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use super::*;
+use crate::CompressionMode;
+use std::fs;
+use tar::Builder;
+use tempfile::tempdir;
+
+#[test]
+fn test_extract_archive_with_zstd() {
+    let tempdir = tempdir().unwrap();
+    let archive_path = tempdir.path().join("archive.tar.zst");
+
+    let mut tar_bytes = Vec::new();
+    {
+        let mut builder = Builder::new(&mut tar_bytes);
+        let mut header = tar::Header::new_gnu();
+        header.set_mode(0o644);
+        header.set_size("hello".len() as u64);
+        header.set_cksum();
+        builder
+            .append_data(&mut header, "extracted.txt", std::io::Cursor::new("hello"))
+            .unwrap();
+        builder.finish().unwrap();
+    }
+    let compressed = zstd::stream::encode_all(std::io::Cursor::new(tar_bytes), 0).unwrap();
+    fs::write(&archive_path, compressed).unwrap();
+
+    let _guard = crate::operations::TestDirGuard::enter(tempdir.path());
+    let input = fs::File::open(&archive_path).unwrap();
+    let result = extract_archive(input, &archive_path, true, CompressionMode::Zstd);
+
+    result.unwrap();
+    assert_eq!(
+        fs::read_to_string(tempdir.path().join("extracted.txt")).unwrap(),
+        "hello"
+    );
+}

src/uu/tar/src/operations/list.rs

@@ -93,47 +93,5 @@ pub fn list_archive(
 }
 
 #[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::CompressionMode;
-    use std::fs;
-    use tar::Builder;
-    use tempfile::tempdir;
-
-    fn write_zstd_tar(archive_path: &Path) {
-        let mut tar_bytes = Vec::new();
-        {
-            let mut builder = Builder::new(&mut tar_bytes);
-            let mut header = tar::Header::new_gnu();
-            header.set_mode(0o644);
-            header.set_size("hello".len() as u64);
-            header.set_cksum();
-            builder
-                .append_data(&mut header, "listed.txt", std::io::Cursor::new("hello"))
-                .unwrap();
-            builder.finish().unwrap();
-        }
-        let compressed = zstd::stream::encode_all(std::io::Cursor::new(tar_bytes), 0).unwrap();
-        fs::write(archive_path, compressed).unwrap();
-    }
-
-    #[test]
-    fn test_list_archive_with_zstd_non_verbose() {
-        let tempdir = tempdir().unwrap();
-        let archive_path = tempdir.path().join("archive.tar.zst");
-        write_zstd_tar(&archive_path);
-
-        let input = fs::File::open(&archive_path).unwrap();
-        list_archive(input, &archive_path, false, CompressionMode::Zstd).unwrap();
-    }
-
-    #[test]
-    fn test_list_archive_with_zstd_verbose() {
-        let tempdir = tempdir().unwrap();
-        let archive_path = tempdir.path().join("archive.tar.zst");
-        write_zstd_tar(&archive_path);
-
-        let input = fs::File::open(&archive_path).unwrap();
-        list_archive(input, &archive_path, true, CompressionMode::Zstd).unwrap();
-    }
-}
+#[path = "list_tests.rs"]
+mod tests;

src/uu/tar/src/operations/list_tests.rs

@@ -0,0 +1,47 @@
+// This file is part of the uutils tar package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use super::*;
+use crate::CompressionMode;
+use std::fs;
+use tar::Builder;
+use tempfile::tempdir;
+
+fn write_zstd_tar(archive_path: &Path) {
+    let mut tar_bytes = Vec::new();
+    {
+        let mut builder = Builder::new(&mut tar_bytes);
+        let mut header = tar::Header::new_gnu();
+        header.set_mode(0o644);
+        header.set_size("hello".len() as u64);
+        header.set_cksum();
+        builder
+            .append_data(&mut header, "listed.txt", std::io::Cursor::new("hello"))
+            .unwrap();
+        builder.finish().unwrap();
+    }
+    let compressed = zstd::stream::encode_all(std::io::Cursor::new(tar_bytes), 0).unwrap();
+    fs::write(archive_path, compressed).unwrap();
+}
+
+#[test]
+fn test_list_archive_with_zstd_non_verbose() {
+    let tempdir = tempdir().unwrap();
+    let archive_path = tempdir.path().join("archive.tar.zst");
+    write_zstd_tar(&archive_path);
+
+    let input = fs::File::open(&archive_path).unwrap();
+    list_archive(input, &archive_path, false, CompressionMode::Zstd).unwrap();
+}
+
+#[test]
+fn test_list_archive_with_zstd_verbose() {
+    let tempdir = tempdir().unwrap();
+    let archive_path = tempdir.path().join("archive.tar.zst");
+    write_zstd_tar(&archive_path);
+
+    let input = fs::File::open(&archive_path).unwrap();
+    list_archive(input, &archive_path, true, CompressionMode::Zstd).unwrap();
+}