libtest2_harness/notify/
terse.rs

1use super::Event;
2use super::MessageKind;
3use super::FAILED;
4use super::IGNORED;
5use super::OK;
6
7#[derive(Debug)]
8pub(crate) struct TerseListNotifier<W> {
9    writer: W,
10    tests: usize,
11}
12
13impl<W: std::io::Write> TerseListNotifier<W> {
14    pub(crate) fn new(writer: W) -> Self {
15        Self { writer, tests: 0 }
16    }
17}
18
19impl<W: std::io::Write> super::Notifier for TerseListNotifier<W> {
20    fn notify(&mut self, event: Event) -> std::io::Result<()> {
21        match event {
22            Event::DiscoverStart(_) => {}
23            Event::DiscoverCase(inner) => {
24                if inner.selected {
25                    let name = &inner.name;
26                    let mode = inner.mode.as_str();
27                    writeln!(self.writer, "{name}: {mode}")?;
28                    self.tests += 1;
29                }
30            }
31            Event::DiscoverComplete(_) => {
32                writeln!(self.writer)?;
33                writeln!(self.writer, "{} tests", self.tests)?;
34                writeln!(self.writer)?;
35            }
36            Event::RunStart(_) => {}
37            Event::CaseStart(_) => {}
38            Event::CaseMessage(_) => {}
39            Event::CaseComplete(_) => {}
40            Event::RunComplete(_) => {}
41        }
42        Ok(())
43    }
44}
45
46#[derive(Debug)]
47pub(crate) struct TerseRunNotifier<W> {
48    writer: W,
49    summary: super::Summary,
50}
51
52impl<W: std::io::Write> TerseRunNotifier<W> {
53    pub(crate) fn new(writer: W) -> Self {
54        Self {
55            writer,
56            summary: Default::default(),
57        }
58    }
59}
60
61impl<W: std::io::Write> super::Notifier for TerseRunNotifier<W> {
62    fn notify(&mut self, event: Event) -> std::io::Result<()> {
63        self.summary.notify(event.clone())?;
64        match event {
65            Event::DiscoverStart(_) => {}
66            Event::DiscoverCase(_) => {}
67            Event::DiscoverComplete(_) => {}
68            Event::RunStart(_) => {
69                self.summary.write_start(&mut self.writer)?;
70            }
71            Event::CaseStart(_) => {}
72            Event::CaseMessage(_) => {}
73            Event::CaseComplete(inner) => {
74                let status = self.summary.get_kind(&inner.name);
75                let (c, style) = match status {
76                    Some(MessageKind::Ignored) => ('i', IGNORED),
77                    Some(MessageKind::Error) => ('F', FAILED),
78                    None => ('.', OK),
79                };
80                write!(self.writer, "{style}{c}{style:#}")?;
81                self.writer.flush()?;
82            }
83            Event::RunComplete(_) => {
84                self.summary.write_complete(&mut self.writer)?;
85            }
86        }
87        Ok(())
88    }
89}