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

use crate::ux::{Element, Elements, Value};

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Outcome {
    Passed,
    Failed(Element),
}

/// A generic expressible property
pub trait Property {
    /// Get the result of this property
    fn result(&self) -> Outcome;

    /// Simple logical And combinator, this property and the next one must pass to pass
    fn and<O>(self, other: O) -> And<Self, O>
    where
        Self: Sized,
    {
        And {
            prop_a: self,
            prop_b: other,
        }
    }

    /*
    fn and_then<F>(self, other: F) -> AndThen<Self, F>
    where
        Self: Sized,
        F: Fn() -> BoxProperty,
    {
        AndThen {
            prop_a: self,
            prop_b: other,
        }
    }
    */

    /// Simple logical Or combinator, this property or the next one must pass to pass
    fn or<O>(self, other: O) -> Or<Self, O>
    where
        Self: Sized,
    {
        Or {
            prop_a: self,
            prop_b: other,
        }
    }
}

/// A Generic Boxed Property
pub struct BoxProperty(Box<dyn Property>);

impl Property for BoxProperty {
    fn result(&self) -> Outcome {
        self.0.result()
    }
}

/// Logical And between properties
pub struct And<A, B> {
    prop_a: A,
    prop_b: B,
}

impl<A, B> Property for And<A, B>
where
    A: Property,
    B: Property,
{
    fn result(&self) -> Outcome {
        fn failure_element(left: Value, right: Value) -> Outcome {
            let mut output = Elements::new();
            output.append("left", left);
            output.append("right", right);
            Outcome::Failed(Element::new("and", output.into()))
        }
        match (self.prop_a.result(), self.prop_b.result()) {
            (Outcome::Passed, Outcome::Passed) => Outcome::Passed,
            (Outcome::Failed(f1), Outcome::Passed) => {
                failure_element(Value::sub(f1), "passed".into())
            }
            (Outcome::Passed, Outcome::Failed(f2)) => {
                failure_element("passed".into(), Value::sub(f2))
            }
            (Outcome::Failed(f1), Outcome::Failed(f2)) => {
                failure_element(Value::sub(f1), Value::sub(f2))
            }
        }
    }
}

/*
pub struct AndThen<A, B> {
    prop_a: A,
    prop_b: B,
}

impl<A, B> Property for AndThen<A, B> {}
*/

/// Logical Or between properties
pub struct Or<A, B> {
    prop_a: A,
    prop_b: B,
}

impl<A, B> Property for Or<A, B>
where
    A: Property,
    B: Property,
{
    fn result(&self) -> Outcome {
        match (self.prop_a.result(), self.prop_b.result()) {
            (Outcome::Passed, _) => Outcome::Passed,
            (_, Outcome::Passed) => Outcome::Passed,
            (Outcome::Failed(f1), Outcome::Failed(f2)) => {
                let mut output = Elements::new();
                output.append("left", Value::sub(f1));
                output.append("right", Value::sub(f2));
                Outcome::Failed(Element::new("or", output.into()))
            }
        }
    }
}