bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #46450 - Gilnaa:libtest_json_output, r=nrc

Browse source 
Libtest json output

A revisit to my [last PR](https://github.com/rust-lang/rust/pull/45923).

Events are now more atomic, printed in a flat hierarchy.

For the normal test output:
```
running 1 test
test f ... FAILED

failures:

---- f stdout ----
	thread 'f' panicked at 'assertion failed: `(left == right)`
  left: `3`,
 right: `4`', f.rs:3:1
note: Run with `RUST_BACKTRACE=1` for a backtrace.

failures:
    f

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out
```

The JSON equivalent is:
```
{ "type": "suite", "event": "started", "test_count": "1" }
{ "type": "test", "event": "started", "name": "f" }
{ "type": "test", "event": "failed", "name": "f" }
{ "type": "suite", "event": "failed", "passed": 0, "failed": 1, "allowed_fail": 0, "ignored": 0,  "measured": 0, "filtered_out": "0" }
{ "type": "test_output", "name": "f", "output": "thread 'f' panicked at 'assertion failed: `(left == right)`
  left: `3`,
 right: `4`', f.rs:3:1
note: Run with `RUST_BACKTRACE=1` for a backtrace.
" }
```
This commit is contained in:
bors 2018-01-27 10:56:56 +00:00
commit 6b99adeb11
12 changed files with 1711 additions and 754 deletions
Download patch file Download diff file Expand all files Collapse all files

229
src/libtest/formatters/json.rs Normal file
View file

@ -0,0 +1,229 @@
// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::*;
pub(crate) struct JsonFormatter<T> {
out: OutputLocation<T>,
}
impl<T: Write> JsonFormatter<T> {
pub fn new(out: OutputLocation<T>) -> Self {
Self { out }
}
fn write_message(&mut self, s: &str) -> io::Result<()> {
assert!(!s.contains('\n'));
self.out.write_all(s.as_ref())?;
self.out.write_all(b"\n")
}
fn write_event(
&mut self,
ty: &str,
name: &str,
evt: &str,
extra: Option<String>,
) -> io::Result<()> {
if let Some(extras) = extra {
self.write_message(&*format!(
r#"{{ "type": "{}", "name": "{}", "event": "{}", {} }}"#,
ty,
name,
evt,
extras
))
} else {
self.write_message(&*format!(
r#"{{ "type": "{}", "name": "{}", "event": "{}" }}"#,
ty,
name,
evt
))
}
}
}
impl<T: Write> OutputFormatter for JsonFormatter<T> {
fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
self.write_message(&*format!(
r#"{{ "type": "suite", "event": "started", "test_count": "{}" }}"#,
test_count
))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_message(&*format!(
r#"{{ "type": "test", "event": "started", "name": "{}" }}"#,
desc.name
))
}
fn write_result(
&mut self,
desc: &TestDesc,
result: &TestResult,
stdout: &[u8],
) -> io::Result<()> {
match *result {
TrOk => self.write_event("test", desc.name.as_slice(), "ok", None),
TrFailed => {
let extra_data = if stdout.len() > 0 {
Some(format!(
r#""stdout": "{}""#,
EscapedString(String::from_utf8_lossy(stdout))
))
} else {
None
};
self.write_event("test", desc.name.as_slice(), "failed", extra_data)
}
TrFailedMsg(ref m) => {
self.write_event(
"test",
desc.name.as_slice(),
"failed",
Some(format!(r#""message": "{}""#, EscapedString(m))),
)
}
TrIgnored => self.write_event("test", desc.name.as_slice(), "ignored", None),
TrAllowedFail => {
self.write_event("test", desc.name.as_slice(), "allowed_failure", None)
}
TrBench(ref bs) => {
let median = bs.ns_iter_summ.median as usize;
let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize;
let mbps = if bs.mb_s == 0 {
"".into()
} else {
format!(r#", "mib_per_second": {}"#, bs.mb_s)
};
let line = format!(
"{{ \"type\": \"bench\", \
\"name\": \"{}\", \
\"median\": {}, \
\"deviation\": {}{} }}",
desc.name,
median,
deviation,
mbps
);
self.write_message(&*line)
}
}
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_message(&*format!(
r#"{{ "type": "test", "event": "timeout", "name": "{}" }}"#,
desc.name
))
}
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
self.write_message(&*format!(
"{{ \"type\": \"suite\", \
\"event\": \"{}\", \
\"passed\": {}, \
\"failed\": {}, \
\"allowed_fail\": {}, \
\"ignored\": {}, \
\"measured\": {}, \
\"filtered_out\": \"{}\" }}",
if state.failed == 0 { "ok" } else { "failed" },
state.passed,
state.failed + state.allowed_fail,
state.allowed_fail,
state.ignored,
state.measured,
state.filtered_out
))?;
Ok(state.failed == 0)
}
}
/// A formatting utility used to print strings with characters in need of escaping.
/// Base code taken form `libserialize::json::escape_str`
struct EscapedString<S: AsRef<str>>(S);
impl<S: AsRef<str>> ::std::fmt::Display for EscapedString<S> {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
let mut start = 0;
for (i, byte) in self.0.as_ref().bytes().enumerate() {
let escaped = match byte {
b'"' => "\\\"",
b'\\' => "\\\\",
b'\x00' => "\\u0000",
b'\x01' => "\\u0001",
b'\x02' => "\\u0002",
b'\x03' => "\\u0003",
b'\x04' => "\\u0004",
b'\x05' => "\\u0005",
b'\x06' => "\\u0006",
b'\x07' => "\\u0007",
b'\x08' => "\\b",
b'\t' => "\\t",
b'\n' => "\\n",
b'\x0b' => "\\u000b",
b'\x0c' => "\\f",
b'\r' => "\\r",
b'\x0e' => "\\u000e",
b'\x0f' => "\\u000f",
b'\x10' => "\\u0010",
b'\x11' => "\\u0011",
b'\x12' => "\\u0012",
b'\x13' => "\\u0013",
b'\x14' => "\\u0014",
b'\x15' => "\\u0015",
b'\x16' => "\\u0016",
b'\x17' => "\\u0017",
b'\x18' => "\\u0018",
b'\x19' => "\\u0019",
b'\x1a' => "\\u001a",
b'\x1b' => "\\u001b",
b'\x1c' => "\\u001c",
b'\x1d' => "\\u001d",
b'\x1e' => "\\u001e",
b'\x1f' => "\\u001f",
b'\x7f' => "\\u007f",
_ => {
continue;
}
};
if start < i {
f.write_str(&self.0.as_ref()[start..i])?;
}
f.write_str(escaped)?;
start = i + 1;
}
if start != self.0.as_ref().len() {
f.write_str(&self.0.as_ref()[start..])?;
}
Ok(())
}
}

32
src/libtest/formatters/mod.rs Normal file
View file

@ -0,0 +1,32 @@
// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::*;
mod pretty;
mod json;
mod terse;
pub(crate) use self::pretty::PrettyFormatter;
pub(crate) use self::json::JsonFormatter;
pub(crate) use self::terse::TerseFormatter;
pub(crate) trait OutputFormatter {
fn write_run_start(&mut self, test_count: usize) -> io::Result<()>;
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()>;
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()>;
fn write_result(
&mut self,
desc: &TestDesc,
result: &TestResult,
stdout: &[u8],
) -> io::Result<()>;
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool>;
}

247
src/libtest/formatters/pretty.rs Normal file
View file

@ -0,0 +1,247 @@
// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::*;
pub(crate) struct PrettyFormatter<T> {
out: OutputLocation<T>,
use_color: bool,
/// Number of columns to fill when aligning names
max_name_len: usize,
is_multithreaded: bool,
}
impl<T: Write> PrettyFormatter<T> {
pub fn new(
out: OutputLocation<T>,
use_color: bool,
max_name_len: usize,
is_multithreaded: bool,
) -> Self {
PrettyFormatter {
out,
use_color,
max_name_len,
is_multithreaded,
}
}
#[cfg(test)]
pub fn output_location(&self) -> &OutputLocation<T> {
&self.out
}
pub fn write_ok(&mut self) -> io::Result<()> {
self.write_short_result("ok", term::color::GREEN)
}
pub fn write_failed(&mut self) -> io::Result<()> {
self.write_short_result("FAILED", term::color::RED)
}
pub fn write_ignored(&mut self) -> io::Result<()> {
self.write_short_result("ignored", term::color::YELLOW)
}
pub fn write_allowed_fail(&mut self) -> io::Result<()> {
self.write_short_result("FAILED (allowed)", term::color::YELLOW)
}
pub fn write_bench(&mut self) -> io::Result<()> {
self.write_pretty("bench", term::color::CYAN)
}
pub fn write_short_result(
&mut self,
result: &str,
color: term::color::Color,
) -> io::Result<()> {
self.write_pretty(result, color)?;
self.write_plain("\n")
}
pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
match self.out {
Pretty(ref mut term) => {
if self.use_color {
term.fg(color)?;
}
term.write_all(word.as_bytes())?;
if self.use_color {
term.reset()?;
}
term.flush()
}
Raw(ref mut stdout) => {
stdout.write_all(word.as_bytes())?;
stdout.flush()
}
}
}
pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
let s = s.as_ref();
self.out.write_all(s.as_bytes())?;
self.out.flush()
}
pub fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_plain("\nsuccesses:\n")?;
let mut successes = Vec::new();
let mut stdouts = String::new();
for &(ref f, ref stdout) in &state.not_failures {
successes.push(f.name.to_string());
if !stdout.is_empty() {
stdouts.push_str(&format!("---- {} stdout ----\n\t", f.name));
let output = String::from_utf8_lossy(stdout);
stdouts.push_str(&output);
stdouts.push_str("\n");
}
}
if !stdouts.is_empty() {
self.write_plain("\n")?;
self.write_plain(&stdouts)?;
}
self.write_plain("\nsuccesses:\n")?;
successes.sort();
for name in &successes {
self.write_plain(&format!(" {}\n", name))?;
}
Ok(())
}
pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_plain("\nfailures:\n")?;
let mut failures = Vec::new();
let mut fail_out = String::new();
for &(ref f, ref stdout) in &state.failures {
failures.push(f.name.to_string());
if !stdout.is_empty() {
fail_out.push_str(&format!("---- {} stdout ----\n\t", f.name));
let output = String::from_utf8_lossy(stdout);
fail_out.push_str(&output);
fail_out.push_str("\n");
}
}
if !fail_out.is_empty() {
self.write_plain("\n")?;
self.write_plain(&fail_out)?;
}
self.write_plain("\nfailures:\n")?;
failures.sort();
for name in &failures {
self.write_plain(&format!(" {}\n", name))?;
}
Ok(())
}
fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
let name = desc.padded_name(self.max_name_len, desc.name.padding());
self.write_plain(&format!("test {} ... ", name))?;
Ok(())
}
}
impl<T: Write> OutputFormatter for PrettyFormatter<T> {
fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
let noun = if test_count != 1 { "tests" } else { "test" };
self.write_plain(&format!("\nrunning {} {}\n", test_count, noun))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
// When running tests concurrently, we should not print
// the test's name as the result will be mis-aligned.
// When running the tests serially, we print the name here so
// that the user can see which test hangs.
if !self.is_multithreaded {
self.write_test_name(desc)?;
}
Ok(())
}
fn write_result(&mut self, desc: &TestDesc, result: &TestResult, _: &[u8]) -> io::Result<()> {
if self.is_multithreaded {
self.write_test_name(desc)?;
}
match *result {
TrOk => self.write_ok(),
TrFailed | TrFailedMsg(_) => self.write_failed(),
TrIgnored => self.write_ignored(),
TrAllowedFail => self.write_allowed_fail(),
TrBench(ref bs) => {
self.write_bench()?;
self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
}
}
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
if self.is_multithreaded {
self.write_test_name(desc)?;
}
self.write_plain(&format!(
"test {} has been running for over {} seconds\n",
desc.name,
TEST_WARN_TIMEOUT_S
))
}
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
if state.options.display_output {
self.write_successes(state)?;
}
let success = state.failed == 0;
if !success {
self.write_failures(state)?;
}
self.write_plain("\ntest result: ")?;
if success {
// There's no parallelism at this point so it's safe to use color
self.write_pretty("ok", term::color::GREEN)?;
} else {
self.write_pretty("FAILED", term::color::RED)?;
}
let s = if state.allowed_fail > 0 {
format!(
". {} passed; {} failed ({} allowed); {} ignored; {} measured; {} filtered out\n\n",
state.passed,
state.failed + state.allowed_fail,
state.allowed_fail,
state.ignored,
state.measured,
state.filtered_out
)
} else {
format!(
". {} passed; {} failed; {} ignored; {} measured; {} filtered out\n\n",
state.passed,
state.failed,
state.ignored,
state.measured,
state.filtered_out
)
};
self.write_plain(&s)?;
Ok(success)
}
}

246
src/libtest/formatters/terse.rs Normal file
View file

@ -0,0 +1,246 @@
// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::*;
pub(crate) struct TerseFormatter<T> {
out: OutputLocation<T>,
use_color: bool,
is_multithreaded: bool,
/// Number of columns to fill when aligning names
max_name_len: usize,
test_count: usize,
}
impl<T: Write> TerseFormatter<T> {
pub fn new(
out: OutputLocation<T>,
use_color: bool,
max_name_len: usize,
is_multithreaded: bool,
) -> Self {
TerseFormatter {
out,
use_color,
max_name_len,
is_multithreaded,
test_count: 0,
}
}
pub fn write_ok(&mut self) -> io::Result<()> {
self.write_short_result(".", term::color::GREEN)
}
pub fn write_failed(&mut self) -> io::Result<()> {
self.write_short_result("F", term::color::RED)
}
pub fn write_ignored(&mut self) -> io::Result<()> {
self.write_short_result("i", term::color::YELLOW)
}
pub fn write_allowed_fail(&mut self) -> io::Result<()> {
self.write_short_result("a", term::color::YELLOW)
}
pub fn write_bench(&mut self) -> io::Result<()> {
self.write_pretty("bench", term::color::CYAN)
}
pub fn write_short_result(
&mut self,
result: &str,
color: term::color::Color,
) -> io::Result<()> {
self.write_pretty(result, color)?;
if self.test_count % QUIET_MODE_MAX_COLUMN == QUIET_MODE_MAX_COLUMN - 1 {
// we insert a new line every 100 dots in order to flush the
// screen when dealing with line-buffered output (e.g. piping to
// `stamp` in the rust CI).
self.write_plain("\n")?;
}
self.test_count += 1;
Ok(())
}
pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
match self.out {
Pretty(ref mut term) => {
if self.use_color {
term.fg(color)?;
}
term.write_all(word.as_bytes())?;
if self.use_color {
term.reset()?;
}
term.flush()
}
Raw(ref mut stdout) => {
stdout.write_all(word.as_bytes())?;
stdout.flush()
}
}
}
pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
let s = s.as_ref();
self.out.write_all(s.as_bytes())?;
self.out.flush()
}
pub fn write_outputs(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_plain("\nsuccesses:\n")?;
let mut successes = Vec::new();
let mut stdouts = String::new();
for &(ref f, ref stdout) in &state.not_failures {
successes.push(f.name.to_string());
if !stdout.is_empty() {
stdouts.push_str(&format!("---- {} stdout ----\n\t", f.name));
let output = String::from_utf8_lossy(stdout);
stdouts.push_str(&output);
stdouts.push_str("\n");
}
}
if !stdouts.is_empty() {
self.write_plain("\n")?;
self.write_plain(&stdouts)?;
}
self.write_plain("\nsuccesses:\n")?;
successes.sort();
for name in &successes {
self.write_plain(&format!(" {}\n", name))?;
}
Ok(())
}
pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_plain("\nfailures:\n")?;
let mut failures = Vec::new();
let mut fail_out = String::new();
for &(ref f, ref stdout) in &state.failures {
failures.push(f.name.to_string());
if !stdout.is_empty() {
fail_out.push_str(&format!("---- {} stdout ----\n\t", f.name));
let output = String::from_utf8_lossy(stdout);
fail_out.push_str(&output);
fail_out.push_str("\n");
}
}
if !fail_out.is_empty() {
self.write_plain("\n")?;
self.write_plain(&fail_out)?;
}
self.write_plain("\nfailures:\n")?;
failures.sort();
for name in &failures {
self.write_plain(&format!(" {}\n", name))?;
}
Ok(())
}
fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
let name = desc.padded_name(self.max_name_len, desc.name.padding());
self.write_plain(&format!("test {} ... ", name))?;
Ok(())
}
}
impl<T: Write> OutputFormatter for TerseFormatter<T> {
fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
let noun = if test_count != 1 { "tests" } else { "test" };
self.write_plain(&format!("\nrunning {} {}\n", test_count, noun))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
// Remnants from old libtest code that used the padding value
// in order to indicate benchmarks.
// When running benchmarks, terse-mode should still print their name as if
// it is the Pretty formatter.
if !self.is_multithreaded && desc.name.padding() == PadOnRight {
self.write_test_name(desc)?;
}
Ok(())
}
fn write_result(&mut self, desc: &TestDesc, result: &TestResult, _: &[u8]) -> io::Result<()> {
match *result {
TrOk => self.write_ok(),
TrFailed | TrFailedMsg(_) => self.write_failed(),
TrIgnored => self.write_ignored(),
TrAllowedFail => self.write_allowed_fail(),
TrBench(ref bs) => {
if self.is_multithreaded {
self.write_test_name(desc)?;
}
self.write_bench()?;
self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
}
}
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_plain(&format!(
"test {} has been running for over {} seconds\n",
desc.name,
TEST_WARN_TIMEOUT_S
))
}
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
if state.options.display_output {
self.write_outputs(state)?;
}
let success = state.failed == 0;
if !success {
self.write_failures(state)?;
}
self.write_plain("\ntest result: ")?;
if success {
// There's no parallelism at this point so it's safe to use color
self.write_pretty("ok", term::color::GREEN)?;
} else {
self.write_pretty("FAILED", term::color::RED)?;
}
let s = if state.allowed_fail > 0 {
format!(
". {} passed; {} failed ({} allowed); {} ignored; {} measured; {} filtered out\n\n",
state.passed,
state.failed + state.allowed_fail,
state.allowed_fail,
state.ignored,
state.measured,
state.filtered_out
)
} else {
format!(
". {} passed; {} failed; {} ignored; {} measured; {} filtered out\n\n",
state.passed,
state.failed,
state.ignored,
state.measured,
state.filtered_out
)
};
self.write_plain(&s)?;
Ok(success)
}
}

1129
src/libtest/lib.rs
View file

File diff suppressed because it is too large Load diff

504
src/libtest/stats.rs
View file

@ -400,16 +400,18 @@ mod tests {
} }
#[test] #[test]
fn test_norm10narrow() { fn test_norm10narrow() {
let val = &[966.0000000000, let val = &[
985.0000000000, 966.0000000000,
1110.0000000000, 985.0000000000,
848.0000000000, 1110.0000000000,
821.0000000000, 848.0000000000,
975.0000000000, 821.0000000000,
962.0000000000, 975.0000000000,
1157.0000000000, 962.0000000000,
1217.0000000000, 1157.0000000000,
955.0000000000]; 1217.0000000000,
955.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 9996.0000000000, sum: 9996.0000000000,
min: 821.0000000000, min: 821.0000000000,
@ -428,16 +430,18 @@ mod tests {
} }
#[test] #[test]
fn test_norm10medium() { fn test_norm10medium() {
let val = &[954.0000000000, let val = &[
1064.0000000000, 954.0000000000,
855.0000000000, 1064.0000000000,
1000.0000000000, 855.0000000000,
743.0000000000, 1000.0000000000,
1084.0000000000, 743.0000000000,
704.0000000000, 1084.0000000000,
1023.0000000000, 704.0000000000,
357.0000000000, 1023.0000000000,
869.0000000000]; 357.0000000000,
869.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 8653.0000000000, sum: 8653.0000000000,
min: 357.0000000000, min: 357.0000000000,
@ -456,16 +460,18 @@ mod tests {
} }
#[test] #[test]
fn test_norm10wide() { fn test_norm10wide() {
let val = &[505.0000000000, let val = &[
497.0000000000, 505.0000000000,
1591.0000000000, 497.0000000000,
887.0000000000, 1591.0000000000,
1026.0000000000, 887.0000000000,
136.0000000000, 1026.0000000000,
1580.0000000000, 136.0000000000,
940.0000000000, 1580.0000000000,
754.0000000000, 940.0000000000,
1433.0000000000]; 754.0000000000,
1433.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 9349.0000000000, sum: 9349.0000000000,
min: 136.0000000000, min: 136.0000000000,
@ -484,31 +490,33 @@ mod tests {
} }
#[test] #[test]
fn test_norm25verynarrow() { fn test_norm25verynarrow() {
let val = &[991.0000000000, let val = &[
1018.0000000000, 991.0000000000,
998.0000000000, 1018.0000000000,
1013.0000000000, 998.0000000000,
974.0000000000, 1013.0000000000,
1007.0000000000, 974.0000000000,
1014.0000000000, 1007.0000000000,
999.0000000000, 1014.0000000000,
1011.0000000000, 999.0000000000,
978.0000000000, 1011.0000000000,
985.0000000000, 978.0000000000,
999.0000000000, 985.0000000000,
983.0000000000, 999.0000000000,
982.0000000000, 983.0000000000,
1015.0000000000, 982.0000000000,
1002.0000000000, 1015.0000000000,
977.0000000000, 1002.0000000000,
948.0000000000, 977.0000000000,
1040.0000000000, 948.0000000000,
974.0000000000, 1040.0000000000,
996.0000000000, 974.0000000000,
989.0000000000, 996.0000000000,
1015.0000000000, 989.0000000000,
994.0000000000, 1015.0000000000,
1024.0000000000]; 994.0000000000,
1024.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 24926.0000000000, sum: 24926.0000000000,
min: 948.0000000000, min: 948.0000000000,
@ -527,16 +535,18 @@ mod tests {
} }
#[test] #[test]
fn test_exp10a() { fn test_exp10a() {
let val = &[23.0000000000, let val = &[
11.0000000000, 23.0000000000,
2.0000000000, 11.0000000000,
57.0000000000, 2.0000000000,
4.0000000000, 57.0000000000,
12.0000000000, 4.0000000000,
5.0000000000, 12.0000000000,
29.0000000000, 5.0000000000,
3.0000000000, 29.0000000000,
21.0000000000]; 3.0000000000,
21.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 167.0000000000, sum: 167.0000000000,
min: 2.0000000000, min: 2.0000000000,
@ -555,16 +565,18 @@ mod tests {
} }
#[test] #[test]
fn test_exp10b() { fn test_exp10b() {
let val = &[24.0000000000, let val = &[
17.0000000000, 24.0000000000,
6.0000000000, 17.0000000000,
38.0000000000, 6.0000000000,
25.0000000000, 38.0000000000,
7.0000000000, 25.0000000000,
51.0000000000, 7.0000000000,
2.0000000000, 51.0000000000,
61.0000000000, 2.0000000000,
32.0000000000]; 61.0000000000,
32.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 263.0000000000, sum: 263.0000000000,
min: 2.0000000000, min: 2.0000000000,
@ -583,16 +595,18 @@ mod tests {
} }
#[test] #[test]
fn test_exp10c() { fn test_exp10c() {
let val = &[71.0000000000, let val = &[
2.0000000000, 71.0000000000,
32.0000000000, 2.0000000000,
1.0000000000, 32.0000000000,
6.0000000000, 1.0000000000,
28.0000000000, 6.0000000000,
13.0000000000, 28.0000000000,
37.0000000000, 13.0000000000,
16.0000000000, 37.0000000000,
36.0000000000]; 16.0000000000,
36.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 242.0000000000, sum: 242.0000000000,
min: 1.0000000000, min: 1.0000000000,
@ -611,31 +625,33 @@ mod tests {
} }
#[test] #[test]
fn test_exp25() { fn test_exp25() {
let val = &[3.0000000000, let val = &[
24.0000000000, 3.0000000000,
1.0000000000, 24.0000000000,
19.0000000000, 1.0000000000,
7.0000000000, 19.0000000000,
5.0000000000, 7.0000000000,
30.0000000000, 5.0000000000,
39.0000000000, 30.0000000000,
31.0000000000, 39.0000000000,
13.0000000000, 31.0000000000,
25.0000000000, 13.0000000000,
48.0000000000, 25.0000000000,
1.0000000000, 48.0000000000,
6.0000000000, 1.0000000000,
42.0000000000, 6.0000000000,
63.0000000000, 42.0000000000,
2.0000000000, 63.0000000000,
12.0000000000, 2.0000000000,
108.0000000000, 12.0000000000,
26.0000000000, 108.0000000000,
1.0000000000, 26.0000000000,
7.0000000000, 1.0000000000,
44.0000000000, 7.0000000000,
25.0000000000, 44.0000000000,
11.0000000000]; 25.0000000000,
11.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 593.0000000000, sum: 593.0000000000,
min: 1.0000000000, min: 1.0000000000,
@ -654,31 +670,33 @@ mod tests {
} }
#[test] #[test]
fn test_binom25() { fn test_binom25() {
let val = &[18.0000000000, let val = &[
17.0000000000, 18.0000000000,
27.0000000000, 17.0000000000,
15.0000000000, 27.0000000000,
21.0000000000, 15.0000000000,
25.0000000000, 21.0000000000,
17.0000000000, 25.0000000000,
24.0000000000, 17.0000000000,
25.0000000000, 24.0000000000,
24.0000000000, 25.0000000000,
26.0000000000, 24.0000000000,
26.0000000000, 26.0000000000,
23.0000000000, 26.0000000000,
15.0000000000, 23.0000000000,
23.0000000000, 15.0000000000,
17.0000000000, 23.0000000000,
18.0000000000, 17.0000000000,
18.0000000000, 18.0000000000,
21.0000000000, 18.0000000000,
16.0000000000, 21.0000000000,
15.0000000000, 16.0000000000,
31.0000000000, 15.0000000000,
20.0000000000, 31.0000000000,
17.0000000000, 20.0000000000,
15.0000000000]; 17.0000000000,
15.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 514.0000000000, sum: 514.0000000000,
min: 15.0000000000, min: 15.0000000000,
@ -697,31 +715,33 @@ mod tests {
} }
#[test] #[test]
fn test_pois25lambda30() { fn test_pois25lambda30() {
let val = &[27.0000000000, let val = &[
33.0000000000, 27.0000000000,
34.0000000000, 33.0000000000,
34.0000000000, 34.0000000000,
24.0000000000, 34.0000000000,
39.0000000000, 24.0000000000,
28.0000000000, 39.0000000000,
27.0000000000, 28.0000000000,
31.0000000000, 27.0000000000,
28.0000000000, 31.0000000000,
38.0000000000, 28.0000000000,
21.0000000000, 38.0000000000,
33.0000000000, 21.0000000000,
36.0000000000, 33.0000000000,
29.0000000000, 36.0000000000,
37.0000000000, 29.0000000000,
32.0000000000, 37.0000000000,
34.0000000000, 32.0000000000,
31.0000000000, 34.0000000000,
39.0000000000, 31.0000000000,
25.0000000000, 39.0000000000,
31.0000000000, 25.0000000000,
32.0000000000, 31.0000000000,
40.0000000000, 32.0000000000,
24.0000000000]; 40.0000000000,
24.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 787.0000000000, sum: 787.0000000000,
min: 21.0000000000, min: 21.0000000000,
@ -740,31 +760,33 @@ mod tests {
} }
#[test] #[test]
fn test_pois25lambda40() { fn test_pois25lambda40() {
let val = &[42.0000000000, let val = &[
50.0000000000, 42.0000000000,
42.0000000000, 50.0000000000,
46.0000000000, 42.0000000000,
34.0000000000, 46.0000000000,
45.0000000000, 34.0000000000,
34.0000000000, 45.0000000000,
49.0000000000, 34.0000000000,
39.0000000000, 49.0000000000,
28.0000000000, 39.0000000000,
40.0000000000, 28.0000000000,
35.0000000000, 40.0000000000,
37.0000000000, 35.0000000000,
39.0000000000, 37.0000000000,
46.0000000000, 39.0000000000,
44.0000000000, 46.0000000000,
32.0000000000, 44.0000000000,
45.0000000000, 32.0000000000,
42.0000000000, 45.0000000000,
37.0000000000, 42.0000000000,
48.0000000000, 37.0000000000,
42.0000000000, 48.0000000000,
33.0000000000, 42.0000000000,
42.0000000000, 33.0000000000,
48.0000000000]; 42.0000000000,
48.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 1019.0000000000, sum: 1019.0000000000,
min: 28.0000000000, min: 28.0000000000,
@ -783,31 +805,33 @@ mod tests {
} }
#[test] #[test]
fn test_pois25lambda50() { fn test_pois25lambda50() {
let val = &[45.0000000000, let val = &[
43.0000000000, 45.0000000000,
44.0000000000, 43.0000000000,
61.0000000000, 44.0000000000,
51.0000000000, 61.0000000000,
53.0000000000, 51.0000000000,
59.0000000000, 53.0000000000,
52.0000000000, 59.0000000000,
49.0000000000, 52.0000000000,
51.0000000000, 49.0000000000,
51.0000000000, 51.0000000000,
50.0000000000, 51.0000000000,
49.0000000000, 50.0000000000,
56.0000000000, 49.0000000000,
42.0000000000, 56.0000000000,
52.0000000000, 42.0000000000,
51.0000000000, 52.0000000000,
43.0000000000, 51.0000000000,
48.0000000000, 43.0000000000,
48.0000000000, 48.0000000000,
50.0000000000, 48.0000000000,
42.0000000000, 50.0000000000,
43.0000000000, 42.0000000000,
42.0000000000, 43.0000000000,
60.0000000000]; 42.0000000000,
60.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 1235.0000000000, sum: 1235.0000000000,
min: 42.0000000000, min: 42.0000000000,
@ -826,31 +850,33 @@ mod tests {
} }
#[test] #[test]
fn test_unif25() { fn test_unif25() {
let val = &[99.0000000000, let val = &[
55.0000000000, 99.0000000000,
92.0000000000, 55.0000000000,
79.0000000000, 92.0000000000,
14.0000000000, 79.0000000000,
2.0000000000, 14.0000000000,
33.0000000000, 2.0000000000,
49.0000000000, 33.0000000000,
3.0000000000, 49.0000000000,
32.0000000000, 3.0000000000,
84.0000000000, 32.0000000000,
59.0000000000, 84.0000000000,
22.0000000000, 59.0000000000,
86.0000000000, 22.0000000000,
76.0000000000, 86.0000000000,
31.0000000000, 76.0000000000,
29.0000000000, 31.0000000000,
11.0000000000, 29.0000000000,
41.0000000000, 11.0000000000,
53.0000000000, 41.0000000000,
45.0000000000, 53.0000000000,
44.0000000000, 45.0000000000,
98.0000000000, 44.0000000000,
98.0000000000, 98.0000000000,
7.0000000000]; 98.0000000000,
7.0000000000,
];
let summ = &Summary { let summ = &Summary {
sum: 1242.0000000000, sum: 1242.0000000000,
min: 2.0000000000, min: 2.0000000000,
@ -885,18 +911,14 @@ mod bench {
#[bench] #[bench]
pub fn sum_three_items(b: &mut Bencher) { pub fn sum_three_items(b: &mut Bencher) {
b.iter(|| { b.iter(|| { [1e20f64, 1.5f64, -1e20f64].sum(); })
[1e20f64, 1.5f64, -1e20f64].sum();
})
} }
#[bench] #[bench]
pub fn sum_many_f64(b: &mut Bencher) { pub fn sum_many_f64(b: &mut Bencher) {
let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60]; let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60];
let v = (0..500).map(|i| nums[i % 5]).collect::<Vec<_>>(); let v = (0..500).map(|i| nums[i % 5]).collect::<Vec<_>>();
b.iter(|| { b.iter(|| { v.sum(); })
v.sum();
})
} }
#[bench] #[bench]

14
src/test/run-make/libtest-json/Makefile Normal file
View file

@ -0,0 +1,14 @@
-include ../tools.mk
# Test expected libtest's JSON output
OUTPUT_FILE := $(TMPDIR)/libtest-json-output.json
all:
$(RUSTC) --test f.rs
$(call RUN,f) -Z unstable-options --test-threads=1 --format=json > $(OUTPUT_FILE) || true
cat $(OUTPUT_FILE) | "$(PYTHON)" validate_json.py
# Compare to output file
diff output.json $(OUTPUT_FILE)

32
src/test/run-make/libtest-json/f.rs Normal file
View file

@ -0,0 +1,32 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[test]
fn a() {
// Should pass
}
#[test]
fn b() {
assert!(false)
}
#[test]
#[should_panic]
fn c() {
assert!(false);
}
#[test]
#[ignore]
fn d() {
assert!(false);
}

10
src/test/run-make/libtest-json/output.json Normal file
View file

@ -0,0 +1,10 @@
{ "type": "suite", "event": "started", "test_count": "4" }
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok" }
{ "type": "test", "event": "started", "name": "b" }
{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'b' panicked at 'assertion failed: false', f.rs:18:5\nnote: Run with `RUST_BACKTRACE=1` for a backtrace.\n" }
{ "type": "test", "event": "started", "name": "c" }
{ "type": "test", "name": "c", "event": "ok" }
{ "type": "test", "event": "started", "name": "d" }
{ "type": "test", "name": "d", "event": "ignored" }
{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "allowed_fail": 0, "ignored": 1, "measured": 0, "filtered_out": "0" }

18
src/test/run-make/libtest-json/validate_json.py Executable file
View file

@ -0,0 +1,18 @@
#!/usr/bin/env python
# Copyright 2016 The Rust Project Developers. See the COPYRIGHT
# file at the top-level directory of this distribution and at
# http://rust-lang.org/COPYRIGHT.
#
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
# option. This file may not be copied, modified, or distributed
# except according to those terms.
import sys
import json
# Try to decode line in order to ensure it is a valid JSON document
for line in sys.stdin:
json.loads(line)

2
src/tools/cargo

@ -1 +1 @@
Subproject commit 91e36aa86c7037de50642f2fec1cf47c3d18af02 Subproject commit 1d6dfea44f97199d5d5c177c7dadcde393eaff9a

2
src/tools/compiletest/src/main.rs
View file

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