oxidize 0.2.1

Awesome matchers/asserts
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

use std::fmt::Debug;
use std::intrinsics::type_name;
use super::Matcher;

pub struct Nothing;
pub struct Something;

impl<T: Debug> Matcher<Option<T>> for Nothing {
    fn matches(&self, lhs: &Option<T>) -> bool {
        lhs.is_none()
    }

    fn fail_msg(&self, lhs: &Option<T>) -> String {
        format!("expected {:?} to be None", lhs)
    }

    fn negated_fail_msg(&self, lhs: &Option<T>) -> String {
        format!("expected {:?} to be Some<{}>", lhs, unsafe { type_name::<T>() })
    }
}

impl<T: Debug> Matcher<Option<T>> for Something {
    fn matches(&self, lhs: &Option<T>) -> bool {
        lhs.is_some()
    }

    fn fail_msg(&self, lhs: &Option<T>) -> String {
        format!("expected {:?} to be Some<{}>", lhs, unsafe { type_name::<T>() })
    }

    fn negated_fail_msg(&self, lhs: &Option<T>) -> String {
        format!("expected {:?} to be None", lhs)
    }
}

#[cfg(test)]
mod test {
    use super::super::super::dsl::*;

    #[test]
    fn test_none_matches() {
        let n: Option<String> = None;
        expect(n).is(none());
    }

    #[test]
    #[should_panic(expected="expected Some(\"Hello\") to be None")]
    fn test_none_fails_with_message() {
        let n = Some("Hello");
        expect(n).is(none());
    }

    #[test]
    #[should_panic(expected="expected None to be Some<i32>")]
    fn test_negated_none_fails_with_message() {
        let n: Option<i32> = None;
        expect(n).is_not(none());
    }

    #[test]
    fn test_some_matches() {
        let n = Some(32);
        expect(n).is(some());
    }

    #[test]
    #[should_panic(expected="expected None to be Some<i32>")]
    fn test_some_fails_with_message() {
        let n: Option<i32> = None;
        expect(n).is(some());
    }

    #[test]
    #[should_panic(expected="expected Some(32) to be None")]
    fn test_negated_some_fails_with_message() {
        let n = Some(32);
        expect(n).is_not(some());
    }
}