archive 0.3.1

A unified interface for extracting common archive formats in-memory
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Tests for single-file decompression (gz, bz2, xz, lz4, zst)

mod common;

use archive::{ArchiveExtractor, ArchiveFormat};
use common::read_test_archive;

#[test]
fn test_single_gz_decompression() {
    let data = read_test_archive("hello.txt.gz");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Gz)
        .expect("Failed to decompress hello.txt.gz");

    assert_eq!(files.len(), 1, "Expected single decompressed file");
    let content = String::from_utf8_lossy(&files[0].data);
    assert_eq!(content.trim(), "Hello, World!");
}

#[test]
fn test_single_bz2_decompression() {
    let data = read_test_archive("hello.txt.bz2");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Bz2)
        .expect("Failed to decompress hello.txt.bz2");

    assert_eq!(files.len(), 1, "Expected single decompressed file");
    let content = String::from_utf8_lossy(&files[0].data);
    assert_eq!(content.trim(), "Hello, World!");
}

#[test]
fn test_single_xz_decompression() {
    let data = read_test_archive("hello.txt.xz");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Xz)
        .expect("Failed to decompress hello.txt.xz");

    assert_eq!(files.len(), 1, "Expected single decompressed file");
    let content = String::from_utf8_lossy(&files[0].data);
    assert_eq!(content.trim(), "Hello, World!");
}

#[test]
fn test_single_lz4_decompression() {
    let data = read_test_archive("hello.txt.lz4");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Lz4)
        .expect("Failed to decompress hello.txt.lz4");

    assert_eq!(files.len(), 1, "Expected single decompressed file");
    let content = String::from_utf8_lossy(&files[0].data);
    assert_eq!(content.trim(), "Hello, World!");
}

#[test]
fn test_single_zst_decompression() {
    let data = read_test_archive("hello.txt.zst");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Zst)
        .expect("Failed to decompress hello.txt.zst");

    assert_eq!(files.len(), 1, "Expected single decompressed file");
    let content = String::from_utf8_lossy(&files[0].data);
    assert_eq!(content.trim(), "Hello, World!");
}

#[test]
fn test_gz_extracts_original_filename() {
    let data = read_test_archive("hello.txt.gz");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Gz)
        .expect("Failed to decompress hello.txt.gz");

    assert_eq!(files.len(), 1);
    // Gzip files created with gzip tool typically store the original filename
    // If no filename in header, should default to "data"
    assert!(
        files[0].path == "hello.txt" || files[0].path == "data",
        "Expected 'hello.txt' or 'data', got '{}'",
        files[0].path
    );
}

#[test]
fn test_bz2_uses_data_as_filename() {
    let data = read_test_archive("hello.txt.bz2");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Bz2)
        .expect("Failed to decompress hello.txt.bz2");

    assert_eq!(files.len(), 1);
    // bzip2 format doesn't store original filename
    assert_eq!(files[0].path, "data");
}

#[test]
fn test_xz_uses_data_as_filename() {
    let data = read_test_archive("hello.txt.xz");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Xz)
        .expect("Failed to decompress hello.txt.xz");

    assert_eq!(files.len(), 1);
    // xz format doesn't store original filename
    assert_eq!(files[0].path, "data");
}

#[test]
fn test_lz4_uses_data_as_filename() {
    let data = read_test_archive("hello.txt.lz4");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Lz4)
        .expect("Failed to decompress hello.txt.lz4");

    assert_eq!(files.len(), 1);
    // lz4 format doesn't store original filename
    assert_eq!(files[0].path, "data");
}

#[test]
fn test_zst_uses_data_as_filename() {
    let data = read_test_archive("hello.txt.zst");
    let extractor = ArchiveExtractor::new();

    let files = extractor
        .extract(&data, ArchiveFormat::Zst)
        .expect("Failed to decompress hello.txt.zst");

    assert_eq!(files.len(), 1);
    // zstd format doesn't store original filename
    assert_eq!(files[0].path, "data");
}