test-case-derive 0.2.3

Provides #[test_case(...)] procedural macro attribute for generating parametrized test cases easily
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

use prelude::*;

pub fn gen_test_case(test_fn_name: Token, token_tree: &Vec<TokenTree>) -> Tokens {
    let (name, leftover)       = given_test_case_name(token_tree);
    let (expected, leftover)   = expected_result(leftover);
    let args                   = leftover;
    let maybe_ignore_attribute = ignore_attribute(name.as_ref());
    let name                   = name.unwrap_or_else(|| generated_test_case_name(args));
    let body                   = test_case_body(test_fn_name, args, expected);

    quote! {
        #[test]
        #maybe_ignore_attribute
        fn #name() {
            #body
        }
    }
}

fn given_test_case_name(token_tree: &[TokenTree]) -> (Option<Token>, &[TokenTree]) {
    let mut iter     = token_tree.into_iter().rev();
    let last         = iter.next();
    let last_but_one = iter.next();

    match (last, last_but_one) {
        (
            Some(&TTToken(TLiteral(Str(ref case_name, _)))),
            Some(&TTToken(TModSep))
        ) =>
            (
                Some(escape_ident(case_name)),
                &token_tree[0..token_tree.len() - 2]
            ),
        _ => (None, token_tree)
    }
}

fn generated_test_case_name(args: &[TokenTree]) -> Token {
    escape_ident(args.to_string())
}

fn test_case_body(test_fn_name: Token, args: &[TokenTree], expected: &[TokenTree]) -> Tokens {
    match expected.len() {
        0 => quote! {
            #test_fn_name(#(#args)*);
        },
        _ => quote! {
            let expected = #(#expected)*;
            let actual   = #test_fn_name(#(#args)*);

            assert_eq!(expected, actual);
        }
    }
}

fn expected_result(token_tree: &[TokenTree]) -> (&[TokenTree], &[TokenTree]) {
    for i in (0..token_tree.len()).rev() {
        if &TTToken(TFatArrow) == &token_tree[i] {
            return (
                &token_tree[i+1..token_tree.len()],
                &token_tree[0..i]
            )
        }
    }

    (&[], token_tree)
}

fn ignore_attribute(given_name: Option<&Token>) -> Tokens {
    if let Some(name) = given_name {
        if quote!(#name).to_string().contains("inconclusive") {
            return quote! { #[ignore] }
        }
    }

    quote! {}
}