src/libtest/formatters/json.rs

   1 use std::{borrow::Cow, io, io::prelude::Write};
   2
   3 use super::OutputFormatter;
   4 use crate::{
   5     console::{ConsoleTestState, OutputLocation},
   6     test_result::TestResult,
   7     time,
   8     types::TestDesc,
   9 };
  10
  11 pub(crate) struct JsonFormatter<T> {
  12     out: OutputLocation<T>,
  13 }
  14
  15 impl<T: Write> JsonFormatter<T> {
  16     pub fn new(out: OutputLocation<T>) -> Self {
  17         Self { out }
  18     }
  19
  20     fn writeln_message(&mut self, s: &str) -> io::Result<()> {
  21         assert!(!s.contains('\n'));
  22
  23         self.out.write_all(s.as_ref())?;
  24         self.out.write_all(b"\n")
  25     }
  26
  27     fn write_message(&mut self, s: &str) -> io::Result<()> {
  28         assert!(!s.contains('\n'));
  29
  30         self.out.write_all(s.as_ref())
  31     }
  32
  33     fn write_event(
  34         &mut self,
  35         ty: &str,
  36         name: &str,
  37         evt: &str,
  38         exec_time: Option<&time::TestExecTime>,
  39         stdout: Option<Cow<'_, str>>,
  40         extra: Option<&str>,
  41     ) -> io::Result<()> {
  42         self.write_message(&*format!(
  43             r#"{{ "type": "{}", "name": "{}", "event": "{}""#,
  44             ty, name, evt
  45         ))?;
  46         if let Some(exec_time) = exec_time {
  47             self.write_message(&*format!(r#", "exec_time": "{}""#, exec_time))?;
  48         }
  49         if let Some(stdout) = stdout {
  50             self.write_message(&*format!(r#", "stdout": "{}""#, EscapedString(stdout)))?;
  51         }
  52         if let Some(extra) = extra {
  53             self.write_message(&*format!(r#", {}"#, extra))?;
  54         }
  55         self.writeln_message(" }")
  56     }
  57 }
  58
  59 impl<T: Write> OutputFormatter for JsonFormatter<T> {
  60     fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
  61         self.writeln_message(&*format!(
  62             r#"{{ "type": "suite", "event": "started", "test_count": {} }}"#,
  63             test_count
  64         ))
  65     }
  66
  67     fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
  68         self.writeln_message(&*format!(
  69             r#"{{ "type": "test", "event": "started", "name": "{}" }}"#,
  70             desc.name
  71         ))
  72     }
  73
  74     fn write_result(
  75         &mut self,
  76         desc: &TestDesc,
  77         result: &TestResult,
  78         exec_time: Option<&time::TestExecTime>,
  79         stdout: &[u8],
  80         state: &ConsoleTestState,
  81     ) -> io::Result<()> {
  82         let display_stdout = state.options.display_output || *result != TestResult::TrOk;
  83         let stdout = if display_stdout && stdout.len() > 0 {
  84             Some(String::from_utf8_lossy(stdout))
  85         } else {
  86             None
  87         };
  88         match *result {
  89             TestResult::TrOk => {
  90                 self.write_event("test", desc.name.as_slice(), "ok", exec_time, stdout, None)
  91             }
  92
  93             TestResult::TrFailed => {
  94                 self.write_event("test", desc.name.as_slice(), "failed", exec_time, stdout, None)
  95             }
  96
  97             TestResult::TrTimedFail => self.write_event(
  98                 "test",
  99                 desc.name.as_slice(),
 100                 "failed",
 101                 exec_time,
 102                 stdout,
 103                 Some(r#""reason": "time limit exceeded""#),
 104             ),
 105
 106             TestResult::TrFailedMsg(ref m) => self.write_event(
 107                 "test",
 108                 desc.name.as_slice(),
 109                 "failed",
 110                 exec_time,
 111                 stdout,
 112                 Some(&*format!(r#""message": "{}""#, EscapedString(m))),
 113             ),
 114
 115             TestResult::TrIgnored => {
 116                 self.write_event("test", desc.name.as_slice(), "ignored", exec_time, stdout, None)
 117             }
 118
 119             TestResult::TrAllowedFail => self.write_event(
 120                 "test",
 121                 desc.name.as_slice(),
 122                 "allowed_failure",
 123                 exec_time,
 124                 stdout,
 125                 None,
 126             ),
 127
 128             TestResult::TrBench(ref bs) => {
 129                 let median = bs.ns_iter_summ.median as usize;
 130                 let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
 131
 132                 let mbps = if bs.mb_s == 0 {
 133                     String::new()
 134                 } else {
 135                     format!(r#", "mib_per_second": {}"#, bs.mb_s)
 136                 };
 137
 138                 let line = format!(
 139                     "{{ \"type\": \"bench\", \
 140                      \"name\": \"{}\", \
 141                      \"median\": {}, \
 142                      \"deviation\": {}{} }}",
 143                     desc.name, median, deviation, mbps
 144                 );
 145
 146                 self.writeln_message(&*line)
 147             }
 148         }
 149     }
 150
 151     fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
 152         self.writeln_message(&*format!(
 153             r#"{{ "type": "test", "event": "timeout", "name": "{}" }}"#,
 154             desc.name
 155         ))
 156     }
 157
 158     fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
 159         self.writeln_message(&*format!(
 160             "{{ \"type\": \"suite\", \
 161              \"event\": \"{}\", \
 162              \"passed\": {}, \
 163              \"failed\": {}, \
 164              \"allowed_fail\": {}, \
 165              \"ignored\": {}, \
 166              \"measured\": {}, \
 167              \"filtered_out\": {} }}",
 168             if state.failed == 0 { "ok" } else { "failed" },
 169             state.passed,
 170             state.failed + state.allowed_fail,
 171             state.allowed_fail,
 172             state.ignored,
 173             state.measured,
 174             state.filtered_out
 175         ))?;
 176
 177         Ok(state.failed == 0)
 178     }
 179 }
 180
 181 /// A formatting utility used to print strings with characters in need of escaping.
 182 /// Base code taken form `libserialize::json::escape_str`
 183 struct EscapedString<S: AsRef<str>>(S);
 184
 185 impl<S: AsRef<str>> ::std::fmt::Display for EscapedString<S> {
 186     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
 187         let mut start = 0;
 188
 189         for (i, byte) in self.0.as_ref().bytes().enumerate() {
 190             let escaped = match byte {
 191                 b'"' => "\\\"",
 192                 b'\\' => "\\\\",
 193                 b'\x00' => "\\u0000",
 194                 b'\x01' => "\\u0001",
 195                 b'\x02' => "\\u0002",
 196                 b'\x03' => "\\u0003",
 197                 b'\x04' => "\\u0004",
 198                 b'\x05' => "\\u0005",
 199                 b'\x06' => "\\u0006",
 200                 b'\x07' => "\\u0007",
 201                 b'\x08' => "\\b",
 202                 b'\t' => "\\t",
 203                 b'\n' => "\\n",
 204                 b'\x0b' => "\\u000b",
 205                 b'\x0c' => "\\f",
 206                 b'\r' => "\\r",
 207                 b'\x0e' => "\\u000e",
 208                 b'\x0f' => "\\u000f",
 209                 b'\x10' => "\\u0010",
 210                 b'\x11' => "\\u0011",
 211                 b'\x12' => "\\u0012",
 212                 b'\x13' => "\\u0013",
 213                 b'\x14' => "\\u0014",
 214                 b'\x15' => "\\u0015",
 215                 b'\x16' => "\\u0016",
 216                 b'\x17' => "\\u0017",
 217                 b'\x18' => "\\u0018",
 218                 b'\x19' => "\\u0019",
 219                 b'\x1a' => "\\u001a",
 220                 b'\x1b' => "\\u001b",
 221                 b'\x1c' => "\\u001c",
 222                 b'\x1d' => "\\u001d",
 223                 b'\x1e' => "\\u001e",
 224                 b'\x1f' => "\\u001f",
 225                 b'\x7f' => "\\u007f",
 226                 _ => {
 227                     continue;
 228                 }
 229             };
 230
 231             if start < i {
 232                 f.write_str(&self.0.as_ref()[start..i])?;
 233             }
 234
 235             f.write_str(escaped)?;
 236
 237             start = i + 1;
 238         }
 239
 240         if start != self.0.as_ref().len() {
 241             f.write_str(&self.0.as_ref()[start..])?;
 242         }
 243
 244         Ok(())
 245     }
 246 }