Skip to main content

yaiko_core/
test_facade.rs

1//! Deterministic test harness metadata and reports.
2#[derive(Debug, Clone, Copy, PartialEq, Eq)]
3pub enum TestOutcome {
4    Passed,
5    Failed,
6}
7#[derive(Debug, Clone, PartialEq, Eq)]
8pub enum TestError {
9    InvalidName,
10    InvalidMessage,
11    Capacity,
12}
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub struct TestReport {
15    pub name: String,
16    pub outcome: TestOutcome,
17    pub message: String,
18}
19#[derive(Debug, Clone, Default)]
20pub struct TestHarness {
21    cases: Vec<TestReport>,
22    capacity: usize,
23}
24impl TestHarness {
25    pub fn new(capacity: usize) -> Self {
26        Self {
27            cases: Vec::new(),
28            capacity,
29        }
30    }
31    pub fn add(
32        mut self,
33        name: impl Into<String>,
34        outcome: TestOutcome,
35        message: impl Into<String>,
36    ) -> Result<Self, TestError> {
37        let name = name.into();
38        let message = message.into();
39        if name.is_empty()
40            || name.len() > 128
41            || name.chars().any(|c| c.is_control() || c.is_whitespace())
42        {
43            return Err(TestError::InvalidName);
44        }
45        if message.len() > 512 {
46            return Err(TestError::InvalidMessage);
47        }
48        if self.cases.len() >= self.capacity {
49            return Err(TestError::Capacity);
50        }
51        self.cases.push(TestReport {
52            name,
53            outcome,
54            message,
55        });
56        self.cases.sort_by(|a, b| a.name.cmp(&b.name));
57        Ok(self)
58    }
59    pub fn passed(&self) -> usize {
60        self.cases
61            .iter()
62            .filter(|x| x.outcome == TestOutcome::Passed)
63            .count()
64    }
65    pub fn failed(&self) -> usize {
66        self.cases
67            .iter()
68            .filter(|x| x.outcome == TestOutcome::Failed)
69            .count()
70    }
71    pub fn snapshot(&self) -> &[TestReport] {
72        &self.cases
73    }
74}
75#[cfg(test)]
76mod tests {
77    use super::*;
78    #[test]
79    fn sorts_and_counts_reports() {
80        let h = TestHarness::new(2)
81            .add("z", TestOutcome::Passed, "ok")
82            .unwrap()
83            .add("a", TestOutcome::Failed, "bad")
84            .unwrap();
85        assert_eq!(h.snapshot()[0].name, "a");
86        assert_eq!(h.passed(), 1);
87        assert_eq!(h.failed(), 1)
88    }
89    #[test]
90    fn validates_and_bounds_cases() {
91        assert!(TestHarness::new(1)
92            .add("bad name", TestOutcome::Passed, "ok")
93            .is_err());
94        let h = TestHarness::new(1)
95            .add("a", TestOutcome::Passed, "ok")
96            .unwrap();
97        assert!(h.add("b", TestOutcome::Passed, "ok").is_err());
98        assert!(TestHarness::new(1)
99            .add("a", TestOutcome::Passed, "x".repeat(513))
100            .is_err())
101    }
102}