mirrors/crosvm
1
0
Fork 0
mirror of https://chromium.googlesource.com/crosvm/crosvm synced 2025-02-05 10:10:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

sys_util: Apply clippy's autofix

Browse source 
Ran the following command under /sys_util/:
`rustup run nightly cargo clippy --fix -Z unstable-options`

BUG=chromium:1111728
TEST=build

Change-Id: I2ecb04f8dea6711c9f0f658185ecdb201ba1f659
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/2331883
Tested-by: Keiichi Watanabe <keiichiw@chromium.org>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>
Commit-Queue: Keiichi Watanabe <keiichiw@chromium.org>
This commit is contained in:
Keiichi Watanabe 2020-07-31 15:00:21 +09:00 committed by Commit Bot
parent 379702c402
commit bb14010332
5 changed files with 22 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
sys_util/src/fork.rs
View file

@ -97,7 +97,6 @@ where
mod tests {
use super::*;
use crate::{getpid, EventFd};
use libc;
fn wait_process(pid: libc::pid_t) -> crate::Result<libc::c_int> {
let mut status: libc::c_int = 0;

10
sys_util/src/handle_eintr.rs
View file

@ -17,19 +17,13 @@ pub trait InterruptibleResult {
impl<T> InterruptibleResult for crate::Result<T> {
fn is_interrupted(&self) -> bool {
match self {
Err(e) if e.errno() == EINTR => true,
_ => false,
}
matches!(self, Err(e) if e.errno() == EINTR)
}
}
impl<T> InterruptibleResult for io::Result<T> {
fn is_interrupted(&self) -> bool {
match self {
Err(e) if e.kind() == io::ErrorKind::Interrupted => true,
_ => false,
}
matches!(self, Err(e) if e.kind() == io::ErrorKind::Interrupted)
}
}

6
sys_util/src/syslog.rs
View file

@ -563,7 +563,7 @@ mod tests {
init().unwrap();
let mut fds = Vec::new();
push_fds(&mut fds);
assert!(fds.len() >= 1);
assert!(!fds.is_empty());
for fd in fds {
assert!(fd >= 0);
}
@ -613,7 +613,7 @@ mod tests {
let syslog_file = file.try_clone().expect("error cloning shared memory file");
echo_file(Some(syslog_file));
const TEST_STR: &'static str = "hello shared memory file";
const TEST_STR: &str = "hello shared memory file";
log(
Priority::Error,
Facility::User,
@ -649,7 +649,7 @@ mod tests {
}
syslogger
.write(&['\n' as u8])
.write(&[b'\n'])
.expect("error writing newline char");
}

10
sys_util/src/timerfd.rs
View file

@ -227,7 +227,7 @@ mod tests {
let dur = Duration::from_millis(200);
let now = Instant::now();
tfd.reset(dur.clone(), None).expect("failed to arm timer");
tfd.reset(dur, None).expect("failed to arm timer");
assert_eq!(tfd.is_armed().unwrap(), true);
@ -243,8 +243,7 @@ mod tests {
let dur = Duration::from_millis(200);
let interval = Duration::from_millis(100);
tfd.reset(dur.clone(), Some(interval))
.expect("failed to arm timer");
tfd.reset(dur, Some(interval)).expect("failed to arm timer");
sleep(dur * 3);
@ -259,7 +258,7 @@ mod tests {
assert_eq!(tfd.is_armed().unwrap(), false);
let dur = Duration::from_nanos(200);
tfd.reset(dur.clone(), None).expect("failed to arm timer");
tfd.reset(dur, None).expect("failed to arm timer");
assert_eq!(tfd.is_armed().unwrap(), true);
clock.lock().add_ns(200);
@ -276,8 +275,7 @@ mod tests {
let dur = Duration::from_nanos(200);
let interval = Duration::from_nanos(100);
tfd.reset(dur.clone(), Some(interval))
.expect("failed to arm timer");
tfd.reset(dur, Some(interval)).expect("failed to arm timer");
clock.lock().add_ns(300);

32
vm_memory/src/guest_memory.rs
View file

@ -698,29 +698,29 @@ mod tests {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
assert!(GuestMemory::new(&vec![(start_addr1, 0x100), (start_addr2, 0x400)]).is_err());
assert!(GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).is_ok());
assert!(GuestMemory::new(&[(start_addr1, 0x100), (start_addr2, 0x400)]).is_err());
assert!(GuestMemory::new(&[(start_addr1, 0x1000), (start_addr2, 0x1000)]).is_ok());
}
#[test]
fn two_regions() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x4000);
assert!(GuestMemory::new(&vec![(start_addr1, 0x4000), (start_addr2, 0x4000)]).is_ok());
assert!(GuestMemory::new(&[(start_addr1, 0x4000), (start_addr2, 0x4000)]).is_ok());
}
#[test]
fn overlap_memory() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
assert!(GuestMemory::new(&vec![(start_addr1, 0x2000), (start_addr2, 0x2000)]).is_err());
assert!(GuestMemory::new(&[(start_addr1, 0x2000), (start_addr2, 0x2000)]).is_err());
}
#[test]
fn region_hole() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x4000);
let gm = GuestMemory::new(&vec![(start_addr1, 0x2000), (start_addr2, 0x2000)]).unwrap();
let gm = GuestMemory::new(&[(start_addr1, 0x2000), (start_addr2, 0x2000)]).unwrap();
assert_eq!(gm.address_in_range(GuestAddress(0x1000)), true);
assert_eq!(gm.address_in_range(GuestAddress(0x3000)), false);
assert_eq!(gm.address_in_range(GuestAddress(0x5000)), true);
@ -747,7 +747,7 @@ mod tests {
fn test_read_u64() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
let gm = GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let gm = GuestMemory::new(&[(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let val1: u64 = 0xaa55aa55aa55aa55;
let val2: u64 = 0x55aa55aa55aa55aa;
@ -764,7 +764,7 @@ mod tests {
fn test_ref_load_u64() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
let gm = GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let gm = GuestMemory::new(&[(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let val1: u64 = 0xaa55aa55aa55aa55;
let val2: u64 = 0x55aa55aa55aa55aa;
@ -784,7 +784,7 @@ mod tests {
fn test_ref_store_u64() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
let gm = GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let gm = GuestMemory::new(&[(start_addr1, 0x1000), (start_addr2, 0x1000)]).unwrap();
let val1: u64 = 0xaa55aa55aa55aa55;
let val2: u64 = 0x55aa55aa55aa55aa;
@ -804,11 +804,8 @@ mod tests {
let size_region1 = 0x1000;
let start_region2 = GuestAddress(0x10000);
let size_region2 = 0x2000;
let gm = GuestMemory::new(&vec![
(start_region1, size_region1),
(start_region2, size_region2),
])
.unwrap();
let gm = GuestMemory::new(&[(start_region1, size_region1), (start_region2, size_region2)])
.unwrap();
let mem_size = gm.memory_size();
assert_eq!(mem_size, size_region1 + size_region2);
@ -823,7 +820,7 @@ mod tests {
fn guest_to_host() {
let start_addr1 = GuestAddress(0x0);
let start_addr2 = GuestAddress(0x1000);
let mem = GuestMemory::new(&vec![(start_addr1, 0x1000), (start_addr2, 0x4000)]).unwrap();
let mem = GuestMemory::new(&[(start_addr1, 0x1000), (start_addr2, 0x4000)]).unwrap();
// Verify the host addresses match what we expect from the mappings.
let addr1_base = get_mapping(&mem, start_addr1).unwrap();
@ -848,11 +845,8 @@ mod tests {
let size_region1 = 0x1000;
let start_region2 = GuestAddress(0x10000);
let size_region2 = 0x2000;
let gm = GuestMemory::new(&vec![
(start_region1, size_region1),
(start_region2, size_region2),
])
.unwrap();
let gm = GuestMemory::new(&[(start_region1, size_region1), (start_region2, size_region2)])
.unwrap();
gm.write_obj_at_addr(0x1337u16, GuestAddress(0x0)).unwrap();
gm.write_obj_at_addr(0x0420u16, GuestAddress(0x10000))