src/libtest/formatters/json.rs

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