lightpack 0.2.8

A lightweight, no-std binary serialization 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
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
152
153
154
155

use byteorder::{ByteOrder, BigEndian, LittleEndian};
use lightpack::{Pack, Size, extra::{BE, LE, PackSize}};

fn pack_vec<B, P>(value: P) -> Vec<u8> where B: ByteOrder, P: Pack {
    let mut buffer = vec![0u8; P::SIZE];
    value.pack::<B>(&mut buffer);
    buffer
}

#[test]
fn unsigned_ints() {
    assert_eq!(pack_vec::<BigEndian, u8>(0), vec![0]);
    assert_eq!(pack_vec::<BigEndian, u16>(4), vec![0, 4]);
    assert_eq!(pack_vec::<LittleEndian, u16>(4), vec![4, 0]);
    assert_eq!(pack_vec::<BigEndian, u16>(258), vec![1, 2]);
    assert_eq!(pack_vec::<LittleEndian, u16>(258), vec![2, 1]);
    assert_eq!(pack_vec::<LittleEndian, u32>(1048), vec![24, 0b100, 0, 0]);
    assert_eq!(pack_vec::<BigEndian, u32>(1048), vec![0, 0, 0b100, 24]);
}

#[test]
fn signed_ints() {
    assert_eq!(pack_vec::<BigEndian, i8>(0), vec![0]);
    assert_eq!(pack_vec::<BigEndian, i8>(-1), vec![255]);
    assert_eq!(pack_vec::<LittleEndian, i8>(-2), vec![254]);
    assert_eq!(pack_vec::<BigEndian, i16>(256), vec![1, 0]);
    assert_eq!(pack_vec::<LittleEndian, i16>(256), vec![0, 1]);
}

#[test]
fn basic_structs() {
    #[derive(Size, Pack, Clone, Copy)]
    #[allow(dead_code)]
    struct X {
        x: u8,
        y: u16,
    }

    #[derive(Size, Pack, Clone, Copy)]
    #[allow(dead_code)]
    struct Y {
        x0: X,
        x1: X,
        x2: bool,
    }

    #[derive(Size, Pack, Clone, Copy)]
    struct Tuple(X, Y);

    #[derive(Size, Pack, Clone, Copy)]
    struct Unit;

    let x0 = X { x: 3, y: 4 };
    let x1 = X { x: 2, y: 8 };
    let y = Y { x0, x1, x2: true };

    assert_eq!(pack_vec::<BigEndian, _>(x0), vec![3, 0, 4]);
    assert_eq!(pack_vec::<LittleEndian, _>(x1), vec![2, 8, 0]);
    assert_eq!(pack_vec::<BigEndian, _>(y), vec![3, 0, 4, 2, 0, 8, 1]);
    assert_eq!(pack_vec::<BigEndian, _>(Tuple(x0, y)), vec![3, 0, 4, 3, 0, 4, 2, 0, 8, 1]);
    assert_eq!(pack_vec::<BigEndian, _>(Unit), vec![]);
}

#[test]
fn generic_structs() {
    #[derive(Size, Pack)]
    #[allow(dead_code)]
    struct Wrap<T>(T);

    #[derive(Size, Pack)]
    #[allow(dead_code)]
    struct Pair<L, R> {
        left: L,
        right: R,
    }

    #[derive(Size, Pack)]
    #[allow(dead_code)]
    struct HasField {
        wrap: Wrap<u32>,
    }

    #[derive(Size, Pack)]
    #[allow(dead_code)]
    struct HasGenericField<T> {
        wrap: Wrap<T>,
        x: bool,
    }

    assert_eq!(pack_vec::<LittleEndian, _>(Wrap(3i32)), vec![3, 0, 0, 0]);
    assert_eq!(pack_vec::<BigEndian, _>(Wrap(4u16)), vec![0, 4]);
    assert_eq!(pack_vec::<BigEndian, _>(Pair { left: -4i16, right: 3u8 }), pack_vec::<BigEndian, _>((-4i16, 3u8)));
    assert_eq!(pack_vec::<BigEndian, _>(HasField { wrap: Wrap(4u32) }), vec![0, 0, 0, 4]);
    assert_eq!(pack_vec::<LittleEndian, _>(HasGenericField { wrap: Wrap(false), x: true }), vec![0, 1]);
}

#[test]
fn primitive_enums() {
    #[derive(Size, Pack, Clone, Copy)]
    #[repr(u8)]
    #[allow(dead_code)]
    enum X {
        A = 1,
        B = 4,
        C = 8,
    }

    #[derive(Size, Pack, Clone, Copy)]
    #[repr(i32)]
    #[allow(dead_code)]
    enum Y {
        A = -9,
    }

    assert_eq!(pack_vec::<BigEndian, _>(X::A), vec![1]);
    assert_eq!(pack_vec::<BigEndian, _>(X::B), vec![4]);
    assert_eq!(pack_vec::<BigEndian, _>(X::C), vec![8]);
}

#[test]
fn arrays() {
    assert_eq!(pack_vec::<BigEndian, _>([0u32; 0]), vec![]);
    assert_eq!(pack_vec::<BigEndian, _>([-1i8]), vec![255]);
    assert_eq!(pack_vec::<BigEndian, _>([16u32; 3]), vec![0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 16]);
    assert_eq!(pack_vec::<BigEndian, _>([3u8, 4, 1, 0, 2]), vec![3, 4, 1, 0, 2]);
    assert_eq!(pack_vec::<LittleEndian, _>([2i16, 3, -1]), vec![2, 0, 3, 0, 255, 255]);
    assert_eq!(pack_vec::<LittleEndian, _>([(true, false), (false, false), (true, true)]), vec![1, 0, 0, 0, 1, 1]);
}

#[test]
fn fixed_endianness() {
    assert_eq!(pack_vec::<BigEndian, _>(BE(45u16)), pack_vec::<BigEndian, u16>(45));
    assert_eq!(pack_vec::<LittleEndian, _>(BE(45u16)), pack_vec::<BigEndian, u16>(45));
    assert_eq!(pack_vec::<BigEndian, _>(LE(45u16)), pack_vec::<LittleEndian, u16>(45));
    assert_eq!(pack_vec::<LittleEndian, _>(LE(45u16)), pack_vec::<LittleEndian, u16>(45));
}

#[test]
fn mixed_endianness() {
    #[derive(Size, Pack)]
    struct Mixed {
        le: LE<u16>,
        be: BE<u16>,
    }

    assert_eq!(pack_vec::<BigEndian, _>(Mixed { le: LE(256), be: BE(256) }), vec![0, 1, 1, 0]);
    assert_eq!(pack_vec::<LittleEndian, _>(Mixed { le: LE(256), be: BE(256) }), vec![0, 1, 1, 0]);
}

#[test]
fn test_pack_size() {
    let mut buffer = [0u8; 4];
    assert_eq!(3u16.pack_size::<BigEndian>(&mut buffer), u16::SIZE);
    assert_eq!(2u32.pack_size::<BigEndian>(&mut buffer), u32::SIZE);
}