sdp-nom 0.2.0

an sdp-parser
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

use std::fmt;

pub fn print_result<T: fmt::Debug>(input: &str, rest: &str, result: &T) {
    println!(
        "INPUT: {:?}\nLEFT:  {:?}\nRESULT: {:#?}",
        input, rest, result
    );
}

pub fn print_leftover(input: &str, rest: &str) {
    println!("INPUT: {:?}\nLEFT:  {:?}", input, rest);
}

trait AssertLinify {
    fn assert_linify(_: Self);
}

impl<T: fmt::Display> AssertLinify for T {
    fn assert_linify(_: T) {
        panic!("{:?} is Debug", std::any::type_name::<T>());
    }
}

#[macro_export]
macro_rules! assert_line {
    ($line:expr) => {{
        let (rest, _parsed) = $crate::sdp_line(&$line).unwrap();
        if !rest.is_empty() {
            $crate::assert::print_leftover($line, rest);
        }
        assert!(rest.is_empty(), "not parsed completely");
    }};

    ($parser:ident, $line:expr) => {
        assert_line!($line, $parser);
    };

    ($line:expr, $parser:ident) => {{
        let (rest, _parsed) = $parser(&$line).unwrap();
        if !rest.is_empty() {
            $crate::assert::print_leftover($line, rest);
        }
        assert!(rest.is_empty(), "not parsed completely");
    }};

    ($parser:ident, $line:expr, $expectation:expr) => {{
        let (rest, parsed) = $parser(&$line).unwrap();
        cfg_if::cfg_if! {
            if #[cfg(feature = "debug")] {
                $crate::assert::print_result($line, &rest, &parsed);
                pretty_assertions::assert_eq!(parsed, $expectation, "{:?} not parsed as expected", $line);
            } else {
                $crate::assert::print_leftover($line, &rest);
                assert!(parsed == $expectation);
            }
        }
        assert!(rest.is_empty(), "not parsed completely");
    }};

    ($parser:ident, $line:expr, $expectation:expr, print) => {{
        let (rest, parsed) = $parser(&$line).unwrap();
        
        cfg_if::cfg_if! {
            if #[cfg(feature = "debug")] {
                $crate::assert::print_result($line, &rest, &parsed);
                pretty_assertions::assert_eq!(parsed, $expectation, "{:?} not parsed as expected", $line);
            } else {
                $crate::assert::print_leftover($line, &rest);
                assert!(parsed == $expectation);
            }
        }
        assert!(rest.is_empty(), "not parsed completely");

        cfg_if::cfg_if! {
            if #[cfg(feature = "udisplay")] {
                let serialized = {
                    let mut output = String::new();
                    ufmt::uwrite!(output, "{}", parsed).unwrap();
                    output
                };

                pretty_assertions::assert_eq!($line, serialized);
            }
        }
    }};
}

// just for debugging, prints and fails
#[macro_export]
macro_rules! assert_line_dbg {
    ($parser:ident, $line:expr) => {{
        let (rest, _parsed) = $parser(&$line).unwrap();
        if !rest.is_empty() {
            $crate::assert::print_leftover($line, rest);
        }
        panic!("{:#?}", _parsed);
    }};
}

#[macro_export]
macro_rules! assert_line_print {
    ($parser:ident, $line:expr) => {{
        let (rest, _parsed) = $parser(&$line).unwrap();
        if !rest.is_empty() {
            $crate::assert::print_leftover($line, rest);
        }
        assert!(rest.is_empty(), "not parsed completely");

        cfg_if::cfg_if! {
            if #[cfg(feature = "udisplay")] {
                let serialized = {
                    let mut output = String::new();
                    ufmt::uwrite!(output, "{}", _parsed).unwrap();
                    output
                };
                assert_eq!($line, serialized);
            }
        }
    }};
}