should_error 0.1.1

The test should fail with Err.
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

# `should_error`

> **NOTE**: This crate is deprecated in favor of [`should_match`](https://crates.io/crates/should_match).

Pass a test if an error is returned.

## Setup

This crate is primarily intended for use in tests, so add it to your `dev-dependencies` instead of `dependencies`:

```shell
cargo add --dev should_error
```

Recommended to work with [`macro_rules_attr`](https://crates.io/crates/macro_rules_attr):

```shell
cargo add --dev macro_rules_attr should_error
```

## Usage

### With `macro_rules_attr`

Simply `apply` the `should_error` macro (the order does not matter):

```rust
use macro_rules_attr::apply;
use should_error::should_error;

// This test will pass
#[apply(should_error)]
#[test]
fn test_apply_first() -> Result<(), &'static str> {
    Err("error")
}

// This test will also pass
#[test]
#[apply(should_error)]
fn test_apply_second() -> Result<(), &'static str> {
    Err("error")
}
```

To further specify the pattern that's expected to match, use the `expected` argument:

```rust
# use macro_rules_attr::apply;
# use should_error::should_error;
#
#[test]
#[apply(should_error, expected = Err("error"))]
fn test_with_error_expected() -> Result<(), &'static str> {
    Err("error")
}
```

You can also match anything else other than an `Err`:

```rust
# use macro_rules_attr::apply;
# use should_error::should_error;
#
#[allow(dead_code, reason = "Only used in tests")]
enum MyEnum {
    One,
    Two,
}

#[test]
#[apply(should_error, expected = MyEnum::One)]
fn test_with_arbitrary_expected() -> MyEnum {
    MyEnum::One
}
```

### Directly

Wrap your tests with `should_error!` (note that the `#[test]` attribute must be wrapped inside the macro):

```rust
use should_error::should_error;

// This test will pass
should_error! {
    #[test]
    fn test() -> Result<(), &'static str> {
        Err("error")
    }
}

// This is not a valid test: the `#[test]` attribute may only be used on a non-associated function
#[test]
should_error! {
    fn test() -> Result<(), &'static str> {
        Ok(())
    }
}
```

To further specify the pattern that's expected to match, use the `expected` argument:

```rust
# use should_error::should_error;
#
should_error! {
    #[test]
    fn test_with_error_expected() -> Result<(), &'static str> {
        Err("error")
    }, expected = Err("error")
}
```

You can also match anything else other than an `Err`:

```rust
# use should_error::should_error;
#
# #[allow(dead_code, reason = "Only used in tests")]
enum MyEnum {
    One,
    Two,
}

should_error! {
    #[test]
    fn test_with_arbitrary_expected() -> MyEnum {
        MyEnum::One
    }, expected = MyEnum::One
}
```