veriform 0.2.0

Cryptographically verifiable data serialization format inspired by Protocol Buffers
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

//! Integration tests for `veriform_derive`

use heapless::{
    consts::{U1024, U8},
    Vec,
};
use veriform::{Decoder, Message};

/// Buffer type.
///
/// Using `heapless::Vec` lets us test on `no_std`.
type Buffer = Vec<u8, U1024>;

/// Create a new buffer for encoding tests
pub fn new_buffer() -> Buffer {
    let mut vec = Vec::new();
    vec.extend_from_slice(&[0u8; 1024]).unwrap();
    vec
}

#[derive(Message, Debug, Eq, PartialEq)]
pub struct EmptyStruct {}

#[derive(Message, Debug, Eq, PartialEq)]
pub enum ExampleEnum {
    #[field(tag = 0, wire_type = "bytes", size = 32)]
    BytesVariant([u8; 32]),

    #[field(tag = 1, wire_type = "message")]
    MessageVariant(EmptyStruct),
}

impl Default for ExampleEnum {
    fn default() -> Self {
        Self::BytesVariant([
            0, 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,
        ])
    }
}

#[test]
fn enum_round_trip() {
    let example = ExampleEnum::default();

    let mut encoded_buf = new_buffer();
    let encoded_len = example.encode(&mut encoded_buf).unwrap().len();
    encoded_buf.truncate(encoded_len);

    let mut decoder = Decoder::new();
    let decoded = ExampleEnum::decode(&mut decoder, &encoded_buf).unwrap();

    assert_eq!(example, decoded);
}

#[derive(Message, Debug, Eq, PartialEq)]
pub struct ExampleStruct {
    #[field(tag = 0, wire_type = "uint64", critical = true)]
    pub uint64_field: u64,

    #[field(tag = 1, wire_type = "sint64", critical = true)]
    pub sint64_field: i64,

    #[field(tag = 2, wire_type = "sequence", critical = true, max = 8)]
    pub msg_sequence_field: heapless::Vec<ExampleEnum, U8>,

    #[digest(alg = "sha256")]
    pub digest: Option<veriform::Sha256Digest>,
}

impl Default for ExampleStruct {
    fn default() -> Self {
        let mut msg_sequence_field = heapless::Vec::new();

        for _ in 0..3 {
            msg_sequence_field.push(ExampleEnum::default()).unwrap();
        }

        Self {
            uint64_field: 42,
            sint64_field: -42,
            msg_sequence_field,
            digest: None,
        }
    }
}

#[test]
fn struct_round_trip() {
    let mut example = ExampleStruct::default();

    let mut encoded_buf = new_buffer();
    let encoded_len = example.encode(&mut encoded_buf).unwrap().len();
    encoded_buf.truncate(encoded_len);

    let mut decoder = Decoder::new();
    let decoded = ExampleStruct::decode(&mut decoder, &encoded_buf).unwrap();

    // Expected digest
    example.digest = Some([
        184, 86, 174, 227, 32, 40, 78, 107, 138, 228, 168, 208, 186, 189, 128, 164, 210, 15, 126,
        220, 90, 4, 255, 19, 230, 230, 211, 218, 188, 104, 230, 87,
    ]);

    assert_eq!(example, decoded);
}