xc3_write 0.21.0

xc3_lib binary writing and layout
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

use std::io::Cursor;

use hexlit::hex;
use xc3_write::{Endian, WriteFull, Xc3Write, Xc3WriteOffsets, assert_hex_eq};

#[test]
fn write_offset() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32))]
        a: u32,
    }

    let value = Test { a: 1 };

    let mut writer = Cursor::new(Vec::new());
    value.xc3_write(&mut writer, Endian::Little).unwrap();

    assert_hex_eq!(hex!(00000000), writer.into_inner());
}

#[test]
fn write_offset_full() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32))]
        inner: Inner,
    }

    #[derive(Xc3Write, Xc3WriteOffsets)]
    #[xc3(align(8))]
    struct Inner {
        a: u32,
    }

    let value = Test {
        inner: Inner { a: 1 },
    };

    let mut writer = Cursor::new(Vec::new());
    let mut data_ptr = 0;
    value
        .write_full(&mut writer, 0, &mut data_ptr, Endian::Little, ())
        .unwrap();

    assert_hex_eq!(hex!(08000000 00000000 01000000), writer.into_inner());
    assert_eq!(12, data_ptr);
}

#[test]
fn write_offset_full_align_0x0() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32), align(8))]
        a: u32,
    }

    let value = Test { a: 1 };

    let mut writer = Cursor::new(Vec::new());
    let mut data_ptr = 0;
    value
        .write_full(&mut writer, 0, &mut data_ptr, Endian::Little, ())
        .unwrap();

    assert_hex_eq!(hex!(08000000 00000000 01000000), writer.into_inner());
    assert_eq!(12, data_ptr);
}

#[test]
fn write_offset_full_align_0xff() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32), align(8, 0xff))]
        a: u32,
    }

    let value = Test { a: 1 };

    let mut writer = Cursor::new(Vec::new());
    let mut data_ptr = 0;
    value
        .write_full(&mut writer, 0, &mut data_ptr, Endian::Little, ())
        .unwrap();

    assert_hex_eq!(hex!(08000000 ffffffff 01000000), writer.into_inner());
    assert_eq!(12, data_ptr);
}

#[test]
fn write_offset_full_optional_offset_some() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32))]
        a: Option<u32>,
    }

    let value = Test { a: Some(1) };

    let mut writer = Cursor::new(Vec::new());
    let mut data_ptr = 0;
    value
        .write_full(&mut writer, 0, &mut data_ptr, Endian::Little, ())
        .unwrap();

    assert_hex_eq!(hex!(04000000 01000000), writer.into_inner());
    assert_eq!(8, data_ptr);
}

#[test]
fn write_offset_full_optional_offset_none() {
    #[derive(Xc3Write, Xc3WriteOffsets)]
    struct Test {
        #[xc3(offset(u32))]
        a: Option<u32>,
    }

    // This should still write a null offset.
    let value = Test { a: None };

    let mut writer = Cursor::new(Vec::new());
    let mut data_ptr = 0;
    value
        .write_full(&mut writer, 0, &mut data_ptr, Endian::Little, ())
        .unwrap();

    assert_hex_eq!(hex!(00000000), writer.into_inner());
    assert_eq!(4, data_ptr);
}