Added JSON output to libtest.

Author: Gilad Naaman

src/libtest/formatters.rs

@@ -17,7 +17,7 @@ pub(crate) trait OutputFormatter {
         align: NamePadding,
         max_name_len: usize) -> io::Result<()>;
     fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()>;
-    fn write_result(&mut self, result: &TestResult) -> io::Result<()>;
+    fn write_result(&mut self, desc: &TestDesc, result: &TestResult) -> io::Result<()>;
     fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool>;
 }
 
@@ -183,7 +183,7 @@ impl<T: Write> OutputFormatter for HumanFormatter<T> {
         }
     }
 
-    fn write_result(&mut self, result: &TestResult) -> io::Result<()> {
+    fn write_result(&mut self, _desc: &TestDesc, result: &TestResult) -> io::Result<()> {
         match *result {
             TrOk => self.write_ok(),
             TrFailed | TrFailedMsg(_) => self.write_failed(),
@@ -244,3 +244,86 @@ impl<T: Write> OutputFormatter for HumanFormatter<T> {
         Ok(success)
     }
 }
+
+pub(crate) struct JsonFormatter<T> {
+    out: OutputLocation<T>,
+    had_events: bool
+}
+
+impl<T: Write> JsonFormatter<T> {
+    pub fn new(out: OutputLocation<T>) -> Self {
+        Self {
+            out,
+            had_events: false
+        }
+    }
+
+    fn write_str<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
+        self.out.write_all(s.as_ref().as_ref())
+    }
+
+    fn write_event(&mut self, event: &str) -> io::Result<()> {
+        if self.had_events {
+            self.out.write_all(b",\n")?;
+        }
+        else {
+            self.had_events = true;
+        }
+
+        self.out.write_all(event.as_ref())
+    }
+}
+
+impl<T: Write> OutputFormatter for JsonFormatter<T> {
+    fn write_run_start(&mut self, _len: usize) -> io::Result<()> {
+        self.write_str("{\n\tevents: [\n")
+    }
+
+    fn write_test_start(&mut self,
+                        desc: &TestDesc,
+                        _align: NamePadding,
+                        _max_name_len: usize) -> io::Result<()> {
+        self.write_event(&*format!("\t\t{{ \"test\": \"{}\", \"event\": \"started\" }}", desc.name))
+    }
+
+    fn write_result(&mut self, desc: &TestDesc, result: &TestResult) -> io::Result<()> {
+        let output = match *result {
+            TrOk =>                 format!("\t\t{{ \"test\": \"{}\", \"event\": \"ok\" }}", desc.name),
+            TrFailed =>             format!("\t\t{{ \"test\": \"{}\", \"event\": \"failed\" }}", desc.name),
+            TrFailedMsg(ref m) =>   format!("\t\t{{ \"test\": \"{}\", \"event\": \"failed\", \"extra\": \"{}\" }}", desc.name, m),
+            TrIgnored =>            format!("\t\t{{ \"test\": \"{}\", \"event\": \"ignored\" }}", desc.name),
+            TrAllowedFail =>        format!("\t\t{{ \"test\": \"{}\", \"event\": \"allowed_failure\" }}", desc.name),
+            TrMetrics(ref mm) =>    format!("\t\t{{ \"test\": \"{}\", \"event\": \"metrics\", \"extra\": \"{}\" }}", desc.name, mm.fmt_metrics()),
+            TrBench(ref bs) =>      format!("\t\t{{ \"test\": \"{}\", \"event\": \"bench\", \"extra\": \"{}\" }}", desc.name, fmt_bench_samples(bs)),
+        };
+
+        self.write_event(&*output)
+    }
+
+    fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
+        self.write_event(&*format!("\t{{ \"test\": \"{}\", \"event\": \"timeout\" }}", desc.name))
+    }
+
+    fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
+        self.write_str("\n\t],\n\t\"summary\": {\n")?;
+
+        self.write_str(&*format!("\t\t\"passed\": {},\n", state.passed))?;
+        self.write_str(&*format!("\t\t\"failed\": {},\n", state.failed + state.allowed_fail))?;
+        self.write_str(&*format!("\t\t\"allowed_fail\": {},\n", state.allowed_fail))?;
+        self.write_str(&*format!("\t\t\"ignored\": {},\n", state.ignored))?;
+        self.write_str(&*format!("\t\t\"measured\": {},\n", state.measured))?;
+
+        if state.failed == 0 {
+            self.write_str(&*format!("\t\t\"filtered_out\": {}\n", state.filtered_out))?;
+        } else {
+            self.write_str(&*format!("\t\t\"filtered_out\": {},\n", state.filtered_out))?;
+            self.write_str("\t\t\"failures\": [")?;
+
+            self.write_str("\t\t]\n")?;
+        }
+        
+        self.write_str("\t}\n}\n")?;
+
+        Ok(state.failed == 0)
+    }
+}

src/libtest/lib.rs

@@ -321,6 +321,13 @@ pub enum ColorConfig {
     NeverColor,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum OutputFormat {
+    Pretty,
+    Terse,
+    Json
+}
+
 #[derive(Debug)]
 pub struct TestOpts {
     pub list: bool,
@@ -332,7 +339,7 @@ pub struct TestOpts {
     pub logfile: Option<PathBuf>,
     pub nocapture: bool,
     pub color: ColorConfig,
-    pub quiet: bool,
+    pub format: OutputFormat,
     pub test_threads: Option<usize>,
     pub skip: Vec<String>,
     pub options: Options,
@@ -351,7 +358,7 @@ impl TestOpts {
             logfile: None,
             nocapture: false,
             color: AutoColor,
-            quiet: false,
+            format: OutputFormat,
             test_threads: None,
             skip: vec![],
             options: Options::new(),
@@ -383,7 +390,11 @@ fn optgroups() -> getopts::Options {
         .optopt("", "color", "Configure coloring of output:
             auto   = colorize if stdout is a tty and tests are run on serially (default);
             always = always colorize output;
-            never  = never colorize output;", "auto|always|never");
+            never  = never colorize output;", "auto|always|never")
+        .optopt("", "format", "Configure formatting of output:
+            pretty = Print verbose output;
+            terse  = Display one character per test;
+            json   = Output a json document", "pretty|terse|json");
     return opts
 }
 
@@ -484,6 +495,19 @@ pub fn parse_opts(args: &[String]) -> Option<OptRes> {
         }
     };
 
+    let format = match matches.opt_str("format").as_ref().map(|s| &**s) {
+        None if quiet => OutputFormat::Terse,
+        Some("pretty") | None => OutputFormat::Pretty,
+        Some("terse") => OutputFormat::Terse,
+        Some("json") => OutputFormat::Json,
+
+        Some(v) => {
+            return Some(Err(format!("argument for --format must be pretty, terse, or json (was \
+                                     {})",
+                                    v)))
+        }
+    };
+
     let test_opts = TestOpts {
         list,
         filter,
@@ -494,7 +518,7 @@ pub fn parse_opts(args: &[String]) -> Option<OptRes> {
         logfile,
         nocapture,
         color,
-        quiet,
+        format,
         test_threads,
         skip: matches.opt_strs("skip"),
         options: Options::new(),
@@ -656,7 +680,9 @@ pub fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Res
         None => Raw(io::stdout()),
         Some(t) => Pretty(t),
     };
-    let mut out = HumanFormatter::new(output, use_color(opts), opts.quiet);
+    
+    let quiet = opts.format == OutputFormat::Terse;
+    let mut out = HumanFormatter::new(output, use_color(opts), quiet);
     let mut st = ConsoleTestState::new(opts)?;
 
     let mut ntest = 0;
@@ -683,9 +709,9 @@ pub fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Res
         }
     }
 
-    if !opts.quiet {
+    if !quiet {
         if ntest != 0 || nbench != 0 {
-            st.write_plain("\n")?;
+            out.write_plain("\n")?;
         }
         st.write_plain(format!("{}, {}\n",
             plural(ntest, "test"),
@@ -712,7 +738,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Resu
             TeTimeout(ref test) => out.write_timeout(test),
             TeResult(test, result, stdout) => {
                 st.write_log_result(&test, &result)?;
-                out.write_result(&result)?;
+                out.write_result(&test, &result)?;
                 match result {
                     TrOk => {
                         st.passed += 1;
@@ -749,8 +775,11 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Resu
         Some(t) => Pretty(t),
     };
 
-    let mut out = HumanFormatter::new(output, use_color(opts), opts.quiet);
-
+    let mut out: Box<OutputFormatter> = match opts.format {
+        OutputFormat::Pretty => Box::new(HumanFormatter::new(output, use_color(opts), false)),
+        OutputFormat::Terse => Box::new(HumanFormatter::new(output, use_color(opts), true)),
+        OutputFormat::Json => Box::new(JsonFormatter::new(output)),
+    };
     let mut st = ConsoleTestState::new(opts)?;
     fn len_if_padded(t: &TestDescAndFn) -> usize {
         match t.testfn.padding() {
@@ -762,7 +791,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Resu
         let n = t.desc.name.as_slice();
         st.max_name_len = n.len();
     }
-    run_tests(opts, tests, |x| callback(&x, &mut st, &mut out))?;
+    run_tests(opts, tests, |x| callback(&x, &mut st, &mut *out))?;
 
     assert!(st.current_test_count() == st.total);
 

src/tools/compiletest/src/main.rs

@@ -484,7 +484,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         filter: config.filter.clone(),
         filter_exact: config.filter_exact,
         run_ignored: config.run_ignored,
-        quiet: config.quiet,
+        format: if config.quiet { test::OutputFormat::Terse } else { test::OutputFormat::Pretty },
         logfile: config.logfile.clone(),
         run_tests: true,
         bench_benchmarks: true,