libpna 0.33.0

PNA(Portable-Network-Archive) decoding and encoding library
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

use libpna::{Archive, DataKind, NormalEntry, ReadEntry, ReadOptions};
use std::io;

fn assert_entry(item: NormalEntry, password: Option<&[u8]>) {
    let path = item.header().path().as_str();
    let mut dist = Vec::new();
    let mut reader = item.reader(ReadOptions::with_password(password)).unwrap();
    io::copy(&mut reader, &mut dist).unwrap();
    match path {
        "raw/first/second/third/pna.txt" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/first/second/third/pna.txt")
        ),
        "raw/images/icon.bmp" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/images/icon.bmp")
        ),
        "raw/images/icon.png" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/images/icon.png")
        ),
        "raw/images/icon.svg" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/images/icon.svg")
        ),
        "raw/parent/child.txt" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/parent/child.txt")
        ),
        "raw/pna/empty.pna" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/pna/empty.pna")
        ),
        "raw/pna/nest.pna" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/pna/nest.pna")
        ),
        "raw/empty.txt" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/empty.txt")
        ),
        "raw/text.txt" => assert_eq!(
            dist.as_slice(),
            include_bytes!("../../resources/test/raw/text.txt")
        ),
        a => panic!("Unexpected entry name {a}"),
    }
}

fn extract_all(bytes: &[u8], password: Option<&[u8]>) {
    let mut n = 0;
    let mut archive_reader = Archive::read_header(bytes).unwrap();
    for entry in archive_reader.entries_with_password(password) {
        let item = entry.unwrap();
        if item.header().data_kind() == DataKind::Directory {
            continue;
        }
        n += 1;
        assert_entry(item, password);
    }
    assert_eq!(n, 9);

    let mut n = 0;
    let mut archive_reader = Archive::read_header(bytes).unwrap();
    for entry in archive_reader.entries() {
        let item = entry.unwrap();
        match item {
            ReadEntry::Solid(item) => {
                for item in item.entries(password).unwrap() {
                    let item = item.unwrap();
                    if item.header().data_kind() == DataKind::Directory {
                        continue;
                    }
                    n += 1;
                    assert_entry(item, password);
                }
            }
            ReadEntry::Normal(item) => {
                if item.header().data_kind() == DataKind::Directory {
                    continue;
                }
                n += 1;
                assert_entry(item, password);
            }
        }
    }
    assert_eq!(n, 9);
}

#[test]
fn solid_store() {
    extract_all(include_bytes!("../../resources/test/solid_store.pna"), None);
}

#[test]
fn solid_zstd() {
    extract_all(include_bytes!("../../resources/test/solid_zstd.pna"), None);
}

#[test]
fn solid_xz() {
    extract_all(include_bytes!("../../resources/test/solid_xz.pna"), None);
}

#[test]
fn solid_deflate() {
    extract_all(
        include_bytes!("../../resources/test/solid_deflate.pna"),
        None,
    );
}