test: add #![warn(unreachable_pub)]

Urgau · gitbot · commit 22cd105fb407 · 2025-03-06T14:21:01.000Z
diff --git a/test/src/cli.rs b/test/src/cli.rs
@@ -44,7 +44,7 @@ impl TestOpts {
 }
 
 /// Result of parsing the options.
-pub type OptRes = Result<TestOpts, String>;
+pub(crate) type OptRes = Result<TestOpts, String>;
 /// Result of parsing the option part.
 type OptPartRes<T> = Result<T, String>;
 
diff --git a/test/src/console.rs b/test/src/console.rs
@@ -20,7 +20,7 @@ use super::types::{NamePadding, TestDesc, TestDescAndFn};
 use super::{filter_tests, run_tests, term};
 
 /// Generic wrapper over stdout.
-pub enum OutputLocation<T> {
+pub(crate) enum OutputLocation<T> {
     Pretty(Box<term::StdoutTerminal>),
     Raw(T),
 }
@@ -41,15 +41,15 @@ impl<T: Write> Write for OutputLocation<T> {
     }
 }
 
-pub struct ConsoleTestDiscoveryState {
+pub(crate) struct ConsoleTestDiscoveryState {
     pub log_out: Option<File>,
     pub tests: usize,
     pub benchmarks: usize,
     pub ignored: usize,
 }
 
 impl ConsoleTestDiscoveryState {
-    pub fn new(opts: &TestOpts) -> io::Result<ConsoleTestDiscoveryState> {
+    pub(crate) fn new(opts: &TestOpts) -> io::Result<ConsoleTestDiscoveryState> {
         let log_out = match opts.logfile {
             Some(ref path) => Some(File::create(path)?),
             None => None,
@@ -58,7 +58,7 @@ impl ConsoleTestDiscoveryState {
         Ok(ConsoleTestDiscoveryState { log_out, tests: 0, benchmarks: 0, ignored: 0 })
     }
 
-    pub fn write_log<F, S>(&mut self, msg: F) -> io::Result<()>
+    pub(crate) fn write_log<F, S>(&mut self, msg: F) -> io::Result<()>
     where
         S: AsRef<str>,
         F: FnOnce() -> S,
@@ -74,7 +74,7 @@ impl ConsoleTestDiscoveryState {
     }
 }
 
-pub struct ConsoleTestState {
+pub(crate) struct ConsoleTestState {
     pub log_out: Option<File>,
     pub total: usize,
     pub passed: usize,
@@ -92,7 +92,7 @@ pub struct ConsoleTestState {
 }
 
 impl ConsoleTestState {
-    pub fn new(opts: &TestOpts) -> io::Result<ConsoleTestState> {
+    pub(crate) fn new(opts: &TestOpts) -> io::Result<ConsoleTestState> {
         let log_out = match opts.logfile {
             Some(ref path) => Some(File::create(path)?),
             None => None,
@@ -116,7 +116,7 @@ impl ConsoleTestState {
         })
     }
 
-    pub fn write_log<F, S>(&mut self, msg: F) -> io::Result<()>
+    pub(crate) fn write_log<F, S>(&mut self, msg: F) -> io::Result<()>
     where
         S: AsRef<str>,
         F: FnOnce() -> S,
@@ -131,7 +131,7 @@ impl ConsoleTestState {
         }
     }
 
-    pub fn write_log_result(
+    pub(crate) fn write_log_result(
         &mut self,
         test: &TestDesc,
         result: &TestResult,
@@ -170,7 +170,7 @@ impl ConsoleTestState {
 }
 
 // List the tests to console, and optionally to logfile. Filters are honored.
-pub fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Result<()> {
+pub(crate) fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Result<()> {
     let output = match term::stdout() {
         None => OutputLocation::Raw(io::stdout().lock()),
         Some(t) => OutputLocation::Pretty(t),
diff --git a/test/src/formatters/json.rs b/test/src/formatters/json.rs
@@ -13,7 +13,7 @@ pub(crate) struct JsonFormatter<T> {
 }
 
 impl<T: Write> JsonFormatter<T> {
-    pub fn new(out: OutputLocation<T>) -> Self {
+    pub(crate) fn new(out: OutputLocation<T>) -> Self {
         Self { out }
     }
 
diff --git a/test/src/formatters/junit.rs b/test/src/formatters/junit.rs
@@ -8,13 +8,13 @@ use crate::test_result::TestResult;
 use crate::time;
 use crate::types::{TestDesc, TestType};
 
-pub struct JunitFormatter<T> {
+pub(crate) struct JunitFormatter<T> {
     out: OutputLocation<T>,
     results: Vec<(TestDesc, TestResult, Duration, Vec<u8>)>,
 }
 
 impl<T: Write> JunitFormatter<T> {
-    pub fn new(out: OutputLocation<T>) -> Self {
+    pub(crate) fn new(out: OutputLocation<T>) -> Self {
         Self { out, results: Vec::new() }
     }
 
diff --git a/test/src/formatters/pretty.rs b/test/src/formatters/pretty.rs
@@ -20,7 +20,7 @@ pub(crate) struct PrettyFormatter<T> {
 }
 
 impl<T: Write> PrettyFormatter<T> {
-    pub fn new(
+    pub(crate) fn new(
         out: OutputLocation<T>,
         use_color: bool,
         max_name_len: usize,
@@ -31,43 +31,43 @@ impl<T: Write> PrettyFormatter<T> {
     }
 
     #[cfg(test)]
-    pub fn output_location(&self) -> &OutputLocation<T> {
+    pub(crate) fn output_location(&self) -> &OutputLocation<T> {
         &self.out
     }
 
-    pub fn write_ok(&mut self) -> io::Result<()> {
+    pub(crate) fn write_ok(&mut self) -> io::Result<()> {
         self.write_short_result("ok", term::color::GREEN)
     }
 
-    pub fn write_failed(&mut self) -> io::Result<()> {
+    pub(crate) fn write_failed(&mut self) -> io::Result<()> {
         self.write_short_result("FAILED", term::color::RED)
     }
 
-    pub fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {
+    pub(crate) fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {
         if let Some(message) = message {
             self.write_short_result(&format!("ignored, {message}"), term::color::YELLOW)
         } else {
             self.write_short_result("ignored", term::color::YELLOW)
         }
     }
 
-    pub fn write_time_failed(&mut self) -> io::Result<()> {
+    pub(crate) fn write_time_failed(&mut self) -> io::Result<()> {
         self.write_short_result("FAILED (time limit exceeded)", term::color::RED)
     }
 
-    pub fn write_bench(&mut self) -> io::Result<()> {
+    pub(crate) fn write_bench(&mut self) -> io::Result<()> {
         self.write_pretty("bench", term::color::CYAN)
     }
 
-    pub fn write_short_result(
+    pub(crate) fn write_short_result(
         &mut self,
         result: &str,
         color: term::color::Color,
     ) -> io::Result<()> {
         self.write_pretty(result, color)
     }
 
-    pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
+    pub(crate) fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
         match self.out {
             OutputLocation::Pretty(ref mut term) => {
                 if self.use_color {
@@ -86,7 +86,7 @@ impl<T: Write> PrettyFormatter<T> {
         }
     }
 
-    pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
+    pub(crate) 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()
@@ -154,15 +154,15 @@ impl<T: Write> PrettyFormatter<T> {
         Ok(())
     }
 
-    pub fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+    pub(crate) fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
         self.write_results(&state.not_failures, "successes")
     }
 
-    pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+    pub(crate) fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
         self.write_results(&state.failures, "failures")
     }
 
-    pub fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+    pub(crate) fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
         self.write_results(&state.time_failures, "failures (time limit exceeded)")
     }
 
diff --git a/test/src/formatters/terse.rs b/test/src/formatters/terse.rs
@@ -25,7 +25,7 @@ pub(crate) struct TerseFormatter<T> {
 }
 
 impl<T: Write> TerseFormatter<T> {
-    pub fn new(
+    pub(crate) fn new(
         out: OutputLocation<T>,
         use_color: bool,
         max_name_len: usize,
@@ -42,11 +42,11 @@ impl<T: Write> TerseFormatter<T> {
         }
     }
 
-    pub fn write_ok(&mut self) -> io::Result<()> {
+    pub(crate) fn write_ok(&mut self) -> io::Result<()> {
         self.write_short_result(".", term::color::GREEN)
     }
 
-    pub fn write_failed(&mut self, name: &str) -> io::Result<()> {
+    pub(crate) fn write_failed(&mut self, name: &str) -> io::Result<()> {
         // Put failed tests on their own line and include the test name, so that it's faster
         // to see which test failed without having to wait for them all to run.
 
@@ -62,15 +62,15 @@ impl<T: Write> TerseFormatter<T> {
         self.write_plain("\n")
     }
 
-    pub fn write_ignored(&mut self) -> io::Result<()> {
+    pub(crate) fn write_ignored(&mut self) -> io::Result<()> {
         self.write_short_result("i", term::color::YELLOW)
     }
 
-    pub fn write_bench(&mut self) -> io::Result<()> {
+    pub(crate) fn write_bench(&mut self) -> io::Result<()> {
         self.write_pretty("bench", term::color::CYAN)
     }
 
-    pub fn write_short_result(
+    pub(crate) fn write_short_result(
         &mut self,
         result: &str,
         color: term::color::Color,
@@ -95,7 +95,7 @@ impl<T: Write> TerseFormatter<T> {
         Ok(())
     }
 
-    pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
+    pub(crate) fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
         match self.out {
             OutputLocation::Pretty(ref mut term) => {
                 if self.use_color {
@@ -114,13 +114,13 @@ impl<T: Write> TerseFormatter<T> {
         }
     }
 
-    pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
+    pub(crate) 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<()> {
+    pub(crate) fn write_outputs(&mut self, state: &ConsoleTestState) -> io::Result<()> {
         self.write_plain("\nsuccesses:\n")?;
         let mut successes = Vec::new();
         let mut stdouts = String::new();
@@ -146,7 +146,7 @@ impl<T: Write> TerseFormatter<T> {
         Ok(())
     }
 
-    pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
+    pub(crate) 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();
diff --git a/test/src/helpers/concurrency.rs b/test/src/helpers/concurrency.rs
@@ -4,7 +4,7 @@
 use std::num::NonZero;
 use std::{env, thread};
 
-pub fn get_concurrency() -> usize {
+pub(crate) fn get_concurrency() -> usize {
     if let Ok(value) = env::var("RUST_TEST_THREADS") {
         match value.parse::<NonZero<usize>>().ok() {
             Some(n) => n.get(),
diff --git a/test/src/helpers/mod.rs b/test/src/helpers/mod.rs
@@ -1,6 +1,6 @@
 //! Module with common helpers not directly related to tests
 //! but used in `libtest`.
 
-pub mod concurrency;
-pub mod metrics;
-pub mod shuffle;
+pub(crate) mod concurrency;
+pub(crate) mod metrics;
+pub(crate) mod shuffle;
diff --git a/test/src/helpers/shuffle.rs b/test/src/helpers/shuffle.rs
@@ -4,7 +4,7 @@ use std::time::{SystemTime, UNIX_EPOCH};
 use crate::cli::TestOpts;
 use crate::types::{TestDescAndFn, TestId, TestName};
 
-pub fn get_shuffle_seed(opts: &TestOpts) -> Option<u64> {
+pub(crate) fn get_shuffle_seed(opts: &TestOpts) -> Option<u64> {
     opts.shuffle_seed.or_else(|| {
         if opts.shuffle {
             Some(
@@ -19,7 +19,7 @@ pub fn get_shuffle_seed(opts: &TestOpts) -> Option<u64> {
     })
 }
 
-pub fn shuffle_tests(shuffle_seed: u64, tests: &mut [(TestId, TestDescAndFn)]) {
+pub(crate) fn shuffle_tests(shuffle_seed: u64, tests: &mut [(TestId, TestDescAndFn)]) {
     let test_names: Vec<&TestName> = tests.iter().map(|test| &test.1.desc.name).collect();
     let test_names_hash = calculate_hash(&test_names);
     let mut rng = Rng::new(shuffle_seed, test_names_hash);
diff --git a/test/src/lib.rs b/test/src/lib.rs
@@ -27,6 +27,7 @@
 #![feature(thread_spawn_hook)]
 #![allow(internal_features)]
 #![warn(rustdoc::unescaped_backticks)]
+#![warn(unreachable_pub)]
 
 pub use cli::TestOpts;
 
diff --git a/test/src/options.rs b/test/src/options.rs
@@ -2,7 +2,7 @@
 
 /// Number of times to run a benchmarked function
 #[derive(Clone, PartialEq, Eq)]
-pub enum BenchMode {
+pub(crate) enum BenchMode {
     Auto,
     Single,
 }
diff --git a/test/src/stats/tests.rs b/test/src/stats/tests.rs
@@ -573,13 +573,13 @@ fn test_sum_f64_between_ints_that_sum_to_0() {
 }
 
 #[bench]
-pub fn sum_three_items(b: &mut Bencher) {
+fn sum_three_items(b: &mut Bencher) {
     b.iter(|| {
         [1e20f64, 1.5f64, -1e20f64].sum();
     })
 }
 #[bench]
-pub fn sum_many_f64(b: &mut Bencher) {
+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::<Vec<_>>();
 
@@ -589,4 +589,4 @@ pub fn sum_many_f64(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn no_iter(_: &mut Bencher) {}
+fn no_iter(_: &mut Bencher) {}
diff --git a/test/src/term.rs b/test/src/term.rs
@@ -62,7 +62,7 @@ pub(crate) mod color {
 
 /// A terminal with similar capabilities to an ANSI Terminal
 /// (foreground/background colors etc).
-pub trait Terminal: Write {
+pub(crate) trait Terminal: Write {
     /// Sets the foreground color to the given color.
     ///
     /// If the color is a bright color, but the terminal only supports 8 colors,
diff --git a/test/src/test_result.rs b/test/src/test_result.rs
@@ -12,7 +12,7 @@ use super::types::TestDesc;
 // Return code for secondary process.
 // Start somewhere other than 0 so we know the return code means what we think
 // it means.
-pub const TR_OK: i32 = 50;
+pub(crate) const TR_OK: i32 = 50;
 
 // On Windows we use __fastfail to abort, which is documented to use this
 // exception code.
@@ -39,7 +39,7 @@ pub enum TestResult {
 
 /// Creates a `TestResult` depending on the raw result of test execution
 /// and associated data.
-pub fn calc_result<'a>(
+pub(crate) fn calc_result<'a>(
     desc: &TestDesc,
     task_result: Result<(), &'a (dyn Any + 'static + Send)>,
     time_opts: Option<&time::TestTimeOptions>,
@@ -93,7 +93,7 @@ pub fn calc_result<'a>(
 }
 
 /// Creates a `TestResult` depending on the exit code of test subprocess.
-pub fn get_result_from_exit_code(
+pub(crate) fn get_result_from_exit_code(
     desc: &TestDesc,
     status: ExitStatus,
     time_opts: Option<&time::TestTimeOptions>,
diff --git a/test/src/tests.rs b/test/src/tests.rs
diff --git a/test/src/time.rs b/test/src/time.rs

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ impl TestOpts {`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`/// Result of parsing the options.`
`47`		`-pub type OptRes = Result<TestOpts, String>;`
	`47`	`+pub(crate) type OptRes = Result<TestOpts, String>;`
`48`	`48`	`/// Result of parsing the option part.`
`49`	`49`	`type OptPartRes<T> = Result<T, String>;`
`50`	`50`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ pub(crate) struct JsonFormatter<T> {`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`impl<T: Write> JsonFormatter<T> {`
`16`		`- pub fn new(out: OutputLocation<T>) -> Self {`
	`16`	`+ pub(crate) fn new(out: OutputLocation<T>) -> Self {`
`17`	`17`	`Self { out }`
`18`	`18`	`}`
`19`	`19`
Original file line number	Diff line number	Diff line change
`@@ -8,13 +8,13 @@ use crate::test_result::TestResult;`
`8`	`8`	`use crate::time;`
`9`	`9`	`use crate::types::{TestDesc, TestType};`
`10`	`10`
`11`		`-pub struct JunitFormatter<T> {`
	`11`	`+pub(crate) struct JunitFormatter<T> {`
`12`	`12`	`out: OutputLocation<T>,`
`13`	`13`	`results: Vec<(TestDesc, TestResult, Duration, Vec<u8>)>,`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`impl<T: Write> JunitFormatter<T> {`
`17`		`- pub fn new(out: OutputLocation<T>) -> Self {`
	`17`	`+ pub(crate) fn new(out: OutputLocation<T>) -> Self {`
`18`	`18`	`Self { out, results: Vec::new() }`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub(crate) struct PrettyFormatter<T> {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<T: Write> PrettyFormatter<T> {`
`23`		`- pub fn new(`
	`23`	`+ pub(crate) fn new(`
`24`	`24`	`out: OutputLocation<T>,`
`25`	`25`	`use_color: bool,`
`26`	`26`	`max_name_len: usize,`
`@@ -31,43 +31,43 @@ impl<T: Write> PrettyFormatter<T> {`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`#[cfg(test)]`
`34`		`- pub fn output_location(&self) -> &OutputLocation<T> {`
	`34`	`+ pub(crate) fn output_location(&self) -> &OutputLocation<T> {`
`35`	`35`	`&self.out`
`36`	`36`	`}`
`37`	`37`
`38`		`- pub fn write_ok(&mut self) -> io::Result<()> {`
	`38`	`+ pub(crate) fn write_ok(&mut self) -> io::Result<()> {`
`39`	`39`	`self.write_short_result("ok", term::color::GREEN)`
`40`	`40`	`}`
`41`	`41`
`42`		`- pub fn write_failed(&mut self) -> io::Result<()> {`
	`42`	`+ pub(crate) fn write_failed(&mut self) -> io::Result<()> {`
`43`	`43`	`self.write_short_result("FAILED", term::color::RED)`
`44`	`44`	`}`
`45`	`45`
`46`		`- pub fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {`
	`46`	`+ pub(crate) fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {`
`47`	`47`	`if let Some(message) = message {`
`48`	`48`	`self.write_short_result(&format!("ignored, {message}"), term::color::YELLOW)`
`49`	`49`	`} else {`
`50`	`50`	`self.write_short_result("ignored", term::color::YELLOW)`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`- pub fn write_time_failed(&mut self) -> io::Result<()> {`
	`54`	`+ pub(crate) fn write_time_failed(&mut self) -> io::Result<()> {`
`55`	`55`	`self.write_short_result("FAILED (time limit exceeded)", term::color::RED)`
`56`	`56`	`}`
`57`	`57`
`58`		`- pub fn write_bench(&mut self) -> io::Result<()> {`
	`58`	`+ pub(crate) fn write_bench(&mut self) -> io::Result<()> {`
`59`	`59`	`self.write_pretty("bench", term::color::CYAN)`
`60`	`60`	`}`
`61`	`61`
`62`		`- pub fn write_short_result(`
	`62`	`+ pub(crate) fn write_short_result(`
`63`	`63`	`&mut self,`
`64`	`64`	`result: &str,`
`65`	`65`	`color: term::color::Color,`
`66`	`66`	`) -> io::Result<()> {`
`67`	`67`	`self.write_pretty(result, color)`
`68`	`68`	`}`
`69`	`69`
`70`		`- pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {`
	`70`	`+ pub(crate) fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {`
`71`	`71`	`match self.out {`
`72`	`72`	`OutputLocation::Pretty(ref mut term) => {`
`73`	`73`	`if self.use_color {`
`@@ -86,7 +86,7 @@ impl<T: Write> PrettyFormatter<T> {`
`86`	`86`	`}`
`87`	`87`	`}`
`88`	`88`
`89`		`- pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {`
	`89`	`+ pub(crate) fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {`
`90`	`90`	`let s = s.as_ref();`
`91`	`91`	`self.out.write_all(s.as_bytes())?;`
`92`	`92`	`self.out.flush()`
`@@ -154,15 +154,15 @@ impl<T: Write> PrettyFormatter<T> {`
`154`	`154`	`Ok(())`
`155`	`155`	`}`
`156`	`156`
`157`		`- pub fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
	`157`	`+ pub(crate) fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
`158`	`158`	`self.write_results(&state.not_failures, "successes")`
`159`	`159`	`}`
`160`	`160`
`161`		`- pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
	`161`	`+ pub(crate) fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
`162`	`162`	`self.write_results(&state.failures, "failures")`
`163`	`163`	`}`
`164`	`164`
`165`		`- pub fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
	`165`	`+ pub(crate) fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
`166`	`166`	`self.write_results(&state.time_failures, "failures (time limit exceeded)")`
`167`	`167`	`}`
`168`	`168`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ pub(crate) struct TerseFormatter<T> {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`impl<T: Write> TerseFormatter<T> {`
`28`		`- pub fn new(`
	`28`	`+ pub(crate) fn new(`
`29`	`29`	`out: OutputLocation<T>,`
`30`	`30`	`use_color: bool,`
`31`	`31`	`max_name_len: usize,`
`@@ -42,11 +42,11 @@ impl<T: Write> TerseFormatter<T> {`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`- pub fn write_ok(&mut self) -> io::Result<()> {`
	`45`	`+ pub(crate) fn write_ok(&mut self) -> io::Result<()> {`
`46`	`46`	`self.write_short_result(".", term::color::GREEN)`
`47`	`47`	`}`
`48`	`48`
`49`		`- pub fn write_failed(&mut self, name: &str) -> io::Result<()> {`
	`49`	`+ pub(crate) fn write_failed(&mut self, name: &str) -> io::Result<()> {`
`50`	`50`	`// Put failed tests on their own line and include the test name, so that it's faster`
`51`	`51`	`// to see which test failed without having to wait for them all to run.`
`52`	`52`
`@@ -62,15 +62,15 @@ impl<T: Write> TerseFormatter<T> {`
`62`	`62`	`self.write_plain("\n")`
`63`	`63`	`}`
`64`	`64`
`65`		`- pub fn write_ignored(&mut self) -> io::Result<()> {`
	`65`	`+ pub(crate) fn write_ignored(&mut self) -> io::Result<()> {`
`66`	`66`	`self.write_short_result("i", term::color::YELLOW)`
`67`	`67`	`}`
`68`	`68`
`69`		`- pub fn write_bench(&mut self) -> io::Result<()> {`
	`69`	`+ pub(crate) fn write_bench(&mut self) -> io::Result<()> {`
`70`	`70`	`self.write_pretty("bench", term::color::CYAN)`
`71`	`71`	`}`
`72`	`72`
`73`		`- pub fn write_short_result(`
	`73`	`+ pub(crate) fn write_short_result(`
`74`	`74`	`&mut self,`
`75`	`75`	`result: &str,`
`76`	`76`	`color: term::color::Color,`
`@@ -95,7 +95,7 @@ impl<T: Write> TerseFormatter<T> {`
`95`	`95`	`Ok(())`
`96`	`96`	`}`
`97`	`97`
`98`		`- pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {`
	`98`	`+ pub(crate) fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {`
`99`	`99`	`match self.out {`
`100`	`100`	`OutputLocation::Pretty(ref mut term) => {`
`101`	`101`	`if self.use_color {`
`@@ -114,13 +114,13 @@ impl<T: Write> TerseFormatter<T> {`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`- pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {`
	`117`	`+ pub(crate) fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {`
`118`	`118`	`let s = s.as_ref();`
`119`	`119`	`self.out.write_all(s.as_bytes())?;`
`120`	`120`	`self.out.flush()`
`121`	`121`	`}`
`122`	`122`
`123`		`- pub fn write_outputs(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
	`123`	`+ pub(crate) fn write_outputs(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
`124`	`124`	`self.write_plain("\nsuccesses:\n")?;`
`125`	`125`	`let mut successes = Vec::new();`
`126`	`126`	`let mut stdouts = String::new();`
`@@ -146,7 +146,7 @@ impl<T: Write> TerseFormatter<T> {`
`146`	`146`	`Ok(())`
`147`	`147`	`}`
`148`	`148`
`149`		`- pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
	`149`	`+ pub(crate) fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {`
`150`	`150`	`self.write_plain("\nfailures:\n")?;`
`151`	`151`	`let mut failures = Vec::new();`
`152`	`152`	`let mut fail_out = String::new();`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`/// Number of times to run a benchmarked function`
`4`	`4`	`#[derive(Clone, PartialEq, Eq)]`
`5`		`-pub enum BenchMode {`
	`5`	`+pub(crate) enum BenchMode {`
`6`	`6`	`Auto,`
`7`	`7`	`Single,`
`8`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -573,13 +573,13 @@ fn test_sum_f64_between_ints_that_sum_to_0() {`
`573`	`573`	`}`
`574`	`574`
`575`	`575`	`#[bench]`
`576`		`-pub fn sum_three_items(b: &mut Bencher) {`
	`576`	`+fn sum_three_items(b: &mut Bencher) {`
`577`	`577`	`b.iter(\|\| {`
`578`	`578`	`[1e20f64, 1.5f64, -1e20f64].sum();`
`579`	`579`	`})`
`580`	`580`	`}`
`581`	`581`	`#[bench]`
`582`		`-pub fn sum_many_f64(b: &mut Bencher) {`
	`582`	`+fn sum_many_f64(b: &mut Bencher) {`
`583`	`583`	`let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60];`
`584`	`584`	`let v = (0..500).map(\|i\| nums[i % 5]).collect::<Vec<_>>();`
`585`	`585`
`@@ -589,4 +589,4 @@ pub fn sum_many_f64(b: &mut Bencher) {`
`589`	`589`	`}`
`590`	`590`
`591`	`591`	`#[bench]`
`592`		`-pub fn no_iter(_: &mut Bencher) {}`
	`592`	`+fn no_iter(_: &mut Bencher) {}`