uo-rust-libs 0.1.0

Data readers for various Ultima Online client mul files
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

use crate::mul::{MulReader, MulWriter, MulWriterMode, tests::simple_from_vecs};
use byteorder::{LittleEndian, WriteBytesExt};
use std::ffi::CString;
use std::io::Cursor;
use std::path::Path;

fn fake_reader() -> MulReader<Cursor<Vec<u8>>> {
    let mut idx_cursor = Cursor::new(vec![]);
    idx_cursor.write_u32::<LittleEndian>(0).unwrap(); //Position
    idx_cursor.write_u32::<LittleEndian>(1).unwrap(); //Length
    idx_cursor.write_u16::<LittleEndian>(0).unwrap(); //Opt1
    idx_cursor.write_u16::<LittleEndian>(0).unwrap(); //Opt2
    idx_cursor.write_u32::<LittleEndian>(1).unwrap(); //Position
    idx_cursor.write_u32::<LittleEndian>(4).unwrap(); //Length
    idx_cursor.write_u16::<LittleEndian>(2).unwrap(); //Opt1
    idx_cursor.write_u16::<LittleEndian>(3).unwrap(); //Opt2

    let mut data_cursor = Cursor::new(vec![]);
    data_cursor.write_u8(255).unwrap();
    data_cursor.write_u32::<LittleEndian>(0xdeadbeef).unwrap();
    MulReader::from_readables(idx_cursor, data_cursor)
}

#[test]
fn test_read_entries() {
    let mut mul_reader = fake_reader();
    let record1 = mul_reader.read(0);
    let record2 = mul_reader.read(1);
    match record1 {
        Ok(record) => {
            assert_eq!(record.start, 0);
            assert_eq!(record.length, 1);
            assert_eq!(record.opt1, 0);
            assert_eq!(record.opt2, 0);
            assert_eq!(record.data.len(), 1);
            assert_eq!(record.data[0], 255);
        }
        Err(err) => panic!("{:?}", err),
    };
    match record2 {
        Ok(record) => {
            assert_eq!(record.start, 1);
            assert_eq!(record.length, 4);
            assert_eq!(record.opt1, 2);
            assert_eq!(record.opt2, 3);
            assert_eq!(record.data.len(), 4);
        }
        Err(err) => panic!("{:?}", err),
    }
}

#[test]
fn test_read_entries_provided_by_helper() {
    let mut data_cursor = Cursor::new(vec![]);
    data_cursor.write_u32::<LittleEndian>(0xdeadbeef).unwrap();
    let mut mul_reader =
        simple_from_vecs(vec![(vec![255], 0, 0), (data_cursor.into_inner(), 0, 0)]);
    let record1 = mul_reader.read(0);
    let record2 = mul_reader.read(1);
    match record1 {
        Ok(record) => {
            assert_eq!(record.start, 0);
            assert_eq!(record.length, 1);
            assert_eq!(record.opt1, 0);
            assert_eq!(record.opt2, 0);
            assert_eq!(record.data.len(), 1);
            assert_eq!(record.data[0], 255);
        }
        Err(err) => panic!("{:?}", err),
    };
    match record2 {
        Ok(record) => {
            assert_eq!(record.start, 1);
            assert_eq!(record.length, 4);
            assert_eq!(record.opt1, 0);
            assert_eq!(record.opt2, 0);
            assert_eq!(record.data.len(), 4);
        }
        Err(err) => panic!("{:?}", err),
    }
}

#[test]
fn test_read_impossible_entry() {
    let mut mul_reader = fake_reader();
    let record = mul_reader.read(999999);
    match record {
        Ok(_record) => panic!("Unexpectedly read a result from a known impossible address"),
        Err(_) => {
            //Passed
        }
    }
}

#[test]
fn test_write_simple_mul() {
    match MulWriter::new(
        Path::new("./target/test_mul_out.idx"),
        Path::new("./target/test_mul_out.mul"),
        MulWriterMode::Truncate,
    ) {
        Ok(mut mul_writer) => {
            let mut out_buffer = CString::new("Bakery").unwrap().into_bytes();
            out_buffer.insert(0, 1);
            match mul_writer.append(&out_buffer, None, None) {
                Ok(_) => {
                    //Success
                }
                Err(message) => panic!("{}", message),
            }
        }
        Err(message) => panic!("{}", message),
    }
}