rerec 0.0.7

Readings and records from sensory instruments as used by Herodot and Percepter
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

use serde::{Deserialize, Serialize};
use std::fmt;
use std::fmt::{Display, Formatter};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
pub struct DS18B20 {
    device_name: String,
    raw_reading: i32,
}

impl DS18B20 {
    pub fn new(device_name: String, raw_reading: i32) -> Self {
        Self {
            device_name,
            raw_reading,
        }
    }

    pub fn device_name(&self) -> &str {
        &self.device_name
    }

    pub fn raw_reading(&self) -> i32 {
        self.raw_reading
    }

    pub fn temperature(&self) -> f32 {
        self.raw_reading as f32 / 1000.0
    }
}

impl Display for DS18B20 {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let name = self.device_name();
        let temperature = self.temperature();
        write!(f, "{}: {} °C", name, temperature)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_reading() {
        let _reading = DS18B20 {
            device_name: "28-000000000000".into(),
            raw_reading: 22625,
        };
    }

    #[test]
    fn test_new() {
        let _reading = DS18B20::new("28-000000000000".into(), 22625);
    }

    #[test]
    fn test_debug() {
        let reading = DS18B20::new("28-000000000000".into(), 22625);
        let debug_output = format!("{:?}", reading);
        assert!(debug_output.contains("DS18B20"));
        assert!(debug_output.contains("28-000000000000"));
        assert!(debug_output.contains("22625"));
    }

    #[test]
    fn test_partial_eq() {
        let reading1 = DS18B20::new("28-000000000000".into(), 22625);
        let reading1_again = DS18B20::new("28-000000000000".into(), 22625);
        let reading2 = DS18B20::new("28-000000000000".into(), 23000);

        assert_eq!(reading1, reading1_again);
        assert_ne!(reading1, reading2);
    }

    #[test]
    fn test_get_temperature() {
        let reading = DS18B20::new("28-000000000000".into(), 22625);
        assert_eq!(reading.temperature(), 22.625);

        let reading = DS18B20::new("28-000000000000".into(), -22625);
        assert_eq!(reading.temperature(), -22.625);
    }

    #[test]
    fn test_get_device_name() {
        let reading = DS18B20::new("28-000000000000".into(), 22625);
        let actual = reading.device_name();
        assert_eq!(actual, "28-000000000000");
    }

    #[test]
    fn test_display() {
        let reading = DS18B20::new("28-000000000000".into(), 22625);
        assert_eq!(format!("{}", reading), "28-000000000000: 22.625 °C");

        let reading = DS18B20::new("28-000000000000".into(), -22625);
        assert_eq!(format!("{}", reading), "28-000000000000: -22.625 °C");
    }

    #[test]
    fn test_get_raw_reading() {
        let reading = DS18B20::new("28-000000000000".into(), 22625);
        assert_eq!(reading.raw_reading(), 22625);
    }
}