minbin 0.1.1

Minimal, manual, no-std, zero-dependency, big-endian binary serialization.
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

use minbin::{read_bytes, write_bytes, ToFromBytes};

#[test]
fn test_u8() {
    for expected in [u8::MIN, 42, u8::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (u8, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_i8() {
    for expected in [i8::MIN, 42, i8::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (i8, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_u16() {
    for expected in [u16::MIN, 42, u16::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (u16, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_i16() {
    for expected in [i16::MIN, 42, i16::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (i16, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_u32() {
    for expected in [u32::MIN, 42, u32::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (u32, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_i32() {
    for expected in [i32::MIN, 42, i32::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (i32, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_u64() {
    for expected in [u64::MIN, 42, u64::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (u64, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_i64() {
    for expected in [i64::MIN, 42, i64::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (i64, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_u128() {
    for expected in [u128::MIN, 42, u128::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (u128, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}

#[test]
fn test_i128() {
    for expected in [i128::MIN, 42, i128::MAX] {
        let mut buffer = vec![0u8; expected.byte_count()];
        let write_pos = write_bytes(&expected, &mut buffer).unwrap();
        let (actual, read_pos): (i128, usize) = read_bytes(&buffer[..write_pos]).unwrap();

        assert_eq!(expected.byte_count(), read_pos);
        assert_eq!(expected, actual);
    }
}