wire-repr 0.3.0

A no_std, no_alloc Rust library for wire representations.
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

use wire_repr::wire_repr;

wire_repr! {
    pub layout Framed {
        field tail: U8 { position: 6; }
        align { position: 5; boundary: 4; }
        field second: bytes(current_pos..current_pos + length) { position: 4; }
        padding { position: 3; length: 1; }
        /// The first opaque range.
        field first: bytes(current_pos..current_pos + length) { position: 2; }
        field length: U8 { position: 1; }
    }

    pub layout EmptyRanges {
        field tail: U8 { position: 4; }
        field second: bytes(current_pos..current_pos + length) { position: 3; }
        field first: bytes(current_pos..current_pos + length) { position: 2; }
        field length: U8 { position: 1; }
    }

    pub layout AdjacentMutableRanges {
        field first_length: U8 { position: 1; }
        field second_length: U8 { position: 2; }
        field first: bytes(current_pos..current_pos + first_length) { position: 3; }
        field second: bytes(current_pos..current_pos + second_length) { position: 4; }
        field tail: U8 { position: 5; }
    }

    pub layout WideLength {
        field payload: bytes(current_pos..current_pos + length) { position: 2; }
        field length: BeU128 { position: 1; }
    }

    pub layout ShortFramed {
        field payload: bytes(current_pos..current_pos + length) { position: 2; }
        field length: U8 { position: 1; }
    }
}

#[test]
fn fixed_lengths_frame_exact_ranges_and_preserve_caller_suffix() {
    let noncanonical = [2, b'a', b'b', 0xee, b'c', b'd', 0xff, 0xf0, 9, 0xaa];
    let (view, suffix) = FramedView::parse_prefix(&noncanonical).unwrap();

    assert_eq!(view.as_bytes(), &noncanonical[..9]);
    assert_eq!(suffix, &[0xaa]);
    assert_eq!(view.length(), 2);
    assert_eq!(view.first(), b"ab");
    assert_eq!(view.second(), b"cd");
    assert_eq!(view.tail(), 9);

    let canonical = [2, b'a', b'b', 0xee, b'c', b'd', 0xf0, 0xf1, 9];
    let view = FramedView::parse_exact(&canonical).unwrap();
    assert_eq!(view.length(), 2);
    assert_eq!(view.first(), b"ab");
    assert_eq!(view.second(), b"cd");
    assert_eq!(view.tail(), 9);
}

#[test]
fn adjacent_zero_length_ranges_are_exact_and_do_not_stall_physical_progress() {
    let bytes = [0, 9];
    let view = EmptyRangesView::parse_exact(&bytes).unwrap();

    assert_eq!(view.length(), 0);
    assert!(view.first().is_empty());
    assert!(view.second().is_empty());
    assert_eq!(view.tail(), 9);
    assert_eq!(view.as_bytes(), &bytes);
}

#[test]
fn adjacent_mutable_ranges_respect_each_validated_boundary() {
    let mut bytes = [2, 2, b'a', b'b', b'c', b'd', 9];
    {
        let mut view = AdjacentMutableRangesViewMut::parse_exact_mut(&mut bytes).unwrap();
        view.first_mut().copy_from_slice(b"AB");
        view.second_mut().copy_from_slice(b"CD");
        assert_eq!(view.first(), b"AB");
        assert_eq!(view.second(), b"CD");
        assert_eq!(view.tail(), 9);
    }
    assert_eq!(bytes, [2, 2, b'A', b'B', b'C', b'D', 9]);

    let mut empty_first = [0, 2, b'x', b'y', 9];
    {
        let mut view = AdjacentMutableRangesViewMut::parse_exact_mut(&mut empty_first).unwrap();
        assert!(view.first_mut().is_empty());
        view.second_mut().copy_from_slice(b"XY");
        assert_eq!(view.tail(), 9);
    }
    assert_eq!(empty_first, [0, 2, b'X', b'Y', 9]);
}

#[test]
fn conversion_and_shortage_errors_precede_later_physical_entries() {
    let too_wide = [0xff; 16];
    assert!(matches!(
        WideLengthView::parse_prefix(&too_wide),
        Err(WideLengthError::InvalidRangeSource {
            position: 2,
            source_position: 1,
        })
    ));

    let short = [3, b'a'];
    assert!(matches!(
        ShortFramedView::parse_prefix(&short),
        Err(ShortFramedError::InputTooShort {
            position: 2,
            expected: 3,
            available: 1,
        })
    ));

    assert!(matches!(
        ShortFramedView::parse_prefix(&[]),
        Err(ShortFramedError::InputTooShort {
            position: 1,
            expected: 1,
            available: 0,
        })
    ));
}