traced-test 1.0.4

this crate lets us use #[traced_test] to automatically configure sane default tracing for a rust test
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

// ---------------- [ File: src/errors.rs ]
crate::ix!();

error_tree!{

    pub enum BuilderError {
        MissingOriginalBlock,
        MissingShouldFailAttr,
    }

    pub enum UnknownAttributeError {
        UnknownAttribute {
            attr: syn::Attribute,
        }
    }

    pub enum ShouldFailAttrError {
        // The attribute is not `should_fail`.
        NotShouldFailAttr,

        // The `message` or `trace` key is missing.
        ExpectedValueMissing,

        // The value provided for `message` or `trace` is of incorrect type.
        InvalidExpectedValueFormat,

        // Failed to parse the attribute arguments.
        MetaParseError(syn::Error),

        // Multiple `should_fail` attributes found.
        MultipleShouldFailAttrs,

        // Encountered an unknown attribute key.
        UnknownAttribute,
    }

    pub enum ShouldPanicAttrError {
        // The attribute is not `should_panic`.
        NotShouldPanicAttr,

        // The `expected` key is missing or the value is missing.
        ExpectedValueMissing,

        // The value provided for `expected` is not a string literal.
        InvalidExpectedValueFormat,

        // Failed to parse the attribute arguments.
        MetaParseError(syn::Error),

        // Multiple `should_panic` attributes found.
        MultipleShouldPanicAttrs,
    }

    pub enum TracedTestError {
        BuilderError(BuilderError),
        ShouldFailAttrError(ShouldFailAttrError),
        ShouldPanicAttrNotSupportedWithTracedTest,
        ShouldPanicAttrAccessError,
        TokenStream(TokenStream),
        LexError(proc_macro2::LexError),
        UnknownAttribute(UnknownAttributeError),
        Message(String),
        MissingOriginalBlock,
        MultipleShouldFailAttrs,
    }
}

impl PartialEq for ShouldPanicAttrError {

    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (ShouldPanicAttrError::NotShouldPanicAttr,         ShouldPanicAttrError::NotShouldPanicAttr)         => true,
            (ShouldPanicAttrError::ExpectedValueMissing,       ShouldPanicAttrError::ExpectedValueMissing)       => true,
            (ShouldPanicAttrError::InvalidExpectedValueFormat, ShouldPanicAttrError::InvalidExpectedValueFormat) => true,
            (ShouldPanicAttrError::MultipleShouldPanicAttrs,   ShouldPanicAttrError::MultipleShouldPanicAttrs)   => true,

            // Ignoring the actual contents of `MetaParseError`
            (ShouldPanicAttrError::MetaParseError(_),          ShouldPanicAttrError::MetaParseError(_))          => true,
            _ => false,
        }
    }
}

impl Eq for ShouldPanicAttrError {}

impl PartialEq for ShouldFailAttrError {

    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (ShouldFailAttrError::NotShouldFailAttr,         ShouldFailAttrError::NotShouldFailAttr)         => true,
            (ShouldFailAttrError::ExpectedValueMissing,       ShouldFailAttrError::ExpectedValueMissing)       => true,
            (ShouldFailAttrError::InvalidExpectedValueFormat, ShouldFailAttrError::InvalidExpectedValueFormat) => true,
            (ShouldFailAttrError::MultipleShouldFailAttrs,   ShouldFailAttrError::MultipleShouldFailAttrs)   => true,

            // Ignoring the actual contents of `MetaParseError`
            (ShouldFailAttrError::MetaParseError(_),          ShouldFailAttrError::MetaParseError(_))          => true,
            _ => false,
        }
    }
}

impl Eq for ShouldFailAttrError {}