flipperzero-test-macros 0.16.0

Procedural macros for flipperzero-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
103
104
105
106
107
108
109
110
111
112
113

use quote::quote;
use syn::{Block, Expr, ExprMacro, ExprTuple, Stmt, parse};

/// Find and replace macro assertions inside the given block with `return Err(..)`.
///
/// The following assertion macros are replaced:
/// - [`assert`]
/// - [`assert_eq`]
/// - [`assert_ne`]
pub(crate) fn box_block(mut block: Box<Block>) -> parse::Result<Box<Block>> {
    block.stmts = block_stmts(block.stmts)?;
    Ok(block)
}

/// Searches recursively through block statements to find and replace macro assertions
/// with `return Err(..)`.
///
/// The following assertion macros are replaced:
/// - [`assert`]
/// - [`assert_eq`]
/// - [`assert_ne`]
fn block_stmts(stmts: Vec<Stmt>) -> parse::Result<Vec<Stmt>> {
    stmts
        .into_iter()
        .map(|stmt| match stmt {
            Stmt::Expr(Expr::Block(mut e)) => {
                e.block.stmts = block_stmts(e.block.stmts)?;
                Ok(Stmt::Expr(Expr::Block(e)))
            }
            Stmt::Expr(Expr::Macro(m)) => expr_macro(m).map(Stmt::Expr),
            Stmt::Semi(Expr::Macro(m), trailing) => expr_macro(m).map(|m| Stmt::Semi(m, trailing)),
            _ => Ok(stmt),
        })
        .collect::<Result<_, _>>()
}

/// Replaces macro assertions with `return Err(..)`.
///
/// The following assertion macros are replaced:
/// - [`assert`]
/// - [`assert_eq`]
/// - [`assert_ne`]
fn expr_macro(m: ExprMacro) -> parse::Result<Expr> {
    if m.mac.path.is_ident("assert") {
        let tokens = m.mac.tokens;
        let tokens_str = tokens.to_string();
        syn::parse(
            quote!(
                if !(#tokens) {
                    return ::core::result::Result::Err(
                        ::core::concat!("assertion failed: ", #tokens_str).into(),
                    );
                }
            )
            .into(),
        )
    } else if m.mac.path.is_ident("assert_eq") {
        let (left, right, msg) = binary_macro(m.mac.tokens)?;
        let left_str = quote!(#left).to_string();
        let right_str = quote!(#right).to_string();
        let msg_str = if let Some(msg) = msg {
            quote!(Some(#msg))
        } else {
            quote!(None)
        };
        syn::parse(
            quote!(
                if #left != #right {
                    return ::core::result::Result::Err(
                        ::flipperzero_test::TestFailure::AssertEq {
                            left: #left_str,
                            right: #right_str,
                            msg: #msg_str,
                        }
                    );
                }
            )
            .into(),
        )
    } else if m.mac.path.is_ident("assert_ne") {
        let (left, right, msg) = binary_macro(m.mac.tokens)?;
        let left_str = quote!(#left).to_string();
        let right_str = quote!(#right).to_string();
        let msg_str = if let Some(msg) = msg {
            quote!(Some(#msg))
        } else {
            quote!(None)
        };
        syn::parse(
            quote!(
                if #left == #right {
                    return ::core::result::Result::Err(
                        ::flipperzero_test::TestFailure::AssertNe {
                            left: #left_str,
                            right: #right_str,
                            msg: #msg_str,
                        }
                    );
                }
            )
            .into(),
        )
    } else {
        Ok(Expr::Macro(m))
    }
}

fn binary_macro(tokens: proc_macro2::TokenStream) -> parse::Result<(Expr, Expr, Option<Expr>)> {
    let parts: ExprTuple = syn::parse(quote!((#tokens)).into())?;
    assert!(parts.elems.len() >= 2);
    let mut elems = parts.elems.into_iter();
    Ok((elems.next().unwrap(), elems.next().unwrap(), elems.next()))
}