mls-spec 2.0.0

This crate is a repository of MLS / RFC9420-related data structures.
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

#![allow(dead_code, unused_macros)]

pub mod assertions {
    #[macro_export]
    macro_rules! assert_eq_err {
        ($actual:expr, $expected:expr, $msg:expr) => {{
            color_eyre::eyre::ensure!(
                $actual == $expected,
                "{}\n{}",
                $msg,
                pretty_assertions::Comparison::new(&$actual, &$expected)
            )
        }};
        ($actual:expr, $expected:expr) => {{
            color_eyre::eyre::ensure!(
                $actual == $expected,
                "{}",
                pretty_assertions::Comparison::new(&$actual, &$expected)
            )
        }};
    }

    #[macro_export]
    macro_rules! assert_ne_err {
        ($actual:expr, $expected:expr, $msg:expr) => {
            color_eyre::eyre::ensure!(
                $actual != $expected,
                "{} {} == {}",
                $msg,
                stringify!($actual),
                strinfify!($expected),
            )
        };
        ($actual:expr, $expected:expr) => {
            color_eyre::eyre::ensure!(
                $actual != $expected,
                "{} == {}",
                stringify!($actual),
                stringify!($expected)
            )
        };
    }

    #[macro_export]
    macro_rules! assert_err {
        ($assertion:expr, $msg:expr) => {
            color_eyre::eyre::ensure!($assertion, "{} {:?} != true", $msg, $assertion)
        };
        ($assertion:expr) => {
            color_eyre::eyre::ensure!($assertion, "{:?} != true", $assertion)
        };
    }

    pub use assert_eq_err;
    pub use assert_err;
    pub use assert_ne_err;
}

// TODO: Use this macro to roundtrip all the structs in the drafts
pub(crate) mod testing {
    #[cfg(not(feature = "serde"))]
    pub trait Target: crate::Parsable + crate::Serializable + std::fmt::Debug + PartialEq {}
    #[cfg(not(feature = "serde"))]
    impl<T> Target for T where T: crate::Parsable + crate::Serializable + std::fmt::Debug + PartialEq {}

    #[cfg(feature = "serde")]
    pub trait Target:
        crate::Parsable
        + crate::Serializable
        + serde::Serialize
        + for<'a> serde::Deserialize<'a>
        + std::fmt::Debug
        + PartialEq
    {
    }
    #[cfg(feature = "serde")]
    impl<T> Target for T where
        T: crate::Parsable
            + crate::Serializable
            + serde::Serialize
            + for<'a> serde::Deserialize<'a>
            + std::fmt::Debug
            + PartialEq
    {
    }

    pub(crate) fn roundtrip<T: Target>(value: &T, ctx: &str) -> color_eyre::eyre::Result<()> {
        let _ = color_eyre::install();
        let value_bytes = value.to_tls_bytes()?;
        let value2 = T::from_tls_bytes(&value_bytes)?;
        super::assertions::assert_eq_err!(value, &value2);
        println!("==== --> [{ctx}] TLSPL OK");

        #[cfg(feature = "serde")]
        {
            let value3_bytes = postcard::to_stdvec(&value)?;
            let value3 = postcard::from_bytes(&value3_bytes)?;
            super::assertions::assert_eq_err!(value, &value3);
            println!("==== --> [{ctx}] serde+postcard OK");

            let value4_bytes = serde_json::to_vec(&value)?;
            let value4 = serde_json::from_slice(&value4_bytes)?;
            super::assertions::assert_eq_err!(value, &value4);
            println!("==== --> [{ctx}] serde+json OK");
        }
        Ok(())
    }

    #[macro_export]
    macro_rules! generate_roundtrip_test {
        ($testname:ident, $iv:expr) => {
            #[test]
            fn $testname() -> color_eyre::eyre::Result<()> {
                $crate::test_utils::testing::roundtrip(&$iv, stringify!($testname))?;
                Ok(())
            }
        };
    }
}