From 2acfa838a09d5d142dc691802d7f001195fea0ec Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Tue, 19 Jan 2016 14:55:13 +1300 Subject: [PATCH] rustfmt libtest --- src/libtest/lib.rs | 507 +++++++++++++++++++++------------------ src/libtest/stats.rs | 553 ++++++++++++++++++++----------------------- 2 files changed, 538 insertions(+), 522 deletions(-) diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index 00c9d30c563..b51c2c2824d 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -77,12 +77,10 @@ use std::time::{Instant, Duration}; // to be used by rustc to compile tests in libtest pub mod test { - pub use {Bencher, TestName, TestResult, TestDesc, - TestDescAndFn, TestOpts, TrFailed, TrIgnored, TrOk, - Metric, MetricMap, - StaticTestFn, StaticTestName, DynTestName, DynTestFn, - run_test, test_main, test_main_static, filter_tests, - parse_opts, StaticBenchFn, ShouldPanic}; + pub use {Bencher, TestName, TestResult, TestDesc, TestDescAndFn, TestOpts, TrFailed, + TrIgnored, TrOk, Metric, MetricMap, StaticTestFn, StaticTestName, DynTestName, + DynTestFn, run_test, test_main, test_main_static, filter_tests, parse_opts, + StaticBenchFn, ShouldPanic}; } pub mod stats; @@ -95,13 +93,13 @@ pub mod stats; #[derive(Clone, PartialEq, Eq, Hash, Debug)] pub enum TestName { StaticTestName(&'static str), - DynTestName(String) + DynTestName(String), } impl TestName { fn as_slice(&self) -> &str { match *self { StaticTestName(s) => s, - DynTestName(ref s) => s + DynTestName(ref s) => s, } } } @@ -146,19 +144,19 @@ pub enum TestFn { StaticBenchFn(fn(&mut Bencher)), StaticMetricFn(fn(&mut MetricMap)), DynTestFn(Box), - DynMetricFn(Box), - DynBenchFn(Box) + DynMetricFn(Box), + DynBenchFn(Box), } impl TestFn { fn padding(&self) -> NamePadding { match *self { - StaticTestFn(..) => PadNone, - StaticBenchFn(..) => PadOnRight, + StaticTestFn(..) => PadNone, + StaticBenchFn(..) => PadOnRight, StaticMetricFn(..) => PadOnRight, - DynTestFn(..) => PadNone, - DynMetricFn(..) => PadOnRight, - DynBenchFn(..) => PadOnRight, + DynTestFn(..) => PadNone, + DynMetricFn(..) => PadOnRight, + DynBenchFn(..) => PadOnRight, } } } @@ -171,7 +169,7 @@ impl fmt::Debug for TestFn { StaticMetricFn(..) => "StaticMetricFn(..)", DynTestFn(..) => "DynTestFn(..)", DynMetricFn(..) => "DynMetricFn(..)", - DynBenchFn(..) => "DynBenchFn(..)" + DynBenchFn(..) => "DynBenchFn(..)", }) } } @@ -192,7 +190,7 @@ pub struct Bencher { pub enum ShouldPanic { No, Yes, - YesWithMessage(&'static str) + YesWithMessage(&'static str), } // The definition of a single test. A test runner will run a list of @@ -215,17 +213,20 @@ pub struct TestDescAndFn { #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug, Copy)] pub struct Metric { value: f64, - noise: f64 + noise: f64, } impl Metric { pub fn new(value: f64, noise: f64) -> Metric { - Metric {value: value, noise: noise} + Metric { + value: value, + noise: noise, + } } } #[derive(PartialEq)] -pub struct MetricMap(BTreeMap); +pub struct MetricMap(BTreeMap); impl Clone for MetricMap { fn clone(&self) -> MetricMap { @@ -236,13 +237,12 @@ impl Clone for MetricMap { // The default console test runner. It accepts the command line // arguments and a vector of test_descs. -pub fn test_main(args: &[String], tests: Vec ) { - let opts = - match parse_opts(args) { - Some(Ok(o)) => o, - Some(Err(msg)) => panic!("{:?}", msg), - None => return - }; +pub fn test_main(args: &[String], tests: Vec) { + let opts = match parse_opts(args) { + Some(Ok(o)) => o, + Some(Err(msg)) => panic!("{:?}", msg), + None => return, + }; match run_tests_console(&opts, tests) { Ok(true) => {} Ok(false) => std::process::exit(101), @@ -259,13 +259,25 @@ pub fn test_main(args: &[String], tests: Vec ) { // rather than a &[]. pub fn test_main_static(tests: &[TestDescAndFn]) { let args = env::args().collect::>(); - let owned_tests = tests.iter().map(|t| { - match t.testfn { - StaticTestFn(f) => TestDescAndFn { testfn: StaticTestFn(f), desc: t.desc.clone() }, - StaticBenchFn(f) => TestDescAndFn { testfn: StaticBenchFn(f), desc: t.desc.clone() }, - _ => panic!("non-static tests passed to test::test_main_static") - } - }).collect(); + let owned_tests = tests.iter() + .map(|t| { + match t.testfn { + StaticTestFn(f) => { + TestDescAndFn { + testfn: StaticTestFn(f), + desc: t.desc.clone(), + } + } + StaticBenchFn(f) => { + TestDescAndFn { + testfn: StaticBenchFn(f), + desc: t.desc.clone(), + } + } + _ => panic!("non-static tests passed to test::test_main_static"), + } + }) + .collect(); test_main(&args, owned_tests) } @@ -305,18 +317,26 @@ impl TestOpts { pub type OptRes = Result; fn optgroups() -> Vec { - vec!(getopts::optflag("", "ignored", "Run ignored tests"), - getopts::optflag("", "test", "Run tests and not benchmarks"), - getopts::optflag("", "bench", "Run benchmarks instead of tests"), - getopts::optflag("h", "help", "Display this message (longer with --help)"), - getopts::optopt("", "logfile", "Write logs to the specified file instead \ - of stdout", "PATH"), - getopts::optflag("", "nocapture", "don't capture stdout/stderr of each \ - task, allow printing directly"), - getopts::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")) + vec![getopts::optflag("", "ignored", "Run ignored tests"), + getopts::optflag("", "test", "Run tests and not benchmarks"), + getopts::optflag("", "bench", "Run benchmarks instead of tests"), + getopts::optflag("h", "help", "Display this message (longer with --help)"), + getopts::optopt("", + "logfile", + "Write logs to the specified file instead of stdout", + "PATH"), + getopts::optflag("", + "nocapture", + "don't capture stdout/stderr of each task, allow printing directly"), + getopts::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")] } fn usage(binary: &str) { @@ -353,13 +373,15 @@ Test Attributes: // Parses command line arguments into test options pub fn parse_opts(args: &[String]) -> Option { let args_ = &args[1..]; - let matches = - match getopts::getopts(args_, &optgroups()) { - Ok(m) => m, - Err(f) => return Some(Err(f.to_string())) - }; + let matches = match getopts::getopts(args_, &optgroups()) { + Ok(m) => m, + Err(f) => return Some(Err(f.to_string())), + }; - if matches.opt_present("h") { usage(&args[0]); return None; } + if matches.opt_present("h") { + usage(&args[0]); + return None; + } let filter = if !matches.free.is_empty() { Some(matches.free[0].clone()) @@ -373,8 +395,7 @@ pub fn parse_opts(args: &[String]) -> Option { let logfile = logfile.map(|s| PathBuf::from(&s)); let bench_benchmarks = matches.opt_present("bench"); - let run_tests = ! bench_benchmarks || - matches.opt_present("test"); + let run_tests = !bench_benchmarks || matches.opt_present("test"); let mut nocapture = matches.opt_present("nocapture"); if !nocapture { @@ -386,9 +407,11 @@ pub fn parse_opts(args: &[String]) -> Option { Some("always") => AlwaysColor, Some("never") => NeverColor, - Some(v) => return Some(Err(format!("argument for --color must be \ - auto, always, or never (was {})", - v))), + Some(v) => { + return Some(Err(format!("argument for --color must be auto, always, or never (was \ + {})", + v))) + } }; let test_opts = TestOpts { @@ -436,20 +459,19 @@ struct ConsoleTestState { ignored: usize, measured: usize, metrics: MetricMap, - failures: Vec<(TestDesc, Vec )> , + failures: Vec<(TestDesc, Vec)>, max_name_len: usize, // number of columns to fill when aligning names } impl ConsoleTestState { - pub fn new(opts: &TestOpts, - _: Option) -> io::Result> { + pub fn new(opts: &TestOpts, _: Option) -> io::Result> { let log_out = match opts.logfile { Some(ref path) => Some(try!(File::create(path))), - None => None + None => None, }; let out = match term::stdout() { None => Raw(io::stdout()), - Some(t) => Pretty(t) + Some(t) => Pretty(t), }; Ok(ConsoleTestState { @@ -487,9 +509,7 @@ impl ConsoleTestState { self.write_pretty("bench", term::color::CYAN) } - pub fn write_pretty(&mut self, - word: &str, - color: term::color::Color) -> io::Result<()> { + 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 { @@ -513,22 +533,25 @@ impl ConsoleTestState { Pretty(ref mut term) => { try!(term.write_all(s.as_bytes())); term.flush() - }, + } Raw(ref mut stdout) => { try!(stdout.write_all(s.as_bytes())); stdout.flush() - }, + } } } pub fn write_run_start(&mut self, len: usize) -> io::Result<()> { self.total = len; - let noun = if len != 1 { "tests" } else { "test" }; + let noun = if len != 1 { + "tests" + } else { + "test" + }; self.write_plain(&format!("\nrunning {} {}\n", len, noun)) } - pub fn write_test_start(&mut self, test: &TestDesc, - align: NamePadding) -> io::Result<()> { + pub fn write_test_start(&mut self, test: &TestDesc, align: NamePadding) -> io::Result<()> { let name = test.padded_name(self.max_name_len, align); self.write_plain(&format!("test {} ... ", name)) } @@ -553,18 +576,19 @@ impl ConsoleTestState { self.write_plain("\n") } - pub fn write_log(&mut self, test: &TestDesc, - result: &TestResult) -> io::Result<()> { + pub fn write_log(&mut self, test: &TestDesc, result: &TestResult) -> io::Result<()> { match self.log_out { None => Ok(()), Some(ref mut o) => { - let s = format!("{} {}\n", match *result { - TrOk => "ok".to_owned(), - TrFailed => "failed".to_owned(), - TrIgnored => "ignored".to_owned(), - TrMetrics(ref mm) => mm.fmt_metrics(), - TrBench(ref bs) => fmt_bench_samples(bs) - }, test.name); + let s = format!("{} {}\n", + match *result { + TrOk => "ok".to_owned(), + TrFailed => "failed".to_owned(), + TrIgnored => "ignored".to_owned(), + TrMetrics(ref mm) => mm.fmt_metrics(), + TrBench(ref bs) => fmt_bench_samples(bs), + }, + test.name); o.write_all(s.as_bytes()) } } @@ -612,7 +636,10 @@ impl ConsoleTestState { try!(self.write_failed()); } let s = format!(". {} passed; {} failed; {} ignored; {} measured\n\n", - self.passed, self.failed, self.ignored, self.measured); + self.passed, + self.failed, + self.ignored, + self.measured); try!(self.write_plain(&s)); return Ok(success); } @@ -650,8 +677,9 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> String { let deviation = (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as usize; output.write_fmt(format_args!("{:>11} ns/iter (+/- {})", - fmt_thousands_sep(median, ','), - fmt_thousands_sep(deviation, ','))).unwrap(); + fmt_thousands_sep(median, ','), + fmt_thousands_sep(deviation, ','))) + .unwrap(); if bs.mb_s != 0 { output.write_fmt(format_args!(" = {} MB/s", bs.mb_s)).unwrap(); } @@ -659,10 +687,9 @@ pub fn fmt_bench_samples(bs: &BenchSamples) -> String { } // A simple console test runner -pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::Result { +pub fn run_tests_console(opts: &TestOpts, tests: Vec) -> io::Result { - fn callback(event: &TestEvent, - st: &mut ConsoleTestState) -> io::Result<()> { + fn callback(event: &TestEvent, st: &mut ConsoleTestState) -> io::Result<()> { match (*event).clone() { TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()), TeWait(ref test, padding) => st.write_test_start(test, padding), @@ -675,13 +702,9 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::Res TrMetrics(mm) => { let tname = test.name; let MetricMap(mm) = mm; - for (k,v) in &mm { + for (k, v) in &mm { st.metrics - .insert_metric(&format!("{}.{}", - tname, - k), - v.value, - v.noise); + .insert_metric(&format!("{}.{}", tname, k), v.value, v.noise); } st.measured += 1 } @@ -708,11 +731,11 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec ) -> io::Res PadOnRight => t.desc.name.as_slice().len(), } } - match tests.iter().max_by_key(|t|len_if_padded(*t)) { + match tests.iter().max_by_key(|t| len_if_padded(*t)) { Some(t) => { let n = t.desc.name.as_slice(); st.max_name_len = n.len(); - }, + } None => {} } try!(run_tests(opts, tests, |x| callback(&x, &mut st))); @@ -724,13 +747,13 @@ fn should_sort_failures_before_printing_them() { let test_a = TestDesc { name: StaticTestName("a"), ignore: false, - should_panic: ShouldPanic::No + should_panic: ShouldPanic::No, }; let test_b = TestDesc { name: StaticTestName("b"), ignore: false, - should_panic: ShouldPanic::No + should_panic: ShouldPanic::No, }; let mut st = ConsoleTestState { @@ -744,13 +767,13 @@ fn should_sort_failures_before_printing_them() { measured: 0, max_name_len: 10, metrics: MetricMap::new(), - failures: vec!((test_b, Vec::new()), (test_a, Vec::new())) + failures: vec![(test_b, Vec::new()), (test_a, Vec::new())], }; st.write_failures().unwrap(); let s = match st.out { Raw(ref m) => String::from_utf8_lossy(&m[..]), - Pretty(_) => unreachable!() + Pretty(_) => unreachable!(), }; let apos = s.find("a").unwrap(); @@ -790,18 +813,16 @@ fn stdout_isatty() -> bool { #[derive(Clone)] enum TestEvent { - TeFiltered(Vec ), + TeFiltered(Vec), TeWait(TestDesc, NamePadding), - TeResult(TestDesc, TestResult, Vec ), + TeResult(TestDesc, TestResult, Vec), } -pub type MonitorMsg = (TestDesc, TestResult, Vec ); +pub type MonitorMsg = (TestDesc, TestResult, Vec); -fn run_tests(opts: &TestOpts, - tests: Vec , - mut callback: F) -> io::Result<()> where - F: FnMut(TestEvent) -> io::Result<()>, +fn run_tests(opts: &TestOpts, tests: Vec, mut callback: F) -> io::Result<()> + where F: FnMut(TestEvent) -> io::Result<()> { let mut filtered_tests = filter_tests(opts, tests); if !opts.bench_benchmarks { @@ -818,7 +839,7 @@ fn run_tests(opts: &TestOpts, filtered_tests.into_iter().partition(|e| { match e.testfn { StaticTestFn(_) | DynTestFn(_) => true, - _ => false + _ => false, } }); @@ -873,7 +894,10 @@ fn get_concurrency() -> usize { let opt_n: Option = s.parse().ok(); match opt_n { Some(n) if n > 0 => n, - _ => panic!("RUST_TEST_THREADS is `{}`, should be a positive integer.", s) + _ => { + panic!("RUST_TEST_THREADS is `{}`, should be a positive integer.", + s) + } } } Err(..) => num_cpus(), @@ -911,9 +935,7 @@ fn get_concurrency() -> usize { target_os = "ios", target_os = "android"))] fn num_cpus() -> usize { - unsafe { - libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize - } + unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) as usize } } #[cfg(any(target_os = "freebsd", @@ -926,18 +948,22 @@ fn get_concurrency() -> usize { let mut mib = [libc::CTL_HW, libc::HW_AVAILCPU, 0, 0]; unsafe { - libc::sysctl(mib.as_mut_ptr(), 2, + libc::sysctl(mib.as_mut_ptr(), + 2, &mut cpus as *mut _ as *mut _, &mut cpus_size as *mut _ as *mut _, - 0 as *mut _, 0); + 0 as *mut _, + 0); } if cpus < 1 { mib[1] = libc::HW_NCPU; unsafe { - libc::sysctl(mib.as_mut_ptr(), 2, + libc::sysctl(mib.as_mut_ptr(), + 2, &mut cpus as *mut _ as *mut _, &mut cpus_size as *mut _ as *mut _, - 0 as *mut _, 0); + 0 as *mut _, + 0); } if cpus < 1 { cpus = 1; @@ -953,10 +979,12 @@ fn get_concurrency() -> usize { let mut mib = [libc::CTL_HW, libc::HW_NCPU, 0, 0]; unsafe { - libc::sysctl(mib.as_mut_ptr(), 2, + libc::sysctl(mib.as_mut_ptr(), + 2, &mut cpus as *mut _ as *mut _, &mut cpus_size as *mut _ as *mut _, - 0 as *mut _, 0); + 0 as *mut _, + 0); } if cpus < 1 { cpus = 1; @@ -972,9 +1000,9 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec) -> Vec filtered, Some(ref filter) => { - filtered.into_iter().filter(|test| { - test.desc.name.as_slice().contains(&filter[..]) - }).collect() + filtered.into_iter() + .filter(|test| test.desc.name.as_slice().contains(&filter[..])) + .collect() } }; @@ -986,8 +1014,8 @@ pub fn filter_tests(opts: &TestOpts, tests: Vec) -> Vec) -> Vec) -> Vec { // convert benchmarks to tests, if we're not benchmarking them - tests.into_iter().map(|x| { - let testfn = match x.testfn { - DynBenchFn(bench) => { - DynTestFn(Box::new(move || bench::run_once(|b| bench.run(b)))) - } - StaticBenchFn(benchfn) => { - DynTestFn(Box::new(move || bench::run_once(|b| benchfn(b)))) - } - f => f - }; - TestDescAndFn { desc: x.desc, testfn: testfn } - }).collect() + tests.into_iter() + .map(|x| { + let testfn = match x.testfn { + DynBenchFn(bench) => { + DynTestFn(Box::new(move || bench::run_once(|b| bench.run(b)))) + } + StaticBenchFn(benchfn) => { + DynTestFn(Box::new(move || bench::run_once(|b| benchfn(b)))) + } + f => f, + }; + TestDescAndFn { + desc: x.desc, + testfn: testfn, + } + }) + .collect() } pub fn run_test(opts: &TestOpts, @@ -1039,7 +1072,9 @@ pub fn run_test(opts: &TestOpts, fn write(&mut self, data: &[u8]) -> io::Result { Write::write(&mut *self.0.lock().unwrap(), data) } - fn flush(&mut self) -> io::Result<()> { Ok(()) } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } } thread::spawn(move || { @@ -1051,12 +1086,13 @@ pub fn run_test(opts: &TestOpts, }); let result_guard = cfg.spawn(move || { - if !nocapture { - io::set_print(box Sink(data2.clone())); - io::set_panic(box Sink(data2)); - } - testfn() - }).unwrap(); + if !nocapture { + io::set_print(box Sink(data2.clone())); + io::set_panic(box Sink(data2)); + } + testfn() + }) + .unwrap(); let test_result = calc_result(&desc, result_guard.join()); let stdout = data.lock().unwrap().to_vec(); monitor_ch.send((desc.clone(), test_result, stdout)).unwrap(); @@ -1087,27 +1123,25 @@ pub fn run_test(opts: &TestOpts, return; } DynTestFn(f) => run_test_inner(desc, monitor_ch, opts.nocapture, f), - StaticTestFn(f) => run_test_inner(desc, monitor_ch, opts.nocapture, - Box::new(f)) + StaticTestFn(f) => run_test_inner(desc, monitor_ch, opts.nocapture, Box::new(f)), } } -fn calc_result(desc: &TestDesc, task_result: Result<(), Box>) -> TestResult { +fn calc_result(desc: &TestDesc, task_result: Result<(), Box>) -> TestResult { match (&desc.should_panic, task_result) { (&ShouldPanic::No, Ok(())) | (&ShouldPanic::Yes, Err(_)) => TrOk, (&ShouldPanic::YesWithMessage(msg), Err(ref err)) if err.downcast_ref::() - .map(|e| &**e) - .or_else(|| err.downcast_ref::<&'static str>().map(|e| *e)) - .map(|e| e.contains(msg)) - .unwrap_or(false) => TrOk, + .map(|e| &**e) + .or_else(|| err.downcast_ref::<&'static str>().map(|e| *e)) + .map(|e| e.contains(msg)) + .unwrap_or(false) => TrOk, _ => TrFailed, } } impl MetricMap { - pub fn new() -> MetricMap { MetricMap(BTreeMap::new()) } @@ -1128,7 +1162,7 @@ impl MetricMap { pub fn insert_metric(&mut self, name: &str, value: f64, noise: f64) { let m = Metric { value: value, - noise: noise + noise: noise, }; let MetricMap(ref mut map) = *self; map.insert(name.to_owned(), m); @@ -1136,10 +1170,9 @@ impl MetricMap { pub fn fmt_metrics(&self) -> String { let MetricMap(ref mm) = *self; - let v : Vec = mm.iter() - .map(|(k,v)| format!("{}: {} (+/- {})", *k, - v.value, v.noise)) - .collect(); + let v: Vec = mm.iter() + .map(|(k, v)| format!("{}: {} (+/- {})", *k, v.value, v.noise)) + .collect(); v.join(", ") } } @@ -1156,17 +1189,21 @@ impl MetricMap { pub fn black_box(dummy: T) -> T { // we need to "use" the argument in some way LLVM can't // introspect. - unsafe {asm!("" : : "r"(&dummy))} + unsafe { asm!("" : : "r"(&dummy)) } dummy } #[cfg(all(target_os = "nacl", target_arch = "le32"))] #[inline(never)] -pub fn black_box(dummy: T) -> T { dummy } +pub fn black_box(dummy: T) -> T { + dummy +} impl Bencher { /// Callback for benchmark functions to run in their body. - pub fn iter(&mut self, mut inner: F) where F: FnMut() -> T { + pub fn iter(&mut self, mut inner: F) + where F: FnMut() -> T + { let start = Instant::now(); let k = self.iterations; for _ in 0..k { @@ -1187,13 +1224,17 @@ impl Bencher { } } - pub fn bench_n(&mut self, n: u64, f: F) where F: FnOnce(&mut Bencher) { + pub fn bench_n(&mut self, n: u64, f: F) + where F: FnOnce(&mut Bencher) + { self.iterations = n; f(self); } // This is a more statistics-driven benchmark algorithm - pub fn auto_bench(&mut self, mut f: F) -> stats::Summary where F: FnMut(&mut Bencher) { + pub fn auto_bench(&mut self, mut f: F) -> stats::Summary + where F: FnMut(&mut Bencher) + { // Initial bench run to get ballpark figure. let mut n = 1; self.bench_n(n, |x| f(x)); @@ -1210,17 +1251,19 @@ impl Bencher { // side effect of not being able to do as many runs is // automatically handled by the statistical analysis below // (i.e. larger error bars). - if n == 0 { n = 1; } + if n == 0 { + n = 1; + } let mut total_run = Duration::new(0, 0); - let samples : &mut [f64] = &mut [0.0_f64; 50]; + let samples: &mut [f64] = &mut [0.0_f64; 50]; loop { let loop_start = Instant::now(); for p in &mut *samples { self.bench_n(n, |x| f(x)); *p = self.ns_per_iter() as f64; - }; + } stats::winsorize(samples, 5.0); let summ = stats::Summary::new(samples); @@ -1228,7 +1271,7 @@ impl Bencher { for p in &mut *samples { self.bench_n(5 * n, |x| f(x)); *p = self.ns_per_iter() as f64; - }; + } stats::winsorize(samples, 5.0); let summ5 = stats::Summary::new(samples); @@ -1236,9 +1279,8 @@ impl Bencher { // If we've run for 100ms and seem to have converged to a // stable median. - if loop_run > Duration::from_millis(100) && - summ.median_abs_dev_pct < 1.0 && - summ.median - summ5.median < summ5.median_abs_dev { + if loop_run > Duration::from_millis(100) && summ.median_abs_dev_pct < 1.0 && + summ.median - summ5.median < summ5.median_abs_dev { return summ5; } @@ -1265,11 +1307,13 @@ pub mod bench { use std::time::Duration; use super::{Bencher, BenchSamples}; - pub fn benchmark(f: F) -> BenchSamples where F: FnMut(&mut Bencher) { + pub fn benchmark(f: F) -> BenchSamples + where F: FnMut(&mut Bencher) + { let mut bs = Bencher { iterations: 0, dur: Duration::new(0, 0), - bytes: 0 + bytes: 0, }; let ns_iter_summ = bs.auto_bench(f); @@ -1279,15 +1323,17 @@ pub mod bench { BenchSamples { ns_iter_summ: ns_iter_summ, - mb_s: mb_s as usize + mb_s: mb_s as usize, } } - pub fn run_once(f: F) where F: FnOnce(&mut Bencher) { + pub fn run_once(f: F) + where F: FnOnce(&mut Bencher) + { let mut bs = Bencher { iterations: 0, dur: Duration::new(0, 0), - bytes: 0 + bytes: 0, }; bs.bench_n(1, f); } @@ -1295,22 +1341,22 @@ pub mod bench { #[cfg(test)] mod tests { - use test::{TrFailed, TrIgnored, TrOk, filter_tests, parse_opts, - TestDesc, TestDescAndFn, TestOpts, run_test, - MetricMap, - StaticTestName, DynTestName, DynTestFn, ShouldPanic}; + use test::{TrFailed, TrIgnored, TrOk, filter_tests, parse_opts, TestDesc, TestDescAndFn, + TestOpts, run_test, MetricMap, StaticTestName, DynTestName, DynTestFn, ShouldPanic}; use std::sync::mpsc::channel; #[test] pub fn do_not_run_ignored_tests() { - fn f() { panic!(); } + fn f() { + panic!(); + } let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: true, should_panic: ShouldPanic::No, }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1320,14 +1366,14 @@ mod tests { #[test] pub fn ignored_tests_result_in_ignored() { - fn f() { } + fn f() {} let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: true, should_panic: ShouldPanic::No, }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1337,14 +1383,16 @@ mod tests { #[test] fn test_should_panic() { - fn f() { panic!(); } + fn f() { + panic!(); + } let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: false, should_panic: ShouldPanic::Yes, }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1354,14 +1402,16 @@ mod tests { #[test] fn test_should_panic_good_message() { - fn f() { panic!("an error message"); } + fn f() { + panic!("an error message"); + } let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: false, should_panic: ShouldPanic::YesWithMessage("error message"), }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1371,14 +1421,16 @@ mod tests { #[test] fn test_should_panic_bad_message() { - fn f() { panic!("an error message"); } + fn f() { + panic!("an error message"); + } let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: false, should_panic: ShouldPanic::YesWithMessage("foobar"), }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1388,14 +1440,14 @@ mod tests { #[test] fn test_should_panic_but_succeeds() { - fn f() { } + fn f() {} let desc = TestDescAndFn { desc: TestDesc { name: StaticTestName("whatever"), ignore: false, should_panic: ShouldPanic::Yes, }, - testfn: DynTestFn(Box::new(move|| f())), + testfn: DynTestFn(Box::new(move || f())), }; let (tx, rx) = channel(); run_test(&TestOpts::new(), false, desc, tx); @@ -1405,12 +1457,10 @@ mod tests { #[test] fn parse_ignored_flag() { - let args = vec!("progname".to_string(), - "filter".to_string(), - "--ignored".to_string()); + let args = vec!["progname".to_string(), "filter".to_string(), "--ignored".to_string()]; let opts = match parse_opts(&args) { Some(Ok(o)) => o, - _ => panic!("Malformed arg in parse_ignored_flag") + _ => panic!("Malformed arg in parse_ignored_flag"), }; assert!((opts.run_ignored)); } @@ -1424,28 +1474,26 @@ mod tests { opts.run_tests = true; opts.run_ignored = true; - let tests = vec!( - TestDescAndFn { - desc: TestDesc { - name: StaticTestName("1"), - ignore: true, - should_panic: ShouldPanic::No, - }, - testfn: DynTestFn(Box::new(move|| {})), - }, - TestDescAndFn { - desc: TestDesc { - name: StaticTestName("2"), - ignore: false, - should_panic: ShouldPanic::No, - }, - testfn: DynTestFn(Box::new(move|| {})), - }); + let tests = vec![TestDescAndFn { + desc: TestDesc { + name: StaticTestName("1"), + ignore: true, + should_panic: ShouldPanic::No, + }, + testfn: DynTestFn(Box::new(move || {})), + }, + TestDescAndFn { + desc: TestDesc { + name: StaticTestName("2"), + ignore: false, + should_panic: ShouldPanic::No, + }, + testfn: DynTestFn(Box::new(move || {})), + }]; let filtered = filter_tests(&opts, tests); assert_eq!(filtered.len(), 1); - assert_eq!(filtered[0].desc.name.to_string(), - "1"); + assert_eq!(filtered[0].desc.name.to_string(), "1"); assert!(filtered[0].desc.ignore == false); } @@ -1454,19 +1502,17 @@ mod tests { let mut opts = TestOpts::new(); opts.run_tests = true; - let names = - vec!("sha1::test".to_string(), - "isize::test_to_str".to_string(), - "isize::test_pow".to_string(), - "test::do_not_run_ignored_tests".to_string(), - "test::ignored_tests_result_in_ignored".to_string(), - "test::first_free_arg_should_be_a_filter".to_string(), - "test::parse_ignored_flag".to_string(), - "test::filter_for_ignored_option".to_string(), - "test::sort_tests".to_string()); - let tests = - { - fn testfn() { } + let names = vec!["sha1::test".to_string(), + "isize::test_to_str".to_string(), + "isize::test_pow".to_string(), + "test::do_not_run_ignored_tests".to_string(), + "test::ignored_tests_result_in_ignored".to_string(), + "test::first_free_arg_should_be_a_filter".to_string(), + "test::parse_ignored_flag".to_string(), + "test::filter_for_ignored_option".to_string(), + "test::sort_tests".to_string()]; + let tests = { + fn testfn() {} let mut tests = Vec::new(); for name in &names { let test = TestDescAndFn { @@ -1483,16 +1529,15 @@ mod tests { }; let filtered = filter_tests(&opts, tests); - let expected = - vec!("isize::test_pow".to_string(), - "isize::test_to_str".to_string(), - "sha1::test".to_string(), - "test::do_not_run_ignored_tests".to_string(), - "test::filter_for_ignored_option".to_string(), - "test::first_free_arg_should_be_a_filter".to_string(), - "test::ignored_tests_result_in_ignored".to_string(), - "test::parse_ignored_flag".to_string(), - "test::sort_tests".to_string()); + let expected = vec!["isize::test_pow".to_string(), + "isize::test_to_str".to_string(), + "sha1::test".to_string(), + "test::do_not_run_ignored_tests".to_string(), + "test::filter_for_ignored_option".to_string(), + "test::first_free_arg_should_be_a_filter".to_string(), + "test::ignored_tests_result_in_ignored".to_string(), + "test::parse_ignored_flag".to_string(), + "test::sort_tests".to_string()]; for (a, b) in expected.iter().zip(filtered) { assert!(*a == b.desc.name.to_string()); diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index c1ba1260f67..335b6d67209 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -111,7 +111,7 @@ pub trait Stats { /// is otherwise equivalent. /// /// See also: https://en.wikipedia.org/wiki/Quartile - fn quartiles(&self) -> (f64,f64,f64); + fn quartiles(&self) -> (f64, f64, f64); /// Inter-quartile range: the difference between the 25th percentile (1st quartile) and the 75th /// percentile (3rd quartile). See `quartiles`. @@ -134,7 +134,7 @@ pub struct Summary { pub std_dev_pct: f64, pub median_abs_dev: f64, pub median_abs_dev_pct: f64, - pub quartiles: (f64,f64,f64), + pub quartiles: (f64, f64, f64), pub iqr: f64, } @@ -153,7 +153,7 @@ impl Summary { median_abs_dev: samples.median_abs_dev(), median_abs_dev_pct: samples.median_abs_dev_pct(), quartiles: samples.quartiles(), - iqr: samples.iqr() + iqr: samples.iqr(), } } } @@ -187,7 +187,7 @@ impl Stats for [f64] { partials.push(x); } else { partials[j] = x; - partials.truncate(j+1); + partials.truncate(j + 1); } } let zero: f64 = 0.0; @@ -221,13 +221,13 @@ impl Stats for [f64] { let mut v: f64 = 0.0; for s in self { let x = *s - mean; - v = v + x*x; + v = v + x * x; } // NB: this is _supposed to be_ len-1, not len. If you // change it back to len, you will be calculating a // population variance, not a sample variance. let denom = (self.len() - 1) as f64; - v/denom + v / denom } } @@ -260,7 +260,7 @@ impl Stats for [f64] { percentile_of_sorted(&tmp, pct) } - fn quartiles(&self) -> (f64,f64,f64) { + fn quartiles(&self) -> (f64, f64, f64) { let mut tmp = self.to_vec(); local_sort(&mut tmp); let first = 25f64; @@ -269,11 +269,11 @@ impl Stats for [f64] { let b = percentile_of_sorted(&tmp, secound); let third = 75f64; let c = percentile_of_sorted(&tmp, third); - (a,b,c) + (a, b, c) } fn iqr(&self) -> f64 { - let (a,_,c) = self.quartiles(); + let (a, _, c) = self.quartiles(); c - a } } @@ -299,7 +299,7 @@ fn percentile_of_sorted(sorted_samples: &[f64], pct: f64) -> f64 { let d = rank - lrank; let n = lrank as usize; let lo = sorted_samples[n]; - let hi = sorted_samples[n+1]; + let hi = sorted_samples[n + 1]; lo + (hi - lo) * d } @@ -316,7 +316,7 @@ pub fn winsorize(samples: &mut [f64], pct: f64) { local_sort(&mut tmp); let lo = percentile_of_sorted(&tmp, pct); let hundred = 100 as f64; - let hi = percentile_of_sorted(&tmp, hundred-pct); + let hi = percentile_of_sorted(&tmp, hundred - pct); for samp in samples { if *samp > hi { *samp = hi @@ -380,10 +380,7 @@ mod tests { #[test] fn test_norm2() { - let val = &[ - 958.0000000000, - 924.0000000000, - ]; + let val = &[958.0000000000, 924.0000000000]; let summ = &Summary { sum: 1882.0000000000, min: 924.0000000000, @@ -395,25 +392,23 @@ mod tests { std_dev_pct: 2.5549022912, median_abs_dev: 25.2042000000, median_abs_dev_pct: 2.6784484591, - quartiles: (932.5000000000,941.0000000000,949.5000000000), + quartiles: (932.5000000000, 941.0000000000, 949.5000000000), iqr: 17.0000000000, }; check(val, summ); } #[test] fn test_norm10narrow() { - let val = &[ - 966.0000000000, - 985.0000000000, - 1110.0000000000, - 848.0000000000, - 821.0000000000, - 975.0000000000, - 962.0000000000, - 1157.0000000000, - 1217.0000000000, - 955.0000000000, - ]; + let val = &[966.0000000000, + 985.0000000000, + 1110.0000000000, + 848.0000000000, + 821.0000000000, + 975.0000000000, + 962.0000000000, + 1157.0000000000, + 1217.0000000000, + 955.0000000000]; let summ = &Summary { sum: 9996.0000000000, min: 821.0000000000, @@ -425,25 +420,23 @@ mod tests { std_dev_pct: 12.6742097933, median_abs_dev: 102.2994000000, median_abs_dev_pct: 10.5408964451, - quartiles: (956.7500000000,970.5000000000,1078.7500000000), + quartiles: (956.7500000000, 970.5000000000, 1078.7500000000), iqr: 122.0000000000, }; check(val, summ); } #[test] fn test_norm10medium() { - let val = &[ - 954.0000000000, - 1064.0000000000, - 855.0000000000, - 1000.0000000000, - 743.0000000000, - 1084.0000000000, - 704.0000000000, - 1023.0000000000, - 357.0000000000, - 869.0000000000, - ]; + let val = &[954.0000000000, + 1064.0000000000, + 855.0000000000, + 1000.0000000000, + 743.0000000000, + 1084.0000000000, + 704.0000000000, + 1023.0000000000, + 357.0000000000, + 869.0000000000]; let summ = &Summary { sum: 8653.0000000000, min: 357.0000000000, @@ -455,25 +448,23 @@ mod tests { std_dev_pct: 25.4846418487, median_abs_dev: 195.7032000000, median_abs_dev_pct: 21.4704552935, - quartiles: (771.0000000000,911.5000000000,1017.2500000000), + quartiles: (771.0000000000, 911.5000000000, 1017.2500000000), iqr: 246.2500000000, }; check(val, summ); } #[test] fn test_norm10wide() { - let val = &[ - 505.0000000000, - 497.0000000000, - 1591.0000000000, - 887.0000000000, - 1026.0000000000, - 136.0000000000, - 1580.0000000000, - 940.0000000000, - 754.0000000000, - 1433.0000000000, - ]; + let val = &[505.0000000000, + 497.0000000000, + 1591.0000000000, + 887.0000000000, + 1026.0000000000, + 136.0000000000, + 1580.0000000000, + 940.0000000000, + 754.0000000000, + 1433.0000000000]; let summ = &Summary { sum: 9349.0000000000, min: 136.0000000000, @@ -485,40 +476,38 @@ mod tests { std_dev_pct: 52.3146817750, median_abs_dev: 611.5725000000, median_abs_dev_pct: 66.9482758621, - quartiles: (567.2500000000,913.5000000000,1331.2500000000), + quartiles: (567.2500000000, 913.5000000000, 1331.2500000000), iqr: 764.0000000000, }; check(val, summ); } #[test] fn test_norm25verynarrow() { - let val = &[ - 991.0000000000, - 1018.0000000000, - 998.0000000000, - 1013.0000000000, - 974.0000000000, - 1007.0000000000, - 1014.0000000000, - 999.0000000000, - 1011.0000000000, - 978.0000000000, - 985.0000000000, - 999.0000000000, - 983.0000000000, - 982.0000000000, - 1015.0000000000, - 1002.0000000000, - 977.0000000000, - 948.0000000000, - 1040.0000000000, - 974.0000000000, - 996.0000000000, - 989.0000000000, - 1015.0000000000, - 994.0000000000, - 1024.0000000000, - ]; + let val = &[991.0000000000, + 1018.0000000000, + 998.0000000000, + 1013.0000000000, + 974.0000000000, + 1007.0000000000, + 1014.0000000000, + 999.0000000000, + 1011.0000000000, + 978.0000000000, + 985.0000000000, + 999.0000000000, + 983.0000000000, + 982.0000000000, + 1015.0000000000, + 1002.0000000000, + 977.0000000000, + 948.0000000000, + 1040.0000000000, + 974.0000000000, + 996.0000000000, + 989.0000000000, + 1015.0000000000, + 994.0000000000, + 1024.0000000000]; let summ = &Summary { sum: 24926.0000000000, min: 948.0000000000, @@ -530,25 +519,23 @@ mod tests { std_dev_pct: 1.9888308788, median_abs_dev: 22.2390000000, median_abs_dev_pct: 2.2283567134, - quartiles: (983.0000000000,998.0000000000,1013.0000000000), + quartiles: (983.0000000000, 998.0000000000, 1013.0000000000), iqr: 30.0000000000, }; check(val, summ); } #[test] fn test_exp10a() { - let val = &[ - 23.0000000000, - 11.0000000000, - 2.0000000000, - 57.0000000000, - 4.0000000000, - 12.0000000000, - 5.0000000000, - 29.0000000000, - 3.0000000000, - 21.0000000000, - ]; + let val = &[23.0000000000, + 11.0000000000, + 2.0000000000, + 57.0000000000, + 4.0000000000, + 12.0000000000, + 5.0000000000, + 29.0000000000, + 3.0000000000, + 21.0000000000]; let summ = &Summary { sum: 167.0000000000, min: 2.0000000000, @@ -560,25 +547,23 @@ mod tests { std_dev_pct: 101.5828843560, median_abs_dev: 13.3434000000, median_abs_dev_pct: 116.0295652174, - quartiles: (4.2500000000,11.5000000000,22.5000000000), + quartiles: (4.2500000000, 11.5000000000, 22.5000000000), iqr: 18.2500000000, }; check(val, summ); } #[test] fn test_exp10b() { - let val = &[ - 24.0000000000, - 17.0000000000, - 6.0000000000, - 38.0000000000, - 25.0000000000, - 7.0000000000, - 51.0000000000, - 2.0000000000, - 61.0000000000, - 32.0000000000, - ]; + let val = &[24.0000000000, + 17.0000000000, + 6.0000000000, + 38.0000000000, + 25.0000000000, + 7.0000000000, + 51.0000000000, + 2.0000000000, + 61.0000000000, + 32.0000000000]; let summ = &Summary { sum: 263.0000000000, min: 2.0000000000, @@ -590,25 +575,23 @@ mod tests { std_dev_pct: 74.4671410520, median_abs_dev: 22.9803000000, median_abs_dev_pct: 93.7971428571, - quartiles: (9.5000000000,24.5000000000,36.5000000000), + quartiles: (9.5000000000, 24.5000000000, 36.5000000000), iqr: 27.0000000000, }; check(val, summ); } #[test] fn test_exp10c() { - let val = &[ - 71.0000000000, - 2.0000000000, - 32.0000000000, - 1.0000000000, - 6.0000000000, - 28.0000000000, - 13.0000000000, - 37.0000000000, - 16.0000000000, - 36.0000000000, - ]; + let val = &[71.0000000000, + 2.0000000000, + 32.0000000000, + 1.0000000000, + 6.0000000000, + 28.0000000000, + 13.0000000000, + 37.0000000000, + 16.0000000000, + 36.0000000000]; let summ = &Summary { sum: 242.0000000000, min: 1.0000000000, @@ -620,40 +603,38 @@ mod tests { std_dev_pct: 88.4507754589, median_abs_dev: 21.4977000000, median_abs_dev_pct: 97.7168181818, - quartiles: (7.7500000000,22.0000000000,35.0000000000), + quartiles: (7.7500000000, 22.0000000000, 35.0000000000), iqr: 27.2500000000, }; check(val, summ); } #[test] fn test_exp25() { - let val = &[ - 3.0000000000, - 24.0000000000, - 1.0000000000, - 19.0000000000, - 7.0000000000, - 5.0000000000, - 30.0000000000, - 39.0000000000, - 31.0000000000, - 13.0000000000, - 25.0000000000, - 48.0000000000, - 1.0000000000, - 6.0000000000, - 42.0000000000, - 63.0000000000, - 2.0000000000, - 12.0000000000, - 108.0000000000, - 26.0000000000, - 1.0000000000, - 7.0000000000, - 44.0000000000, - 25.0000000000, - 11.0000000000, - ]; + let val = &[3.0000000000, + 24.0000000000, + 1.0000000000, + 19.0000000000, + 7.0000000000, + 5.0000000000, + 30.0000000000, + 39.0000000000, + 31.0000000000, + 13.0000000000, + 25.0000000000, + 48.0000000000, + 1.0000000000, + 6.0000000000, + 42.0000000000, + 63.0000000000, + 2.0000000000, + 12.0000000000, + 108.0000000000, + 26.0000000000, + 1.0000000000, + 7.0000000000, + 44.0000000000, + 25.0000000000, + 11.0000000000]; let summ = &Summary { sum: 593.0000000000, min: 1.0000000000, @@ -665,40 +646,38 @@ mod tests { std_dev_pct: 103.3565983562, median_abs_dev: 19.2738000000, median_abs_dev_pct: 101.4410526316, - quartiles: (6.0000000000,19.0000000000,31.0000000000), + quartiles: (6.0000000000, 19.0000000000, 31.0000000000), iqr: 25.0000000000, }; check(val, summ); } #[test] fn test_binom25() { - let val = &[ - 18.0000000000, - 17.0000000000, - 27.0000000000, - 15.0000000000, - 21.0000000000, - 25.0000000000, - 17.0000000000, - 24.0000000000, - 25.0000000000, - 24.0000000000, - 26.0000000000, - 26.0000000000, - 23.0000000000, - 15.0000000000, - 23.0000000000, - 17.0000000000, - 18.0000000000, - 18.0000000000, - 21.0000000000, - 16.0000000000, - 15.0000000000, - 31.0000000000, - 20.0000000000, - 17.0000000000, - 15.0000000000, - ]; + let val = &[18.0000000000, + 17.0000000000, + 27.0000000000, + 15.0000000000, + 21.0000000000, + 25.0000000000, + 17.0000000000, + 24.0000000000, + 25.0000000000, + 24.0000000000, + 26.0000000000, + 26.0000000000, + 23.0000000000, + 15.0000000000, + 23.0000000000, + 17.0000000000, + 18.0000000000, + 18.0000000000, + 21.0000000000, + 16.0000000000, + 15.0000000000, + 31.0000000000, + 20.0000000000, + 17.0000000000, + 15.0000000000]; let summ = &Summary { sum: 514.0000000000, min: 15.0000000000, @@ -710,40 +689,38 @@ mod tests { std_dev_pct: 22.2037202539, median_abs_dev: 5.9304000000, median_abs_dev_pct: 29.6520000000, - quartiles: (17.0000000000,20.0000000000,24.0000000000), + quartiles: (17.0000000000, 20.0000000000, 24.0000000000), iqr: 7.0000000000, }; check(val, summ); } #[test] fn test_pois25lambda30() { - let val = &[ - 27.0000000000, - 33.0000000000, - 34.0000000000, - 34.0000000000, - 24.0000000000, - 39.0000000000, - 28.0000000000, - 27.0000000000, - 31.0000000000, - 28.0000000000, - 38.0000000000, - 21.0000000000, - 33.0000000000, - 36.0000000000, - 29.0000000000, - 37.0000000000, - 32.0000000000, - 34.0000000000, - 31.0000000000, - 39.0000000000, - 25.0000000000, - 31.0000000000, - 32.0000000000, - 40.0000000000, - 24.0000000000, - ]; + let val = &[27.0000000000, + 33.0000000000, + 34.0000000000, + 34.0000000000, + 24.0000000000, + 39.0000000000, + 28.0000000000, + 27.0000000000, + 31.0000000000, + 28.0000000000, + 38.0000000000, + 21.0000000000, + 33.0000000000, + 36.0000000000, + 29.0000000000, + 37.0000000000, + 32.0000000000, + 34.0000000000, + 31.0000000000, + 39.0000000000, + 25.0000000000, + 31.0000000000, + 32.0000000000, + 40.0000000000, + 24.0000000000]; let summ = &Summary { sum: 787.0000000000, min: 21.0000000000, @@ -755,40 +732,38 @@ mod tests { std_dev_pct: 16.3814245145, median_abs_dev: 5.9304000000, median_abs_dev_pct: 18.5325000000, - quartiles: (28.0000000000,32.0000000000,34.0000000000), + quartiles: (28.0000000000, 32.0000000000, 34.0000000000), iqr: 6.0000000000, }; check(val, summ); } #[test] fn test_pois25lambda40() { - let val = &[ - 42.0000000000, - 50.0000000000, - 42.0000000000, - 46.0000000000, - 34.0000000000, - 45.0000000000, - 34.0000000000, - 49.0000000000, - 39.0000000000, - 28.0000000000, - 40.0000000000, - 35.0000000000, - 37.0000000000, - 39.0000000000, - 46.0000000000, - 44.0000000000, - 32.0000000000, - 45.0000000000, - 42.0000000000, - 37.0000000000, - 48.0000000000, - 42.0000000000, - 33.0000000000, - 42.0000000000, - 48.0000000000, - ]; + let val = &[42.0000000000, + 50.0000000000, + 42.0000000000, + 46.0000000000, + 34.0000000000, + 45.0000000000, + 34.0000000000, + 49.0000000000, + 39.0000000000, + 28.0000000000, + 40.0000000000, + 35.0000000000, + 37.0000000000, + 39.0000000000, + 46.0000000000, + 44.0000000000, + 32.0000000000, + 45.0000000000, + 42.0000000000, + 37.0000000000, + 48.0000000000, + 42.0000000000, + 33.0000000000, + 42.0000000000, + 48.0000000000]; let summ = &Summary { sum: 1019.0000000000, min: 28.0000000000, @@ -800,40 +775,38 @@ mod tests { std_dev_pct: 14.3978417577, median_abs_dev: 5.9304000000, median_abs_dev_pct: 14.1200000000, - quartiles: (37.0000000000,42.0000000000,45.0000000000), + quartiles: (37.0000000000, 42.0000000000, 45.0000000000), iqr: 8.0000000000, }; check(val, summ); } #[test] fn test_pois25lambda50() { - let val = &[ - 45.0000000000, - 43.0000000000, - 44.0000000000, - 61.0000000000, - 51.0000000000, - 53.0000000000, - 59.0000000000, - 52.0000000000, - 49.0000000000, - 51.0000000000, - 51.0000000000, - 50.0000000000, - 49.0000000000, - 56.0000000000, - 42.0000000000, - 52.0000000000, - 51.0000000000, - 43.0000000000, - 48.0000000000, - 48.0000000000, - 50.0000000000, - 42.0000000000, - 43.0000000000, - 42.0000000000, - 60.0000000000, - ]; + let val = &[45.0000000000, + 43.0000000000, + 44.0000000000, + 61.0000000000, + 51.0000000000, + 53.0000000000, + 59.0000000000, + 52.0000000000, + 49.0000000000, + 51.0000000000, + 51.0000000000, + 50.0000000000, + 49.0000000000, + 56.0000000000, + 42.0000000000, + 52.0000000000, + 51.0000000000, + 43.0000000000, + 48.0000000000, + 48.0000000000, + 50.0000000000, + 42.0000000000, + 43.0000000000, + 42.0000000000, + 60.0000000000]; let summ = &Summary { sum: 1235.0000000000, min: 42.0000000000, @@ -845,40 +818,38 @@ mod tests { std_dev_pct: 11.3913245723, median_abs_dev: 4.4478000000, median_abs_dev_pct: 8.8956000000, - quartiles: (44.0000000000,50.0000000000,52.0000000000), + quartiles: (44.0000000000, 50.0000000000, 52.0000000000), iqr: 8.0000000000, }; check(val, summ); } #[test] fn test_unif25() { - let val = &[ - 99.0000000000, - 55.0000000000, - 92.0000000000, - 79.0000000000, - 14.0000000000, - 2.0000000000, - 33.0000000000, - 49.0000000000, - 3.0000000000, - 32.0000000000, - 84.0000000000, - 59.0000000000, - 22.0000000000, - 86.0000000000, - 76.0000000000, - 31.0000000000, - 29.0000000000, - 11.0000000000, - 41.0000000000, - 53.0000000000, - 45.0000000000, - 44.0000000000, - 98.0000000000, - 98.0000000000, - 7.0000000000, - ]; + let val = &[99.0000000000, + 55.0000000000, + 92.0000000000, + 79.0000000000, + 14.0000000000, + 2.0000000000, + 33.0000000000, + 49.0000000000, + 3.0000000000, + 32.0000000000, + 84.0000000000, + 59.0000000000, + 22.0000000000, + 86.0000000000, + 76.0000000000, + 31.0000000000, + 29.0000000000, + 11.0000000000, + 41.0000000000, + 53.0000000000, + 45.0000000000, + 44.0000000000, + 98.0000000000, + 98.0000000000, + 7.0000000000]; let summ = &Summary { sum: 1242.0000000000, min: 2.0000000000, @@ -890,7 +861,7 @@ mod tests { std_dev_pct: 64.1488719719, median_abs_dev: 45.9606000000, median_abs_dev_pct: 102.1346666667, - quartiles: (29.0000000000,45.0000000000,79.0000000000), + quartiles: (29.0000000000, 45.0000000000, 79.0000000000), iqr: 50.0000000000, }; check(val, summ); @@ -920,7 +891,7 @@ mod bench { #[bench] pub fn sum_many_f64(b: &mut Bencher) { let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60]; - let v = (0..500).map(|i| nums[i%5]).collect::>(); + let v = (0..500).map(|i| nums[i % 5]).collect::>(); b.iter(|| { v.sum();