bc-envelope 0.43.0

Gordian Envelope for Rust.
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
125
126

use bc_components::Digest;
use bc_envelope::prelude::*;
use indoc::indoc;

mod common;
use crate::common::check_encoding::*;

#[test]
fn test_digest() {
    Envelope::new(Digest::from_image("Hello.".as_bytes()))
        .check_encoding()
        .unwrap();
}

#[test]
fn test_1() -> EnvelopeResult<()> {
    let e = Envelope::new("Hello.");

    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e.diagnostic_annotated(), indoc! {r#"
        200(   / envelope /
            201("Hello.")   / leaf /
        )
    "#}.trim());

    Ok(())
}

#[test]
fn test_2() -> EnvelopeResult<()> {
    let array: Vec<u64> = vec![1, 2, 3];
    let e = Envelope::new(Into::<CBOR>::into(array));

    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e.diagnostic_annotated(), indoc! {r#"
        200(   / envelope /
            201(   / leaf /
                [1, 2, 3]
            )
        )
    "#}.trim());

    Ok(())
}

#[test]
fn test_3() -> EnvelopeResult<()> {
    let e1 = Envelope::new_assertion("A", "B").check_encoding()?;
    let e2 = Envelope::new_assertion("C", "D").check_encoding()?;
    let e3 = Envelope::new_assertion("E", "F").check_encoding()?;

    let e4 = e2.add_assertion_envelope(e3).unwrap();
    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e4.format(), indoc! {r#"
        {
            "C": "D"
        } [
            "E": "F"
        ]
    "#}.trim());

    // println!("{}", e4.diagnostic_annotated());

    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e4.diagnostic_annotated(), indoc! {r#"
        200(   / envelope /
            [
                {
                    201("C"):   / leaf /
                    201("D")   / leaf /
                },
                {
                    201("E"):   / leaf /
                    201("F")   / leaf /
                }
            ]
        )
    "#}.trim());

    e4.check_encoding()?;

    let e5 = e1.add_assertion_envelope(e4).unwrap().check_encoding()?;

    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e5.format(), indoc! {r#"
        {
            "A": "B"
        } [
            {
                "C": "D"
            } [
                "E": "F"
            ]
        ]
    "#}.trim());

    // expected-text-output-rubric:
    #[rustfmt::skip]
    assert_actual_expected!(e5.diagnostic_annotated(), indoc! {r#"
        200(   / envelope /
            [
                {
                    201("A"):   / leaf /
                    201("B")   / leaf /
                },
                [
                    {
                        201("C"):   / leaf /
                        201("D")   / leaf /
                    },
                    {
                        201("E"):   / leaf /
                        201("F")   / leaf /
                    }
                ]
            ]
        )
    "#}.trim());

    Ok(())
}