xpct 0.5.1

An extensible test assertion library
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

use float_cmp::approx_eq;

use crate::core::Match;
use crate::matchers::Mismatch;

/// The matcher for [`approx_eq_f32`] and [`approx_eq_f64`].
///
/// [`approx_eq_f32`]: crate::approx_eq_f32
/// [`approx_eq_f64`]: crate::approx_eq_f64
#[derive(Debug)]
pub struct ApproxEqFloatMatcher<Float, Ulps> {
    expected: Float,
    ulps: Ulps,
}

impl ApproxEqFloatMatcher<f32, i32> {
    /// Create a new [`ApproxEqFloatMatcher`] from the expected value and number of ULPs.
    pub fn new(expected: f32, ulps: i32) -> Self {
        Self { expected, ulps }
    }
}

impl ApproxEqFloatMatcher<f64, i64> {
    /// Create a new [`ApproxEqFloatMatcher`] from the expected value and number of ULPs.
    pub fn new(expected: f64, ulps: i64) -> Self {
        Self { expected, ulps }
    }
}

impl Match<f32> for ApproxEqFloatMatcher<f32, i32> {
    type Fail = Mismatch<f32, f32>;

    fn matches(&mut self, actual: &f32) -> crate::Result<bool> {
        Ok(approx_eq!(f32, *actual, self.expected, ulps = self.ulps))
    }

    fn fail(self, actual: f32) -> Self::Fail {
        Mismatch {
            expected: self.expected,
            actual,
        }
    }
}

impl Match<f64> for ApproxEqFloatMatcher<f64, i64> {
    type Fail = Mismatch<f64, f64>;

    fn matches(&mut self, actual: &f64) -> crate::Result<bool> {
        Ok(approx_eq!(f64, *actual, self.expected, ulps = self.ulps))
    }

    fn fail(self, actual: f64) -> Self::Fail {
        Mismatch {
            expected: self.expected,
            actual,
        }
    }
}