s_test_fixture 0.1.2

s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle
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

# s_test_fixture

s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle.


# Usage
Their is four macros: `before`, `after`, `before_each`, `after_each`. The function pass as argument must return nothing.

`before` and `after` are simply added before the test function

```rust
#[cfg(test)]
mod tests {
    use s_fixture::before;
    #[test]
    #[before(function_to_run(2))]
    fn test() {
        let a = 2;
        something();
        assert_eq!(a,2);
        println!("ending");

    }
    
    fn something(){}

    fn function_to_run(i:i32){
        println!("I did {} thing(s)",i);
    }
}
```
will return 

```
I did 2 thing(s)
ending
```
```rust
#[cfg(test)]
mod tests {
    use s_fixture::after;
    #[test]
    #[after(function_to_run(66))]
    fn test() -> Result<(), ()> {
        println!("before");
        let i = -55;
        something();
        if i == 0 {
            something();
            Ok(())
        } else if i == 2 {
            something();
            return Ok(());
        } else {
            panic!("oh no!")
            Ok(())
        }
    }
    
    fn something(){}

    fn function_to_run(i:i32){
        println!("I did {} thing(s)",i);
    }
}

```
will return
```
before
{panic statement}
I did 66 thing(s)
```

`before_each` and `after_each` behave in a similar matter and stack with `before` and `after` macro. It has to be noted that the scope of the 
function pass as argument matter. It has to consider the scope of the test module.

```rust
use s_fixture::{before_each,after, before};

#[cfg(test)]
#[before_each(function_to_run(78))]
mod tests {
    use super::*;
    #[test]
    #[before(function_to_run(2))]
    fn test() {
        let a = 2;
        something();
        assert_eq!(a,2);
        println!("ending");

    }
    
    fn something(){}

    fn function_to_run(i:i32){
        println!("I did {} thing(s)",i);
    }
}
```
will return
```
I did 2 thing(s)
I did 78 thing(s)
ending
```
The macros are pretty easy to use but examples can be found in the test folder of the source code.

# Test

run 
`cargo test -- --test-threads 1`