smoke 0.4.0

A framework for testing
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

use super::api::{Outcome, Property};
use crate::ux::{Element, Elements};
use std::cmp::Ordering;

struct NamedOp<T> {
    name: &'static str,
    op: fn(T) -> bool,
}

const EQ_OP: NamedOp<bool> = NamedOp {
    name: "==",
    op: |b| b,
};
const NE_OP: NamedOp<bool> = NamedOp {
    name: "!=",
    op: |b| !b,
};
const GT_OP: NamedOp<Ordering> = NamedOp {
    name: ">",
    op: |o| o == Ordering::Greater,
};
const GE_OP: NamedOp<Ordering> = NamedOp {
    name: ">=",
    op: |o| o == Ordering::Greater || o == Ordering::Equal,
};
const LT_OP: NamedOp<Ordering> = NamedOp {
    name: "<",
    op: |o| o == Ordering::Less,
};
const LE_OP: NamedOp<Ordering> = NamedOp {
    name: "<=",
    op: |o| o == Ordering::Less || o == Ordering::Equal,
};

/// Relation between 2 values based on the Eq trait
pub struct RelationEq<T> {
    left: T,
    right: T,
    op: &'static NamedOp<bool>,
}

impl<T: Eq + std::fmt::Debug> Property for RelationEq<T> {
    fn result(&self) -> Outcome {
        if (self.op.op)(self.left == self.right) {
            Outcome::Passed
        } else {
            let mut output = Elements::new();
            let l_value = format!("{:?}", self.left);
            let r_value = format!("{:?}", self.right);
            output.append("left", l_value.into());
            output.append("right", r_value.into());
            Outcome::Failed(Element::new(self.op.name, output.into()))
        }
    }
}

/// Relation between 2 values based on the Ord trait
pub struct RelationOrd<T> {
    left: T,
    right: T,
    op: &'static NamedOp<Ordering>,
}

impl<T: Ord + std::fmt::Debug> Property for RelationOrd<T> {
    fn result(&self) -> Outcome {
        if (self.op.op)(self.left.cmp(&self.right)) {
            Outcome::Passed
        } else {
            let mut output = Elements::new();
            let l_value = format!("{:?}", self.left);
            let r_value = format!("{:?}", self.right);
            output.append("left", l_value.into());
            output.append("right", r_value.into());
            Outcome::Failed(Element::new(self.op.name, output.into()))
        }
    }
}

/// Check that 2 elements are equal
pub fn equal<T: Eq>(left: T, right: T) -> RelationEq<T> {
    RelationEq {
        left,
        right,
        op: &EQ_OP,
    }
}

/// Check that 2 elements are not equal
pub fn not_equal<T: Eq>(left: T, right: T) -> RelationEq<T> {
    RelationEq {
        left,
        right,
        op: &NE_OP,
    }
}

/// Check that the left element is greater than the right element
pub fn greater<T: Ord>(left: T, right: T) -> RelationOrd<T> {
    RelationOrd {
        left,
        right,
        op: &GT_OP,
    }
}

/// Check that the left element is greater or equal than the right element
pub fn greater_equal<T: Ord>(left: T, right: T) -> RelationOrd<T> {
    RelationOrd {
        left,
        right,
        op: &GE_OP,
    }
}

/// Check that the left element is less than the right element
pub fn less<T: Ord>(left: T, right: T) -> RelationOrd<T> {
    RelationOrd {
        left,
        right,
        op: &LT_OP,
    }
}

/// Check that the left element is less or equal than the right element
pub fn less_equal<T: Ord>(left: T, right: T) -> RelationOrd<T> {
    RelationOrd {
        left,
        right,
        op: &LE_OP,
    }
}