OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

libtest: Remove all uses of `~str` from `libtest`.

This commit is contained in:
Patrick Walton 2014-05-13 16:44:05 -07:00
parent 1440e09839
commit 93499b1eaf
6 changed files with 138 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/compiletest/compiletest.rs
View File

@ -152,7 +152,8 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
"(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
!opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
lldb_python_dir: matches.opt_str("lldb-python-dir"),
test_shard: test::opt_shard(matches.opt_str("test-shard")),
test_shard: test::opt_shard(matches.opt_str("test-shard")
.map(|x| x.to_strbuf())),
verbose: matches.opt_present("verbose")
}
}
@ -235,7 +236,10 @@ pub fn run_tests(config: &Config) {
pub fn test_opts(config: &Config) -> test::TestOpts {
test::TestOpts {
filter: config.filter.clone(),
filter: match config.filter {
None => None,
Some(ref filter) => Some(filter.to_strbuf()),
},
run_ignored: config.run_ignored,
logfile: config.logfile.clone(),
run_tests: true,
@ -314,7 +318,9 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
}
test::DynTestName(format!("[{}] {}", config.mode, shorten(testfile)))
test::DynTestName(format_strbuf!("[{}] {}",
config.mode,
shorten(testfile)))
}
pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {

2
src/librustc/front/test.rs
View File

@ -327,7 +327,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
pub fn main() {
#![main]
use std::slice::Vector;
test::test_main_static(::std::os::args().as_slice(), TESTS);
test::test_main_static_x(::std::os::args().as_slice(), TESTS);
}
)).unwrap();

6
src/librustdoc/markdown.rs
View File

@ -176,10 +176,6 @@ pub fn test(input: &str, libs: HashSet<Path>, mut test_args: Vec<StrBuf>) -> int
let mut collector = Collector::new(input.to_strbuf(), libs, true, true);
find_testable_code(input_str.as_slice(), &mut collector);
test_args.unshift("rustdoctest".to_strbuf());
testing::test_main(test_args.move_iter()
.map(|x| x.to_str())
.collect::<Vec<_>>()
.as_slice(),
collector.tests);
testing::test_main(test_args.as_slice(), collector.tests);
0
}

9
src/librustdoc/test.rs
View File

@ -92,10 +92,7 @@ pub fn run(input: &str,
test_args.unshift("rustdoctest".to_strbuf());
testing::test_main(test_args.move_iter()
.map(|x| x.to_str())
.collect::<Vec<_>>()
.as_slice(),
testing::test_main(test_args.as_slice(),
collector.tests.move_iter().collect());
0
}
@ -235,9 +232,9 @@ impl Collector {
pub fn add_test(&mut self, test: StrBuf, should_fail: bool, no_run: bool, should_ignore: bool) {
let name = if self.use_headers {
let s = self.current_header.as_ref().map(|s| s.as_slice()).unwrap_or("");
format!("{}_{}", s, self.cnt)
format_strbuf!("{}_{}", s, self.cnt)
} else {
format!("{}_{}", self.names.connect("::"), self.cnt)
format_strbuf!("{}_{}", self.names.connect("::"), self.cnt)
};
self.cnt += 1;
let libs = self.libs.clone();

195
src/libtest/lib.rs
View File

@ -70,7 +70,7 @@ pub mod test {
MetricChange, Improvement, Regression, LikelyNoise,
StaticTestFn, StaticTestName, DynTestName, DynTestFn,
run_test, test_main, test_main_static, filter_tests,
parse_opts, StaticBenchFn};
parse_opts, StaticBenchFn, test_main_static_x};
}
pub mod stats;
@ -83,7 +83,7 @@ pub mod stats;
#[deriving(Clone)]
pub enum TestName {
StaticTestName(&'static str),
DynTestName(~str)
DynTestName(StrBuf)
}
impl fmt::Show for TestName {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -98,20 +98,20 @@ impl fmt::Show for TestName {
enum NamePadding { PadNone, PadOnLeft, PadOnRight }
impl TestDesc {
fn padded_name(&self, column_count: uint, align: NamePadding) -> ~str {
fn padded_name(&self, column_count: uint, align: NamePadding) -> StrBuf {
use std::num::Saturating;
let mut name = StrBuf::from_str(self.name.to_str());
let fill = column_count.saturating_sub(name.len());
let mut pad = StrBuf::from_owned_str(" ".repeat(fill));
match align {
PadNone => name.into_owned(),
PadNone => name,
PadOnLeft => {
pad.push_str(name.as_slice());
pad.into_owned()
pad
}
PadOnRight => {
name.push_str(pad.as_slice());
name.into_owned()
name
}
}
}
@ -187,7 +187,7 @@ impl Metric {
}
#[deriving(Eq)]
pub struct MetricMap(TreeMap<~str,Metric>);
pub struct MetricMap(TreeMap<StrBuf,Metric>);
impl Clone for MetricMap {
fn clone(&self) -> MetricMap {
@ -206,11 +206,11 @@ pub enum MetricChange {
Regression(f64)
}
pub type MetricDiff = TreeMap<~str,MetricChange>;
pub type MetricDiff = TreeMap<StrBuf,MetricChange>;
// The default console test runner. It accepts the command line
// arguments and a vector of test_descs.
pub fn test_main(args: &[~str], tests: Vec<TestDescAndFn> ) {
pub fn test_main(args: &[StrBuf], tests: Vec<TestDescAndFn> ) {
let opts =
match parse_opts(args) {
Some(Ok(o)) => o,
@ -231,7 +231,7 @@ pub fn test_main(args: &[~str], tests: Vec<TestDescAndFn> ) {
// a ~[TestDescAndFn] is used in order to effect ownership-transfer
// semantics into parallel test runners, which in turn requires a ~[]
// rather than a &[].
pub fn test_main_static(args: &[~str], tests: &[TestDescAndFn]) {
pub fn test_main_static(args: &[StrBuf], tests: &[TestDescAndFn]) {
let owned_tests = tests.iter().map(|t| {
match t.testfn {
StaticTestFn(f) =>
@ -248,8 +248,16 @@ pub fn test_main_static(args: &[~str], tests: &[TestDescAndFn]) {
test_main(args, owned_tests)
}
pub fn test_main_static_x(args: &[~str], tests: &[TestDescAndFn]) {
test_main_static(args.iter()
.map(|x| x.to_strbuf())
.collect::<Vec<_>>()
.as_slice(),
tests)
}
pub struct TestOpts {
pub filter: Option<~str>,
pub filter: Option<StrBuf>,
pub run_ignored: bool,
pub run_tests: bool,
pub run_benchmarks: bool,
@ -280,7 +288,7 @@ impl TestOpts {
}
/// Result of parsing the options.
pub type OptRes = Result<TestOpts, ~str>;
pub type OptRes = Result<TestOpts, StrBuf>;
fn optgroups() -> Vec<getopts::OptGroup> {
vec!(getopts::optflag("", "ignored", "Run ignored tests"),
@ -337,20 +345,30 @@ Test Attributes:
}
// Parses command line arguments into test options
pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
pub fn parse_opts(args: &[StrBuf]) -> Option<OptRes> {
let args_ = args.tail();
let matches =
match getopts::getopts(args_, optgroups().as_slice()) {
match getopts::getopts(args_.iter()
.map(|x| x.to_owned())
.collect::<Vec<_>>()
.as_slice(),
optgroups().as_slice()) {
Ok(m) => m,
Err(f) => return Some(Err(f.to_err_msg()))
Err(f) => return Some(Err(f.to_err_msg().to_strbuf()))
};
if matches.opt_present("h") { usage(args[0], "h"); return None; }
if matches.opt_present("help") { usage(args[0], "help"); return None; }
if matches.opt_present("h") {
usage(args[0].as_slice(), "h");
return None;
}
if matches.opt_present("help") {
usage(args[0].as_slice(), "help");
return None;
}
let filter =
if matches.free.len() > 0 {
Some((*matches.free.get(0)).clone())
Some((*matches.free.get(0)).to_strbuf())
} else {
None
};
@ -374,7 +392,7 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
let save_metrics = save_metrics.map(|s| Path::new(s));
let test_shard = matches.opt_str("test-shard");
let test_shard = opt_shard(test_shard);
let test_shard = opt_shard(test_shard.map(|x| x.to_strbuf()));
let mut nocapture = matches.opt_present("nocapture");
if !nocapture {
@ -397,11 +415,11 @@ pub fn parse_opts(args: &[~str]) -> Option<OptRes> {
Some(Ok(test_opts))
}
pub fn opt_shard(maybestr: Option<~str>) -> Option<(uint,uint)> {
pub fn opt_shard(maybestr: Option<StrBuf>) -> Option<(uint,uint)> {
match maybestr {
None => None,
Some(s) => {
let mut it = s.split('.');
let mut it = s.as_slice().split('.');
match (it.next().and_then(from_str), it.next().and_then(from_str), it.next()) {
(Some(a), Some(b), None) => Some((a, b)),
_ => None,
@ -567,9 +585,9 @@ impl<T: Writer> ConsoleTestState<T> {
None => Ok(()),
Some(ref mut o) => {
let s = format!("{} {}\n", match *result {
TrOk => "ok".to_owned(),
TrFailed => "failed".to_owned(),
TrIgnored => "ignored".to_owned(),
TrOk => "ok".to_strbuf(),
TrFailed => "failed".to_strbuf(),
TrIgnored => "ignored".to_strbuf(),
TrMetrics(ref mm) => fmt_metrics(mm),
TrBench(ref bs) => fmt_bench_samples(bs)
}, test.name.to_str());
@ -696,25 +714,25 @@ impl<T: Writer> ConsoleTestState<T> {
}
}
pub fn fmt_metrics(mm: &MetricMap) -> ~str {
pub fn fmt_metrics(mm: &MetricMap) -> StrBuf {
let MetricMap(ref mm) = *mm;
let v : Vec<~str> = mm.iter()
.map(|(k,v)| format!("{}: {} (+/- {})",
let v : Vec<StrBuf> = mm.iter()
.map(|(k,v)| format_strbuf!("{}: {} (+/- {})",
*k,
v.value as f64,
v.noise as f64))
.collect();
v.connect(", ")
v.connect(", ").to_strbuf()
}
pub fn fmt_bench_samples(bs: &BenchSamples) -> ~str {
pub fn fmt_bench_samples(bs: &BenchSamples) -> StrBuf {
if bs.mb_s != 0 {
format!("{:>9} ns/iter (+/- {}) = {} MB/s",
format_strbuf!("{:>9} ns/iter (+/- {}) = {} MB/s",
bs.ns_iter_summ.median as uint,
(bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint,
bs.mb_s)
} else {
format!("{:>9} ns/iter (+/- {})",
format_strbuf!("{:>9} ns/iter (+/- {})",
bs.ns_iter_summ.median as uint,
(bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint)
}
@ -738,8 +756,10 @@ pub fn run_tests_console(opts: &TestOpts,
let tname = test.name.to_str();
let MetricMap(mm) = mm;
for (k,v) in mm.iter() {
st.metrics.insert_metric(tname + "." + *k,
v.value, v.noise);
st.metrics
.insert_metric(tname + "." + k.as_slice(),
v.value,
v.noise);
}
st.measured += 1
}
@ -924,7 +944,7 @@ pub fn filter_tests(
} else {
let filter_str = match opts.filter {
Some(ref f) => (*f).clone(),
None => "".to_owned()
None => "".to_strbuf()
};
fn filter_fn(test: TestDescAndFn, filter_str: &str) ->
@ -936,7 +956,9 @@ pub fn filter_tests(
}
}
filtered.move_iter().filter_map(|x| filter_fn(x, filter_str)).collect()
filtered.move_iter()
.filter_map(|x| filter_fn(x, filter_str.as_slice()))
.collect()
};
// Maybe pull out the ignored test and unignore them
@ -995,8 +1017,8 @@ pub fn run_test(opts: &TestOpts,
let stdout = ChanWriter::new(tx.clone());
let stderr = ChanWriter::new(tx);
let mut task = TaskBuilder::new().named(match desc.name {
DynTestName(ref name) => name.clone().into_maybe_owned(),
StaticTestName(name) => name.into_maybe_owned(),
DynTestName(ref name) => name.clone().to_owned(),
StaticTestName(name) => name.to_owned(),
});
if nocapture {
drop((stdout, stderr));
@ -1091,7 +1113,14 @@ impl MetricMap {
pub fn save(&self, p: &Path) -> io::IoResult<()> {
let mut file = try!(File::create(p));
let MetricMap(ref map) = *self;
map.to_json().to_pretty_writer(&mut file)
// FIXME(pcwalton): Yuck.
let mut new_map = TreeMap::new();
for (ref key, ref value) in map.iter() {
new_map.insert(key.to_owned(), (*value).clone());
}
new_map.to_json().to_pretty_writer(&mut file)
}
/// Compare against another MetricMap. Optionally compare all
@ -1170,7 +1199,7 @@ impl MetricMap {
noise: noise
};
let MetricMap(ref mut map) = *self;
map.insert(name.to_owned(), m);
map.insert(name.to_strbuf(), m);
}
/// Attempt to "ratchet" an external metric file. This involves loading
@ -1416,17 +1445,19 @@ mod tests {
#[test]
fn first_free_arg_should_be_a_filter() {
let args = vec!("progname".to_owned(), "filter".to_owned());
let args = vec!("progname".to_strbuf(), "filter".to_strbuf());
let opts = match parse_opts(args.as_slice()) {
Some(Ok(o)) => o,
_ => fail!("Malformed arg in first_free_arg_should_be_a_filter")
};
assert!("filter" == opts.filter.clone().unwrap());
assert!("filter" == opts.filter.clone().unwrap().as_slice());
}
#[test]
fn parse_ignored_flag() {
let args = vec!("progname".to_owned(), "filter".to_owned(), "--ignored".to_owned());
let args = vec!("progname".to_strbuf(),
"filter".to_strbuf(),
"--ignored".to_strbuf());
let opts = match parse_opts(args.as_slice()) {
Some(Ok(o)) => o,
_ => fail!("Malformed arg in parse_ignored_flag")
@ -1463,7 +1494,8 @@ mod tests {
let filtered = filter_tests(&opts, tests);
assert_eq!(filtered.len(), 1);
assert_eq!(filtered.get(0).desc.name.to_str(), "1".to_owned());
assert_eq!(filtered.get(0).desc.name.to_str().to_strbuf(),
"1".to_strbuf());
assert!(filtered.get(0).desc.ignore == false);
}
@ -1473,12 +1505,15 @@ mod tests {
opts.run_tests = true;
let names =
vec!("sha1::test".to_owned(), "int::test_to_str".to_owned(), "int::test_pow".to_owned(),
"test::do_not_run_ignored_tests".to_owned(),
"test::ignored_tests_result_in_ignored".to_owned(),
"test::first_free_arg_should_be_a_filter".to_owned(),
"test::parse_ignored_flag".to_owned(), "test::filter_for_ignored_option".to_owned(),
"test::sort_tests".to_owned());
vec!("sha1::test".to_strbuf(),
"int::test_to_str".to_strbuf(),
"int::test_pow".to_strbuf(),
"test::do_not_run_ignored_tests".to_strbuf(),
"test::ignored_tests_result_in_ignored".to_strbuf(),
"test::first_free_arg_should_be_a_filter".to_strbuf(),
"test::parse_ignored_flag".to_strbuf(),
"test::filter_for_ignored_option".to_strbuf(),
"test::sort_tests".to_strbuf());
let tests =
{
fn testfn() { }
@ -1499,16 +1534,18 @@ mod tests {
let filtered = filter_tests(&opts, tests);
let expected =
vec!("int::test_pow".to_owned(), "int::test_to_str".to_owned(), "sha1::test".to_owned(),
"test::do_not_run_ignored_tests".to_owned(),
"test::filter_for_ignored_option".to_owned(),
"test::first_free_arg_should_be_a_filter".to_owned(),
"test::ignored_tests_result_in_ignored".to_owned(),
"test::parse_ignored_flag".to_owned(),
"test::sort_tests".to_owned());
vec!("int::test_pow".to_strbuf(),
"int::test_to_str".to_strbuf(),
"sha1::test".to_strbuf(),
"test::do_not_run_ignored_tests".to_strbuf(),
"test::filter_for_ignored_option".to_strbuf(),
"test::first_free_arg_should_be_a_filter".to_strbuf(),
"test::ignored_tests_result_in_ignored".to_strbuf(),
"test::parse_ignored_flag".to_strbuf(),
"test::sort_tests".to_strbuf());
for (a, b) in expected.iter().zip(filtered.iter()) {
assert!(*a == b.desc.name.to_str());
assert!(*a == b.desc.name.to_str().to_strbuf());
}
}
@ -1536,31 +1573,31 @@ mod tests {
let diff1 = m2.compare_to_old(&m1, None);
assert_eq!(*(diff1.find(&"in-both-noise".to_owned()).unwrap()), LikelyNoise);
assert_eq!(*(diff1.find(&"in-first-noise".to_owned()).unwrap()), MetricRemoved);
assert_eq!(*(diff1.find(&"in-second-noise".to_owned()).unwrap()), MetricAdded);
assert_eq!(*(diff1.find(&"in-both-want-downwards-but-regressed".to_owned()).unwrap()),
assert_eq!(*(diff1.find(&"in-both-noise".to_strbuf()).unwrap()), LikelyNoise);
assert_eq!(*(diff1.find(&"in-first-noise".to_strbuf()).unwrap()), MetricRemoved);
assert_eq!(*(diff1.find(&"in-second-noise".to_strbuf()).unwrap()), MetricAdded);
assert_eq!(*(diff1.find(&"in-both-want-downwards-but-regressed".to_strbuf()).unwrap()),
Regression(100.0));
assert_eq!(*(diff1.find(&"in-both-want-downwards-and-improved".to_owned()).unwrap()),
assert_eq!(*(diff1.find(&"in-both-want-downwards-and-improved".to_strbuf()).unwrap()),
Improvement(50.0));
assert_eq!(*(diff1.find(&"in-both-want-upwards-but-regressed".to_owned()).unwrap()),
assert_eq!(*(diff1.find(&"in-both-want-upwards-but-regressed".to_strbuf()).unwrap()),
Regression(50.0));
assert_eq!(*(diff1.find(&"in-both-want-upwards-and-improved".to_owned()).unwrap()),
assert_eq!(*(diff1.find(&"in-both-want-upwards-and-improved".to_strbuf()).unwrap()),
Improvement(100.0));
assert_eq!(diff1.len(), 7);
let diff2 = m2.compare_to_old(&m1, Some(200.0));
assert_eq!(*(diff2.find(&"in-both-noise".to_owned()).unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&"in-first-noise".to_owned()).unwrap()), MetricRemoved);
assert_eq!(*(diff2.find(&"in-second-noise".to_owned()).unwrap()), MetricAdded);
assert_eq!(*(diff2.find(&"in-both-want-downwards-but-regressed".to_owned()).unwrap()),
assert_eq!(*(diff2.find(&"in-both-noise".to_strbuf()).unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&"in-first-noise".to_strbuf()).unwrap()), MetricRemoved);
assert_eq!(*(diff2.find(&"in-second-noise".to_strbuf()).unwrap()), MetricAdded);
assert_eq!(*(diff2.find(&"in-both-want-downwards-but-regressed".to_strbuf()).unwrap()),
LikelyNoise);
assert_eq!(*(diff2.find(&"in-both-want-downwards-and-improved".to_owned()).unwrap()),
assert_eq!(*(diff2.find(&"in-both-want-downwards-and-improved".to_strbuf()).unwrap()),
LikelyNoise);
assert_eq!(*(diff2.find(&"in-both-want-upwards-but-regressed".to_owned()).unwrap()),
assert_eq!(*(diff2.find(&"in-both-want-upwards-but-regressed".to_strbuf()).unwrap()),
LikelyNoise);
assert_eq!(*(diff2.find(&"in-both-want-upwards-and-improved".to_owned()).unwrap()),
assert_eq!(*(diff2.find(&"in-both-want-upwards-and-improved".to_strbuf()).unwrap()),
LikelyNoise);
assert_eq!(diff2.len(), 7);
}
@ -1585,29 +1622,29 @@ mod tests {
let (diff1, ok1) = m2.ratchet(&pth, None);
assert_eq!(ok1, false);
assert_eq!(diff1.len(), 2);
assert_eq!(*(diff1.find(&"runtime".to_owned()).unwrap()), Regression(10.0));
assert_eq!(*(diff1.find(&"throughput".to_owned()).unwrap()), LikelyNoise);
assert_eq!(*(diff1.find(&"runtime".to_strbuf()).unwrap()), Regression(10.0));
assert_eq!(*(diff1.find(&"throughput".to_strbuf()).unwrap()), LikelyNoise);
// Check that it was not rewritten.
let m3 = MetricMap::load(&pth);
let MetricMap(m3) = m3;
assert_eq!(m3.len(), 2);
assert_eq!(*(m3.find(&"runtime".to_owned()).unwrap()), Metric::new(1000.0, 2.0));
assert_eq!(*(m3.find(&"throughput".to_owned()).unwrap()), Metric::new(50.0, 2.0));
assert_eq!(*(m3.find(&"runtime".to_strbuf()).unwrap()), Metric::new(1000.0, 2.0));
assert_eq!(*(m3.find(&"throughput".to_strbuf()).unwrap()), Metric::new(50.0, 2.0));
// Ask for a ratchet with an explicit noise-percentage override,
// that should advance.
let (diff2, ok2) = m2.ratchet(&pth, Some(10.0));
assert_eq!(ok2, true);
assert_eq!(diff2.len(), 2);
assert_eq!(*(diff2.find(&"runtime".to_owned()).unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&"throughput".to_owned()).unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&"runtime".to_strbuf()).unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&"throughput".to_strbuf()).unwrap()), LikelyNoise);
// Check that it was rewritten.
let m4 = MetricMap::load(&pth);
let MetricMap(m4) = m4;
assert_eq!(m4.len(), 2);
assert_eq!(*(m4.find(&"runtime".to_owned()).unwrap()), Metric::new(1100.0, 2.0));
assert_eq!(*(m4.find(&"throughput".to_owned()).unwrap()), Metric::new(50.0, 2.0));
assert_eq!(*(m4.find(&"runtime".to_strbuf()).unwrap()), Metric::new(1100.0, 2.0));
assert_eq!(*(m4.find(&"throughput".to_strbuf()).unwrap()), Metric::new(50.0, 2.0));
}
}

13
src/libtest/stats.rs
View File

@ -1028,17 +1028,20 @@ mod tests {
#[test]
fn test_boxplot_nonpositive() {
#[allow(deprecated_owned_vector)]
fn t(s: &Summary<f64>, expected: ~str) {
fn t(s: &Summary<f64>, expected: StrBuf) {
use std::io::MemWriter;
let mut m = MemWriter::new();
write_boxplot(&mut m as &mut io::Writer, s, 30).unwrap();
let out = str::from_utf8(m.unwrap().as_slice()).unwrap().to_owned();
let out = str::from_utf8(m.unwrap().as_slice()).unwrap().to_strbuf();
assert_eq!(out, expected);
}
t(&Summary::new([-2.0, -1.0]), "-2 |[------******#*****---]| -1".to_owned());
t(&Summary::new([0.0, 2.0]), "0 |[-------*****#*******---]| 2".to_owned());
t(&Summary::new([-2.0, 0.0]), "-2 |[------******#******---]| 0".to_owned());
t(&Summary::new([-2.0, -1.0]),
"-2 |[------******#*****---]| -1".to_strbuf());
t(&Summary::new([0.0, 2.0]),
"0 |[-------*****#*******---]| 2".to_strbuf());
t(&Summary::new([-2.0, 0.0]),
"-2 |[------******#******---]| 0".to_strbuf());
}
#[test]