more-asserts 0.3.1

Small library providing additional assert_* and debug_assert_* macros.
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

use more_asserts as ma;
use std::panic::catch_unwind;

#[derive(PartialOrd, PartialEq, Debug)]
enum DummyType {
    Foo,
    Bar,
    Baz,
}

#[test]
fn test_assert_lt() {
    ma::assert_lt!(3, 4);
    ma::assert_lt!(4.0, 4.5);
    ma::assert_lt!("a string", "b string");
    ma::assert_lt!(
        DummyType::Foo,
        DummyType::Bar,
        "Message with {}",
        "cool formatting"
    );

    let a = &DummyType::Foo;
    let b = &DummyType::Baz;
    ma::assert_lt!(a, b);

    assert!(catch_unwind(|| ma::assert_lt!(5, 3)).is_err());
    assert!(catch_unwind(|| ma::assert_lt!(5, 5)).is_err());
    assert!(catch_unwind(|| ma::assert_lt!(DummyType::Bar, DummyType::Foo)).is_err());
}

#[test]
fn test_assert_gt() {
    ma::assert_gt!(4, 3);
    ma::assert_gt!(4.5, 4.0);
    ma::assert_gt!("b string", "a string");
    ma::assert_gt!(
        DummyType::Bar,
        DummyType::Foo,
        "Message with {}",
        "cool formatting"
    );

    let a = &DummyType::Foo;
    let b = &DummyType::Baz;
    ma::assert_gt!(b, a);

    assert!(catch_unwind(|| ma::assert_gt!(3, 5)).is_err());
    assert!(catch_unwind(|| ma::assert_gt!(5, 5)).is_err());
    assert!(catch_unwind(|| ma::assert_gt!(DummyType::Foo, DummyType::Bar)).is_err());
}

#[test]
fn test_assert_le() {
    ma::assert_le!(3, 4);
    ma::assert_le!(4, 4);
    ma::assert_le!(4.0, 4.5);
    ma::assert_le!("a string", "a string");
    ma::assert_le!("a string", "b string");
    ma::assert_le!(DummyType::Foo, DummyType::Bar, "Message");
    ma::assert_le!(
        DummyType::Foo,
        DummyType::Foo,
        "Message with {}",
        "cool formatting"
    );

    let a = &DummyType::Foo;
    let b = &DummyType::Baz;
    ma::assert_le!(a, a);
    ma::assert_le!(a, b);

    assert!(catch_unwind(|| ma::assert_le!(5, 3)).is_err());
    assert!(catch_unwind(|| ma::assert_le!(DummyType::Bar, DummyType::Foo)).is_err());
}

#[test]
fn test_assert_ge() {
    ma::assert_ge!(4, 3);
    ma::assert_ge!(4, 4);
    ma::assert_ge!(4.5, 4.0);
    ma::assert_ge!(5.0, 5.0);
    ma::assert_ge!("a string", "a string");
    ma::assert_ge!("b string", "a string");
    ma::assert_ge!(DummyType::Bar, DummyType::Bar, "Example");
    ma::assert_ge!(
        DummyType::Bar,
        DummyType::Foo,
        "Message with {}",
        "cool formatting",
    );

    let a = &DummyType::Foo;
    let b = &DummyType::Baz;
    ma::assert_ge!(a, a);
    ma::assert_ge!(b, a);

    assert!(catch_unwind(|| ma::assert_ge!(3, 5)).is_err());
    assert!(catch_unwind(|| ma::assert_ge!(DummyType::Foo, DummyType::Bar)).is_err());
}