src/libtest/formatters/json.rs

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