wirespec-syntax 0.4.2

Parser and AST for the wirespec protocol description language
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

use wirespec_syntax::ast::*;
use wirespec_syntax::parse;

#[test]
fn parse_extern_asn1_single_type() {
    let ast = parse(r#"extern asn1 "supl/SUPL.asn1" { SuplPosInit }"#).unwrap();
    assert_eq!(ast.items.len(), 1);
    match &ast.items[0] {
        wirespec_syntax::ast::AstTopItem::ExternAsn1(e) => {
            assert_eq!(e.path, "supl/SUPL.asn1");
            assert_eq!(e.rust_module, None);
            assert_eq!(e.type_names, vec!["SuplPosInit"]);
        }
        other => panic!("expected ExternAsn1, got {:?}", other),
    }
}

#[test]
fn parse_extern_asn1_with_use() {
    let ast = parse(r#"extern asn1 "SUPL.asn1" use supl_types { SuplPosInit }"#).unwrap();
    match &ast.items[0] {
        wirespec_syntax::ast::AstTopItem::ExternAsn1(e) => {
            assert_eq!(e.path, "SUPL.asn1");
            assert_eq!(e.rust_module.as_deref(), Some("supl_types"));
            assert_eq!(e.type_names, vec!["SuplPosInit"]);
        }
        other => panic!("expected ExternAsn1, got {:?}", other),
    }
}

#[test]
fn parse_asn1_field_with_length() {
    let ast = parse(
        r#"
        extern asn1 "s.asn1" { Foo }
        packet P {
            length: u16,
            payload: asn1(Foo, encoding: uper, length: length),
        }
    "#,
    )
    .unwrap();
    let packet = match &ast.items[1] {
        AstTopItem::Packet(p) => p,
        other => panic!("expected Packet, got {:?}", other),
    };
    let payload_field = packet
        .fields
        .iter()
        .find(|f| matches!(f, AstFieldItem::Field(fd) if fd.name == "payload"))
        .unwrap();
    match payload_field {
        AstFieldItem::Field(fd) => match &fd.type_expr {
            AstTypeExpr::Asn1 {
                type_name,
                encoding,
                length,
                ..
            } => {
                assert_eq!(type_name, "Foo");
                assert_eq!(encoding, "uper");
                assert!(matches!(length, Asn1Length::Expr(_)));
            }
            other => panic!("expected Asn1 type, got {:?}", other),
        },
        _ => panic!("expected Field"),
    }
}

#[test]
fn parse_asn1_field_with_remaining() {
    let ast = parse(
        r#"
        extern asn1 "s.asn1" { Bar }
        packet P {
            payload: asn1(Bar, encoding: uper, remaining),
        }
    "#,
    )
    .unwrap();
    let packet = match &ast.items[1] {
        AstTopItem::Packet(p) => p,
        other => panic!("expected Packet, got {:?}", other),
    };
    let payload_field = packet
        .fields
        .iter()
        .find(|f| matches!(f, AstFieldItem::Field(fd) if fd.name == "payload"))
        .unwrap();
    match payload_field {
        AstFieldItem::Field(fd) => match &fd.type_expr {
            AstTypeExpr::Asn1 {
                type_name,
                encoding,
                length,
                ..
            } => {
                assert_eq!(type_name, "Bar");
                assert_eq!(encoding, "uper");
                assert!(matches!(length, Asn1Length::Remaining));
            }
            other => panic!("expected Asn1 type, got {:?}", other),
        },
        _ => panic!("expected Field"),
    }
}

#[test]
fn parse_extern_asn1_multiple_types() {
    let ast = parse(r#"extern asn1 "schema.asn1" { TypeA, TypeB, TypeC }"#).unwrap();
    match &ast.items[0] {
        wirespec_syntax::ast::AstTopItem::ExternAsn1(e) => {
            assert_eq!(e.type_names, vec!["TypeA", "TypeB", "TypeC"]);
        }
        other => panic!("expected ExternAsn1, got {:?}", other),
    }
}