bitbuffer 0.11.3

Reading bit sequences from a byte slice
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 bitbuffer::{
    BigEndian, BitRead, BitReadBuffer, BitReadStream, BitWrite, BitWriteStream, LittleEndian,
};
use std::fmt::Debug;

#[track_caller]
fn roundtrip<
    T: BitRead<'static, BigEndian>
        + BitWrite<BigEndian>
        + BitRead<'static, LittleEndian>
        + BitWrite<LittleEndian>
        + Debug
        + PartialEq,
>(
    val: T,
) {
    {
        let mut data = Vec::new();
        let size = {
            let mut stream = BitWriteStream::new(&mut data, LittleEndian);
            stream.write(&val).unwrap();
            stream.bit_len()
        };
        let mut read = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
        assert_eq!(val, read.read().unwrap());
        assert_eq!(size, read.pos());
    }
    {
        let mut data = Vec::new();
        let size = {
            let mut stream = BitWriteStream::new(&mut data, BigEndian);
            stream.write(&val).unwrap();
            stream.bit_len()
        };
        let mut read = BitReadStream::new(BitReadBuffer::new_owned(data, BigEndian));
        assert_eq!(val, read.read().unwrap());
        assert_eq!(size, read.pos());
    }
}

#[test]
fn test_basic_struct() {
    #[derive(Debug, PartialEq, BitRead, BitWrite)]
    struct Foo {
        int: u32,
        float: f64,
        #[size = 2]
        smaller_int: u8,
        signed: i32,
        #[size = 3]
        smaller_signed: i32,
        dynamic_string: String,
        #[size = 3]
        fixed_string: String,
    }
    roundtrip(Foo {
        int: 1234,
        float: 10.2,
        smaller_int: 3,
        signed: -3,
        smaller_signed: -1,
        dynamic_string: "Foobar".to_string(),
        fixed_string: "asd".to_string(),
    });
}

#[test]
fn test_bare_enum() {
    #[derive(Debug, PartialEq, BitRead, BitWrite)]
    #[discriminant_bits = 4]
    enum Enum {
        A,
        B,
        C,
        D,
    }
    roundtrip(Enum::A);
    roundtrip(Enum::B);
    roundtrip(Enum::C);
    roundtrip(Enum::D);
}

#[test]
fn test_field_enum() {
    #[derive(Debug, PartialEq, BitRead, BitWrite)]
    struct CompoundVariant(#[size = 15] u16, bool);

    #[derive(Debug, PartialEq, BitRead, BitWrite)]
    #[discriminant_bits = 4]
    enum Enum {
        A,
        B(String),
        C(f32),
        D(#[size = 15] i64),
        E(CompoundVariant),
    }
    roundtrip(Enum::A);
    roundtrip(Enum::B("foobar".into()));
    roundtrip(Enum::C(12.0));
    roundtrip(Enum::D(-12345));
    roundtrip(Enum::E(CompoundVariant(6789, true)));
}

#[test]
fn test_array() {
    roundtrip([1, 2, 3, 4, 5]);
    roundtrip([String::from("asd"), String::from("foobar")]);
}

#[test]
fn test_tuple() {
    roundtrip((1, false));
    roundtrip((1, 10.12, String::from("asd")));
}