nok-codegen 0.0.1

Concrete Error type built around a pseudo stack trace
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

use prettyplease::unparse;
use quote::quote;
use syn::parse2;

#[test]
fn test_generate_macros() {
    let actual = crate::generate_macros::generate_macros(
        quote! { payload_type: Payload, export_globally: true },
    );
    let expected = quote! {
        #[macro_export]
        macro_rules! error {
            () => {
                nok::error_t!($crate::Payload)
            };
            ($($arg:tt)*) => {
                nok::error_t!($crate::Payload, $($arg)*)
            };
        }
        #[macro_export]
        macro_rules! err {
            () => {
                nok::err_t!($crate::Payload)
            };
            ($($arg:tt)*) => {
                nok::err_t!($crate::Payload, $($arg)*)
            };
        }
        #[macro_export]
        macro_rules! to_err_msg {
            () => {
                nok::to_err_msg_t!($crate::Payload)
            };
            ($payload:expr) => {
                nok::to_err_msg_t!($crate::Payload, $payload)
            };
        }
        #[macro_export]
        macro_rules! to_err_msg_dbg {
            () => {
                nok::to_err_msg_dbg_t!($crate::Payload)
            };
            ($payload:expr) => {
                nok::to_err_msg_dbg_t!($crate::Payload, $payload)
            };
        }
        #[macro_export]
        macro_rules! map_err {
            ($err:expr) => {
                nok::map_err_t!($crate::Payload, $err)
            };
            ($err:expr, $payload:expr) => {
                nok::map_err_t!($crate::Payload, $err, $payload)
            };
        }
        #[macro_export]
        macro_rules! map_err_dbg {
            ($err:expr) => {
                nok::map_err_dbg_t!($crate::Payload, $err)
            };
            ($err:expr, $payload:expr) => {
                nok::map_err_dbg_t!($crate::Payload, $err, $payload)
            };
        }
        #[macro_export]
        macro_rules! replace {
            () => {
                nok::replace_t!($crate::Payload)
            };
            ($($arg:tt)*) => {
                nok::replace_t!($crate::Payload, $($arg)*)
            };
        }
        #[macro_export]
        macro_rules! replace_err {
            ($err:expr) => {
                nok::replace_err_t!($crate::Payload, $err)
            };
            ($err:expr, $($arg:tt)*) => {
                nok::replace_err_t!($crate::Payload, $err, $($arg)*)
            };
        }
        #[macro_export]
        macro_rules! verify {
            ($statement:expr) => {
                nok::verify_t!($crate::Payload, $statement)
            };
            ($statement:expr, $($arg:tt)*) => {
                nok::verify_t!($crate::Payload, $statement, $($arg)*)
            };
        }
        #[macro_export]
        macro_rules! ok_or {
            ($opt:expr) => {
                nok::ok_or_t!($crate::Payload, $opt)
            };
            ($opt:expr, $($arg:tt)*) => {
                nok::ok_or_t!($crate::Payload, $opt, $($arg)*)
            };
        }
    };

    let actual = unparse(&parse2(actual).unwrap());
    let expected = unparse(&parse2(expected).unwrap());
    assert_eq!(actual, expected);
}