enforce 0.0.1 

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

#![feature(phase)]
#![deny(warnings)]
#![allow(non_snake_case)]
#[phase(plugin)] extern crate stainless;
#[phase(plugin, link)] extern crate enforce;

describe! error_types {
    describe! option {
        describe! some {
            it "should check if something is Some" {
                (enforce!(Some(7u))).some();
            }

            failing "should fail is something is None" {
                (enforce!(None::<uint>)).some();
            }

            it "should support negation" {
                (enforce!(None::<()>)).not().some()
            }
        }

        describe! none {
            it "should check if something is None" {
                (enforce!(None::<()>)).none();
            }

            failing "should fail is something is Some" {
                (enforce!(Some(7u))).none();
            }

            it "should support negation" {
                (enforce!(Some(7u))).not().none()
            }
        }
    }

    describe! result {
        describe! ok {
            it "should check if something is Ok" {
                (enforce!(Ok::<uint, ()>(7u))).ok();
            }

            failing "should fail is something is Err" {
                (enforce!(Err::<(), uint>(7u))).ok();
            }

            it "should support negation" {
                (enforce!(Err::<(), ()>(()))).not().ok()
            }
        }

        describe! err {
            it "should check if something is Err" {
                (enforce!(Err::<(), uint>(7u))).err();
            }

            failing "should fail is something is Ok" {
                (enforce!(Ok::<uint, ()>(7u))).err();
            }

            it "should support negation" {
                (enforce!(Ok::<(), ()>(()))).not().err()
            }
        }
    }
}