serial_traits 1.1.2

A trait that allows you to serialize to and parse from Vec<u8> buffers. Comes with implementations for primitive types, String and generic collection types (if the item type implements the trait too.)
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

#[cfg(test)]
mod tests {
    use crate::leb128;
    use rand;
    use rand::Rng;

    macro_rules! test_leb128 {
        ($name:tt, $primitive:ty) => {
            #[test]
            fn $name() {
                let value = rand::rng().random::<u128>() as $primitive;

                let mut buffer = leb128::serialize(value);
                let result = leb128::parse::<$primitive>(&mut buffer);

                match result {
                    Some(outcome) => assert_eq!(value, outcome),
                    None => panic!(),
                }
            }
        };
    }

    test_leb128!(test_u8, u8);
    test_leb128!(test_u16, u16);
    test_leb128!(test_u32, u32);
    test_leb128!(test_u64, u64);
    test_leb128!(test_u128, u128);
    test_leb128!(test_usize, usize);
    test_leb128!(test_i8, i8);
    test_leb128!(test_i16, i16);
    test_leb128!(test_i32, i32);
    test_leb128!(test_i64, i64);
    test_leb128!(test_i128, i128);
    test_leb128!(test_isize, isize);

    macro_rules! test_leb128_bytesize {
        ($name:tt, $expected_bytesize:expr, $negative:expr) => {
            #[test]
            fn $name() {
                let mut value = 1 << (($expected_bytesize - 1) * 7 + 5);

                if $negative {
                    value *= -1;
                }

                let mut buffer = leb128::serialize::<i128>(value);

                assert_eq!($expected_bytesize, buffer.len());

                let result = leb128::parse::<i128>(&mut buffer);

                match result {
                    Some(outcome) => assert_eq!(value, outcome),
                    None => panic!(),
                }
            }
        };
    }

    test_leb128_bytesize!(test_bytesize_1_positive, 1, false);
    test_leb128_bytesize!(test_bytesize_1_negative, 1, true);
    test_leb128_bytesize!(test_bytesize_2_positive, 2, false);
    test_leb128_bytesize!(test_bytesize_2_negative, 2, true);
    test_leb128_bytesize!(test_bytesize_3_positive, 3, false);
    test_leb128_bytesize!(test_bytesize_3_negative, 3, true);
    test_leb128_bytesize!(test_bytesize_4_positive, 4, false);
    test_leb128_bytesize!(test_bytesize_4_negative, 4, true);
    test_leb128_bytesize!(test_bytesize_5_positive, 5, false);
    test_leb128_bytesize!(test_bytesize_5_negative, 5, true);
    test_leb128_bytesize!(test_bytesize_6_positive, 6, false);
    test_leb128_bytesize!(test_bytesize_6_negative, 6, true);
    test_leb128_bytesize!(test_bytesize_7_positive, 7, false);
    test_leb128_bytesize!(test_bytesize_7_negative, 7, true);
    test_leb128_bytesize!(test_bytesize_8_positive, 8, false);
    test_leb128_bytesize!(test_bytesize_8_negative, 8, true);
    test_leb128_bytesize!(test_bytesize_9_positive, 9, false);
    test_leb128_bytesize!(test_bytesize_9_negative, 9, true);
    test_leb128_bytesize!(test_bytesize_10_positive, 10, false);
    test_leb128_bytesize!(test_bytesize_10_negative, 10, true);
    test_leb128_bytesize!(test_bytesize_11_positive, 11, false);
    test_leb128_bytesize!(test_bytesize_11_negative, 11, true);
    test_leb128_bytesize!(test_bytesize_12_positive, 12, false);
    test_leb128_bytesize!(test_bytesize_12_negative, 12, true);
    test_leb128_bytesize!(test_bytesize_13_positive, 13, false);
    test_leb128_bytesize!(test_bytesize_13_negative, 13, true);
    test_leb128_bytesize!(test_bytesize_14_positive, 14, false);
    test_leb128_bytesize!(test_bytesize_14_negative, 14, true);
    test_leb128_bytesize!(test_bytesize_15_positive, 15, false);
    test_leb128_bytesize!(test_bytesize_15_negative, 15, true);
    test_leb128_bytesize!(test_bytesize_16_positive, 16, false);
    test_leb128_bytesize!(test_bytesize_16_negative, 16, true);

    macro_rules! test_leb128_single_byte_type {
        ($name:tt, $prim_type:ty, $value:expr) => {
            #[test]
            fn $name() {
                let mut buffer = leb128::serialize::<$prim_type>($value);

                assert_eq!(1, buffer.len());

                let result = leb128::parse::<$prim_type>(&mut buffer);

                match result {
                    Some(outcome) => assert_eq!($value, outcome),
                    None => panic!(),
                }
            }
        };
    }

    test_leb128_single_byte_type!(test_single_byte_type_u8_0, u8, 0);
    test_leb128_single_byte_type!(test_single_byte_type_u8_255, u8, 255);
    test_leb128_single_byte_type!(test_single_byte_type_i8_n128, i8, -128);
    test_leb128_single_byte_type!(test_single_byte_type_i8_127, i8, 127);
}