mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix a few clippy lints in libtest

Browse Source 
- Remove unnecessary references and dereferences
- Use `.contains` instead of `a <= x && x <= b`
- Use `mem::take` instead of `mem::replace` where possible
This commit is contained in:
Joshua Nelson 2023-01-03 04:13:19 +00:00
parent 77429957a0
commit 3534e0a393
11 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
library/test/src/console.rs
View File

@ -147,7 +147,7 @@ pub fn list_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Res
let mut ntest = 0;
let mut nbench = 0;
for test in filter_tests(&opts, tests).into_iter() {
for test in filter_tests(opts, tests).into_iter() {
use crate::TestFn::*;
let TestDescAndFn { desc: TestDesc { name, .. }, testfn } = test;
@ -244,7 +244,7 @@ fn on_test_event(
let stdout = &completed_test.stdout;
st.write_log_result(test, result, exec_time.as_ref())?;
out.write_result(test, result, exec_time.as_ref(), &*stdout, st)?;
out.write_result(test, result, exec_time.as_ref(), stdout, st)?;
handle_test_result(st, completed_test);
}
}
@ -262,7 +262,7 @@ pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Resu
let max_name_len = tests
.iter()
.max_by_key(|t| len_if_padded(*t))
.max_by_key(|t| len_if_padded(t))
.map(|t| t.desc.name.as_slice().len())
.unwrap_or(0);

18
library/test/src/formatters/json.rs
View File

@ -40,20 +40,20 @@ fn write_event(
extra: Option<&str>,
) -> io::Result<()> {
// A doc test's name includes a filename which must be escaped for correct json.
self.write_message(&*format!(
self.write_message(&format!(
r#"{{ "type": "{}", "name": "{}", "event": "{}""#,
ty,
EscapedString(name),
evt
))?;
if let Some(exec_time) = exec_time {
self.write_message(&*format!(r#", "exec_time": {}"#, exec_time.0.as_secs_f64()))?;
self.write_message(&format!(r#", "exec_time": {}"#, exec_time.0.as_secs_f64()))?;
}
if let Some(stdout) = stdout {
self.write_message(&*format!(r#", "stdout": "{}""#, EscapedString(stdout)))?;
self.write_message(&format!(r#", "stdout": "{}""#, EscapedString(stdout)))?;
}
if let Some(extra) = extra {
self.write_message(&*format!(r#", {extra}"#))?;
self.write_message(&format!(r#", {extra}"#))?;
}
self.writeln_message(" }")
}
@ -66,13 +66,13 @@ fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> i
} else {
String::new()
};
self.writeln_message(&*format!(
self.writeln_message(&format!(
r#"{{ "type": "suite", "event": "started", "test_count": {test_count}{shuffle_seed_json} }}"#
))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
self.writeln_message(&*format!(
self.writeln_message(&format!(
r#"{{ "type": "test", "event": "started", "name": "{}" }}"#,
EscapedString(desc.name.as_slice())
))
@ -151,20 +151,20 @@ fn write_result(
mbps
);
self.writeln_message(&*line)
self.writeln_message(&line)
}
}
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.writeln_message(&*format!(
self.writeln_message(&format!(
r#"{{ "type": "test", "event": "timeout", "name": "{}" }}"#,
EscapedString(desc.name.as_slice())
))
}
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
self.write_message(&*format!(
self.write_message(&format!(
"{{ \"type\": \"suite\", \
\"event\": \"{}\", \
\"passed\": {}, \

16
library/test/src/formatters/junit.rs
View File

@ -64,7 +64,7 @@ fn write_result(
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
self.write_message("<testsuites>")?;
self.write_message(&*format!(
self.write_message(&format!(
"<testsuite name=\"test\" package=\"test\" id=\"0\" \
errors=\"0\" \
failures=\"{}\" \
@ -73,12 +73,12 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
>",
state.failed, state.total, state.ignored
))?;
for (desc, result, duration) in std::mem::replace(&mut self.results, Vec::new()) {
for (desc, result, duration) in std::mem::take(&mut self.results) {
let (class_name, test_name) = parse_class_name(&desc);
match result {
TestResult::TrIgnored => { /* no-op */ }
TestResult::TrFailed => {
self.write_message(&*format!(
self.write_message(&format!(
"<testcase classname=\"{}\" \
name=\"{}\" time=\"{}\">",
class_name,
@ -90,19 +90,19 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
}
TestResult::TrFailedMsg(ref m) => {
self.write_message(&*format!(
self.write_message(&format!(
"<testcase classname=\"{}\" \
name=\"{}\" time=\"{}\">",
class_name,
test_name,
duration.as_secs_f64()
))?;
self.write_message(&*format!("<failure message=\"{m}\" type=\"assert\"/>"))?;
self.write_message(&format!("<failure message=\"{m}\" type=\"assert\"/>"))?;
self.write_message("</testcase>")?;
}
TestResult::TrTimedFail => {
self.write_message(&*format!(
self.write_message(&format!(
"<testcase classname=\"{}\" \
name=\"{}\" time=\"{}\">",
class_name,
@ -114,7 +114,7 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
}
TestResult::TrBench(ref b) => {
self.write_message(&*format!(
self.write_message(&format!(
"<testcase classname=\"benchmark::{}\" \
name=\"{}\" time=\"{}\" />",
class_name, test_name, b.ns_iter_summ.sum
@ -122,7 +122,7 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
}
TestResult::TrOk => {
self.write_message(&*format!(
self.write_message(&format!(
"<testcase classname=\"{}\" \
name=\"{}\" time=\"{}\"/>",
class_name,

16
library/test/src/formatters/pretty.rs
View File

@ -134,7 +134,7 @@ fn write_results(
let mut results = Vec::new();
let mut stdouts = String::new();
for &(ref f, ref stdout) in inputs {
for (f, stdout) in inputs {
results.push(f.name.to_string());
if !stdout.is_empty() {
stdouts.push_str(&format!("---- {} stdout ----\n", f.name));
@ -171,9 +171,9 @@ pub fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()
fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
let name = desc.padded_name(self.max_name_len, desc.name.padding());
if let Some(test_mode) = desc.test_mode() {
self.write_plain(&format!("test {name} - {test_mode} ... "))?;
self.write_plain(format!("test {name} - {test_mode} ... "))?;
} else {
self.write_plain(&format!("test {name} ... "))?;
self.write_plain(format!("test {name} ... "))?;
}
Ok(())
@ -188,7 +188,7 @@ fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> i
} else {
String::new()
};
self.write_plain(&format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
@ -221,7 +221,7 @@ fn write_result(
TestResult::TrIgnored => self.write_ignored(desc.ignore_message)?,
TestResult::TrBench(ref bs) => {
self.write_bench()?;
self.write_plain(&format!(": {}", fmt_bench_samples(bs)))?;
self.write_plain(format!(": {}", fmt_bench_samples(bs)))?;
}
TestResult::TrTimedFail => self.write_time_failed()?,
}
@ -231,7 +231,7 @@ fn write_result(
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_plain(&format!(
self.write_plain(format!(
"test {} has been running for over {} seconds\n",
desc.name,
time::TEST_WARN_TIMEOUT_S
@ -267,11 +267,11 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
state.passed, state.failed, state.ignored, state.measured, state.filtered_out
);
self.write_plain(&s)?;
self.write_plain(s)?;
if let Some(ref exec_time) = state.exec_time {
let time_str = format!("; finished in {exec_time}");
self.write_plain(&time_str)?;
self.write_plain(time_str)?;
}
self.write_plain("\n\n")?;

20
library/test/src/formatters/terse.rs
View File

@ -70,7 +70,7 @@ pub fn write_short_result(
// screen when dealing with line-buffered output (e.g., piping to
// `stamp` in the rust CI).
let out = format!(" {}/{}\n", self.test_count + 1, self.total_test_count);
self.write_plain(&out)?;
self.write_plain(out)?;
}
self.test_count += 1;
@ -106,7 +106,7 @@ 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 {
for (f, stdout) in &state.not_failures {
successes.push(f.name.to_string());
if !stdout.is_empty() {
stdouts.push_str(&format!("---- {} stdout ----\n", f.name));
@ -132,7 +132,7 @@ 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 {
for (f, stdout) in &state.failures {
failures.push(f.name.to_string());
if !stdout.is_empty() {
fail_out.push_str(&format!("---- {} stdout ----\n", f.name));
@ -157,9 +157,9 @@ pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
let name = desc.padded_name(self.max_name_len, desc.name.padding());
if let Some(test_mode) = desc.test_mode() {
self.write_plain(&format!("test {name} - {test_mode} ... "))?;
self.write_plain(format!("test {name} - {test_mode} ... "))?;
} else {
self.write_plain(&format!("test {name} ... "))?;
self.write_plain(format!("test {name} ... "))?;
}
Ok(())
@ -175,7 +175,7 @@ fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> i
} else {
String::new()
};
self.write_plain(&format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
@ -209,13 +209,13 @@ fn write_result(
self.write_test_name(desc)?;
}
self.write_bench()?;
self.write_plain(&format!(": {}\n", fmt_bench_samples(bs)))
self.write_plain(format!(": {}\n", fmt_bench_samples(bs)))
}
}
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_plain(&format!(
self.write_plain(format!(
"test {} has been running for over {} seconds\n",
desc.name,
time::TEST_WARN_TIMEOUT_S
@ -245,11 +245,11 @@ fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
state.passed, state.failed, state.ignored, state.measured, state.filtered_out
);
self.write_plain(&s)?;
self.write_plain(s)?;
if let Some(ref exec_time) = state.exec_time {
let time_str = format!("; finished in {exec_time}");
self.write_plain(&time_str)?;
self.write_plain(time_str)?;
}
self.write_plain("\n\n")?;

2
library/test/src/lib.rs
View File

@ -789,7 +789,7 @@ fn run_test_in_spawned_subprocess(
}
});
let record_result2 = record_result.clone();
panic::set_hook(Box::new(move |info| record_result2(Some(&info))));
panic::set_hook(Box::new(move |info| record_result2(Some(info))));
if let Err(message) = testfn() {
panic!("{}", message);
}

6
library/test/src/term/terminfo/mod.rs
View File

@ -149,7 +149,7 @@ fn reset(&mut self) -> io::Result<bool> {
// are there any terminals that have color/attrs and not sgr0?
// Try falling back to sgr, then op
let cmd = match ["sgr0", "sgr", "op"].iter().find_map(|cap| self.ti.strings.get(*cap)) {
Some(op) => match expand(&op, &[], &mut Variables::new()) {
Some(op) => match expand(op, &[], &mut Variables::new()) {
Ok(cmd) => cmd,
Err(e) => return Err(io::Error::new(io::ErrorKind::InvalidData, e)),
},
@ -180,12 +180,12 @@ pub(crate) fn new(out: T) -> Option<TerminfoTerminal<T>> {
}
fn dim_if_necessary(&self, color: color::Color) -> color::Color {
if color >= self.num_colors && color >= 8 && color < 16 { color - 8 } else { color }
if color >= self.num_colors && (8..16).contains(&color) { color - 8 } else { color }
}
fn apply_cap(&mut self, cmd: &str, params: &[Param]) -> io::Result<bool> {
match self.ti.strings.get(cmd) {
Some(cmd) => match expand(&cmd, params, &mut Variables::new()) {
Some(cmd) => match expand(cmd, params, &mut Variables::new()) {
Ok(s) => self.out.write_all(&s).and(Ok(true)),
Err(e) => Err(io::Error::new(io::ErrorKind::InvalidData, e)),
},

8
library/test/src/term/terminfo/parm.rs
View File

@ -282,14 +282,14 @@ pub(crate) fn expand(
);
}
SetVar => {
if cur >= 'A' && cur <= 'Z' {
if cur.is_ascii_uppercase() {
if let Some(arg) = stack.pop() {
let idx = (cur as u8) - b'A';
vars.sta_va[idx as usize] = arg;
} else {
return Err("stack is empty".to_string());
}
} else if cur >= 'a' && cur <= 'z' {
} else if cur.is_ascii_lowercase() {
if let Some(arg) = stack.pop() {
let idx = (cur as u8) - b'a';
vars.dyn_va[idx as usize] = arg;
@ -301,10 +301,10 @@ pub(crate) fn expand(
}
}
GetVar => {
if cur >= 'A' && cur <= 'Z' {
if cur.is_ascii_uppercase() {
let idx = (cur as u8) - b'A';
stack.push(vars.sta_va[idx as usize].clone());
} else if cur >= 'a' && cur <= 'z' {
} else if cur.is_ascii_lowercase() {
let idx = (cur as u8) - b'a';
stack.push(vars.dyn_va[idx as usize].clone());
} else {

4
library/test/src/term/terminfo/searcher.rs
View File

@ -22,7 +22,7 @@ pub(crate) fn get_dbpath_for_term(term: &str) -> Option<PathBuf> {
if let Ok(dirs) = env::var("TERMINFO_DIRS") {
for i in dirs.split(':') {
if i == "" {
if i.is_empty() {
dirs_to_search.push(PathBuf::from("/usr/share/terminfo"));
} else {
dirs_to_search.push(PathBuf::from(i));
@ -49,7 +49,7 @@ pub(crate) fn get_dbpath_for_term(term: &str) -> Option<PathBuf> {
for mut p in dirs_to_search {
if fs::metadata(&p).is_ok() {
p.push(&first_char.to_string());
p.push(&term);
p.push(term);
if fs::metadata(&p).is_ok() {
return Some(p);
}

4
library/test/src/test_result.rs
View File

@ -33,7 +33,7 @@ pub fn calc_result<'a>(
) -> TestResult {
let result = match (&desc.should_panic, task_result) {
(&ShouldPanic::No, Ok(())) | (&ShouldPanic::Yes, Err(_)) => TestResult::TrOk,
(&ShouldPanic::YesWithMessage(msg), Err(ref err)) => {
(&ShouldPanic::YesWithMessage(msg), Err(err)) => {
let maybe_panic_str = err
.downcast_ref::<String>()
.map(|e| &**e)
@ -52,7 +52,7 @@ pub fn calc_result<'a>(
r#"expected panic with string value,
found non-string value: `{:?}`
expected substring: `{:?}`"#,
(**err).type_id(),
(*err).type_id(),
msg
))
}

2
library/test/src/types.rs
View File

@ -47,7 +47,7 @@ pub fn as_slice(&self) -> &str {
match *self {
StaticTestName(s) => s,
DynTestName(ref s) => s,
AlignedTestName(ref s, _) => &*s,
AlignedTestName(ref s, _) => s,
}
}