respk 0.1.2

Manage resource files using a fast, custom open format designed especially for use in games.
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

use error::Error;
use package::Package;
use std::io::Read;


#[test]
fn open() {
    Package::temporary().unwrap();
}

#[test]
fn write_resource() {
    let package = Package::temporary().unwrap();

    package.write("test", "test".as_bytes()).unwrap();
}

#[test]
fn write_then_read_resource() {
    let package = Package::temporary().unwrap();

    package.write("test", "test".as_bytes()).unwrap();
    let resource = package.read("test").unwrap();

    assert!(resource.contents() == "test".as_bytes());
}

#[test]
fn read_nonexistent_resource_fails() {
    let package = Package::temporary().unwrap();

    match package.read("test") {
        Err(Error::ResourceNotFound) => {},
        _ => panic!("expected Error::ResourceNotFound)"),
    }
}

#[test]
fn delete_existing_resource() {
    let package = Package::temporary().unwrap();

    package.write("test", "test".as_bytes()).unwrap();
    package.delete("test").unwrap();
}

#[test]
fn delete_nonexistent_resource_fails() {
    let package = Package::temporary().unwrap();

    assert!(package.delete("test") == Err(Error::ResourceNotFound));
}

#[test]
fn package_len() {
    let package = Package::temporary().unwrap();
    let len = 10;

    for i in 0..len {
        assert!(package.len() == i);
        package.write(format!("test-{}", i), "test".as_bytes()).unwrap();
        assert!(package.len() == i + 1);
    }

    package.delete("test-0").unwrap();

    assert!(package.len() == len - 1);
}

#[test]
fn stream_resource() {
    let package = Package::temporary().unwrap();

    package.write("test", "test".as_bytes()).unwrap();

    let mut bytes = Vec::new();
    package.stream("test")
        .unwrap()
        .read_to_end(&mut bytes)
        .unwrap();

    assert!(&bytes as &[u8] == "test".as_bytes());
}

#[test]
fn stream_nonexistent_resource_fails() {
    let package = Package::temporary().unwrap();
    let stream = package.stream("test");

    match stream {
        Err(Error::ResourceNotFound) => {},
        _ => panic!("expected Error::ResourceNotFound)"),
    }
}