hilt 0.1.0

Renode-based hardware-in-the-loop test fixtures for embedded Rust projects
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
132
133

//! Captured output of a HIL run and the `assert_hil_ok!` macro.

use std::fmt;

/// Success marker firmware logs (via a CPU hook or semihosting print).
pub const HIL_OK_MARKER: &str = "HIL OK";

/// Result of a HIL run: captured stdout/stderr and the container exit code.
#[derive(Debug, Clone)]
pub struct HilOutput {
    stdout: String,
    stderr: String,
    exit_code: Option<i32>,
}

impl HilOutput {
    /// Builds an output from captured streams and exit code.
    #[must_use]
    pub fn new(stdout: String, stderr: String, exit_code: Option<i32>) -> Self {
        Self {
            stdout,
            stderr,
            exit_code,
        }
    }

    /// `true` if either stream contains the [`HIL_OK_MARKER`].
    #[must_use]
    pub fn passed(&self) -> bool {
        self.contains(HIL_OK_MARKER)
    }

    /// `true` if either stream contains `marker`.
    #[must_use]
    pub fn contains(&self, marker: &str) -> bool {
        self.stdout.contains(marker) || self.stderr.contains(marker)
    }

    /// Captured stdout.
    #[must_use]
    pub fn stdout(&self) -> &str {
        &self.stdout
    }

    /// Captured stderr.
    #[must_use]
    pub fn stderr(&self) -> &str {
        &self.stderr
    }

    /// Stdout and stderr joined with a newline — convenient for log scraping.
    #[must_use]
    pub fn combined(&self) -> String {
        format!("{}\n{}", self.stdout, self.stderr)
    }

    /// Container process exit code, if the process exited normally.
    #[must_use]
    pub fn exit_code(&self) -> Option<i32> {
        self.exit_code
    }
}

impl fmt::Display for HilOutput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let code = match self.exit_code {
            Some(c) => c.to_string(),
            None => "none".to_string(),
        };
        write!(
            f,
            "exit={code}\n--- stdout ---\n{}\n--- stderr ---\n{}",
            self.stdout, self.stderr
        )
    }
}

/// Asserts that a [`HilOutput`] passed.
///
/// `assert_hil_ok!(output)` checks for `HIL OK`; `assert_hil_ok!(output,
/// marker)` checks for a custom marker. On failure it prints the full output.
#[macro_export]
macro_rules! assert_hil_ok {
    ($output:expr) => {
        assert!($output.passed(), "HIL test failed.\n{}", $output)
    };
    ($output:expr, $marker:expr) => {
        assert!(
            $output.contains($marker),
            "HIL test failed -- expected {:?}.\n{}",
            $marker,
            $output,
        )
    };
}

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

    #[test]
    fn passed_detects_marker_in_either_stream() {
        assert!(HilOutput::new("boot\nHIL OK\n".into(), String::new(), Some(0)).passed());
        assert!(HilOutput::new(String::new(), "HIL OK".into(), Some(0)).passed());
        assert!(!HilOutput::new("timeout".into(), String::new(), Some(1)).passed());
    }

    #[test]
    fn contains_and_combined() {
        let o = HilOutput::new("hello".into(), "world".into(), Some(0));
        assert!(o.contains("hello"));
        assert!(o.contains("world"));
        assert_eq!(o.combined(), "hello\nworld");
    }

    #[test]
    fn display_includes_code_and_streams() {
        let s = HilOutput::new("hi".into(), "there".into(), Some(42)).to_string();
        assert!(s.contains("42"));
        assert!(s.contains("hi"));
        assert!(s.contains("there"));
        let none = HilOutput::new(String::new(), String::new(), None).to_string();
        assert!(none.contains("exit=none"));
    }

    #[test]
    fn assert_macro_passes() {
        let o = HilOutput::new("HIL OK".into(), String::new(), Some(0));
        assert_hil_ok!(o);
        let o2 = HilOutput::new("CUSTOM".into(), String::new(), Some(0));
        assert_hil_ok!(o2, "CUSTOM");
    }
}