speculate 0.1.2

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

extern crate speculate as other_speculate;
use other_speculate::speculate;

pub fn zero() -> u32 {
    0
}

speculate! {
    before {
        let mut i = zero();
    }

    before {
        i += 1;
    }

    after {
        i += 1;
    }

    after {
        assert_eq!(i, 6);
    }

    it "works at level 1!" {
        assert_eq!(i, zero() + 1);
        i = 5;
    }

    describe "something" {
        before {
            assert_eq!(i, zero() + 1);
            i = 1;
        }

        it "works at level 2!" {
            assert_eq!(i, 1);
            i = 4;
        }

        after {
            assert_eq!(i, 4);
            i = 5;
        }

        context "nested" {
            before {
                assert_eq!(i, 1);
                i = 2;
            }

            test "works at level 3!" {
                assert_eq!(i, 2);
                i = 3;
            }

            after {
                assert_eq!(i, 3);
                i = 4;
            }
        }

        it "works at level 2 after context!" {
            assert_eq!(i, 1);
            i = 4;
        }
    }

    it "works at level 1 after describe!" {
        assert_eq!(i, zero() + 1);
        i = 5;
    }
}

// Parsing edge cases
mod ec1 {
    use other_speculate::speculate;

    speculate! {}
}

mod ec2 {
    use other_speculate::speculate;

    speculate! {
        before {}
        it "works" {}
    }

    speculate! {
        // Many modules in a same scope!
        it "works again" {}
    }
}

mod ec3 {
    use other_speculate::speculate;

    speculate! {
        it "foo" {}
    }
}

mod ec4 {
    use other_speculate::speculate;

    speculate! {
        after {}
    }
}

mod ec5 {
    use other_speculate::speculate;

    speculate! {
        before {}
        it "foo" {}
        after {}
    }
}

mod attributes {
    use other_speculate::speculate;

    speculate! {
        #[ignore]
        test "ignore" {
            assert_eq!(1, 2);
        }

        #[should_panic]
        test "should panic" {
            assert_eq!(1, 2);
        }

        #[should_panic(expected = "foo")]
        test "should panic with foo" {
            panic!("foo");
        }
    }
}