[go: up one dir, main page]

speculate 0.1.1

An RSpec inspired minimal testing framework for Rust.
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

use proc_macro2::{Ident, TokenStream};

use block::{Bench, Block, Describe, It};
use quote::ToTokens;
use syn;

pub trait Generate {
    fn generate(self, up: Option<&Describe>) -> TokenStream;
}

impl Generate for Block {
    fn generate(self, up: Option<&Describe>) -> TokenStream {
        match self {
            Block::Describe(describe) => describe.generate(up),
            Block::It(it) => it.generate(up),
            Block::Bench(bench) => bench.generate(up),
            Block::Item(item) => item.into_token_stream(),
        }
    }
}

impl Generate for Describe {
    fn generate(mut self, up: Option<&Describe>) -> TokenStream {
        if let Some(ref up) = up {
            self.before = up
                .before
                .iter()
                .chain(self.before.iter())
                .cloned()
                .collect();
            self.after = self.after.iter().chain(up.after.iter()).cloned().collect();
        }

        let items = self
            .blocks
            .iter()
            .map(|block| block.clone().generate(Some(&self)))
            .collect::<Vec<_>>();

        let name = &self.name;

        quote_spanned!(name.span() =>
            mod #name {
                #[allow(unused_imports)]
                use super::*;

                #(#items)*
            }
        )
    }
}

impl Generate for It {
    fn generate(self, up: Option<&Describe>) -> TokenStream {
        let blocks = if let Some(ref up) = up {
            up.before
                .iter()
                .chain(Some(self.block).iter())
                .chain(up.after.iter())
                .cloned()
                .collect()
        } else {
            vec![self.block]
        };

        let stmts = flatten_blocks(blocks);

        let name = Ident::new(&format!("test_{}", self.name), self.name.span());
        let attributes = self.attributes;

        quote_spanned!(name.span() =>
            #[test]
            #(#attributes)*
            fn #name() {
                #(#stmts)*
            }
        )
    }
}

impl Generate for Bench {
    fn generate(self, up: Option<&Describe>) -> TokenStream {
        let blocks = if let Some(ref up) = up {
            up.before
                .iter()
                .chain(Some(self.block).iter())
                .chain(up.after.iter())
                .cloned()
                .collect()
        } else {
            vec![self.block]
        };

        let stmts = flatten_blocks(blocks);

        let name = Ident::new(&format!("bench_{}", self.name), self.name.span());
        let ident = self.ident;

        quote_spanned!(name.span() =>
            #[bench]
            fn #name(#ident: &mut ::test::Bencher) {
                #(#stmts)*
            }
        )
    }
}

fn flatten_blocks(blocks: Vec<syn::Block>) -> impl Iterator<Item = syn::Stmt> {
    blocks.into_iter().flat_map(|block| block.stmts)
}