From 7b7d9540056f6378820caf955a0335268184d6b7 Mon Sep 17 00:00:00 2001 From: Alan Somers Date: Sun, 30 May 2021 12:27:39 -0600 Subject: misc Clippy cleanup * Fix race conditions in the tests. Two tests were grabbing a mutex but immediately dropping it. Thank you, Clippy. * Remove vestigial Windows support. Remove some code added to support Windows in 2015. Nix is no longer intended to ever run on Windows. * Various other minor Clippy lints. --- src/errno.rs | 2 +- src/fcntl.rs | 6 +++--- src/sys/aio.rs | 8 +++++-- src/sys/ptrace/bsd.rs | 16 +++++++------- src/sys/select.rs | 2 -- src/sys/socket/mod.rs | 2 +- src/time.rs | 6 +++--- src/unistd.rs | 54 +++++++++++++++++++++--------------------------- test/sys/test_ioctl.rs | 16 +++++++------- test/sys/test_signal.rs | 11 +++++----- test/sys/test_socket.rs | 47 +++++++++++++++++++---------------------- test/sys/test_sockopt.rs | 2 +- test/sys/test_uio.rs | 2 +- test/sys/test_wait.rs | 2 +- test/test_net.rs | 2 +- test/test_stat.rs | 14 ------------- test/test_unistd.rs | 2 +- 17 files changed, 83 insertions(+), 111 deletions(-) diff --git a/src/errno.rs b/src/errno.rs index 0e8839e6..9275febe 100644 --- a/src/errno.rs +++ b/src/errno.rs @@ -94,7 +94,7 @@ impl ErrnoSentinel for i64 { } impl ErrnoSentinel for *mut c_void { - fn sentinel() -> Self { (-1 as isize) as *mut c_void } + fn sentinel() -> Self { -1isize as *mut c_void } } impl ErrnoSentinel for libc::sighandler_t { diff --git a/src/fcntl.rs b/src/fcntl.rs index 2532724b..ce30b7d1 100644 --- a/src/fcntl.rs +++ b/src/fcntl.rs @@ -166,7 +166,7 @@ libc_bitflags!( ); // The conversion is not identical on all operating systems. -#[allow(clippy::identity_conversion)] +#[allow(clippy::useless_conversion)] pub fn open(path: &P, oflag: OFlag, mode: Mode) -> Result { let fd = path.with_nix_path(|cstr| { unsafe { libc::open(cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint) } @@ -176,7 +176,7 @@ pub fn open(path: &P, oflag: OFlag, mode: Mode) -> Result( dirfd: RawFd, @@ -264,7 +264,7 @@ fn inner_readlink(dirfd: Option, path: &P) -> Result Some(dirfd) => super::sys::stat::fstatat(dirfd, path, AtFlags::AT_SYMLINK_NOFOLLOW), None => super::sys::stat::lstat(path) } - .and_then(|x| Ok(x.st_size)) + .map(|x| x.st_size) .unwrap_or(0); let mut try_size = if reported_size > 0 { // Note: even if `lstat`'s apparently valid answer turns out to be diff --git a/src/sys/aio.rs b/src/sys/aio.rs index 7868a294..a03caa45 100644 --- a/src/sys/aio.rs +++ b/src/sys/aio.rs @@ -513,7 +513,7 @@ impl<'a> AioCb<'a> { } } - fn error_unpinned(self: &mut Self) -> Result<()> { + fn error_unpinned(&mut self) -> Result<()> { let r = unsafe { libc::aio_error(&mut self.aiocb.0 as *mut libc::aiocb) }; @@ -645,7 +645,7 @@ impl<'a> AioCb<'a> { SigEvent::from(&self.aiocb.0.aio_sigevent) } - fn aio_return_unpinned(self: &mut Self) -> Result { + fn aio_return_unpinned(&mut self) -> Result { unsafe { let p: *mut libc::aiocb = &mut self.aiocb.0; self.in_progress = false; @@ -838,6 +838,10 @@ unsafe impl<'a> Sync for LioCb<'a> {} #[cfg(not(any(target_os = "ios", target_os = "macos")))] impl<'a> LioCb<'a> { + pub fn is_empty(&self) -> bool { + self.aiocbs.is_empty() + } + /// Return the number of individual [`AioCb`]s contained. pub fn len(&self) -> usize { self.aiocbs.len() diff --git a/src/sys/ptrace/bsd.rs b/src/sys/ptrace/bsd.rs index e85afc76..141dfbc4 100644 --- a/src/sys/ptrace/bsd.rs +++ b/src/sys/ptrace/bsd.rs @@ -133,16 +133,14 @@ pub fn kill(pid: Pid) -> Result<()> { /// use nix::unistd::Pid; /// use nix::sys::signal::Signal; /// use nix::sys::wait::*; -/// fn main() { -/// // If a process changes state to the stopped state because of a SIGUSR1 -/// // signal, this will step the process forward and forward the user -/// // signal to the stopped process -/// match waitpid(Pid::from_raw(-1), None) { -/// Ok(WaitStatus::Stopped(pid, Signal::SIGUSR1)) => { -/// let _ = step(pid, Signal::SIGUSR1); -/// } -/// _ => {}, +/// // If a process changes state to the stopped state because of a SIGUSR1 +/// // signal, this will step the process forward and forward the user +/// // signal to the stopped process +/// match waitpid(Pid::from_raw(-1), None) { +/// Ok(WaitStatus::Stopped(pid, Signal::SIGUSR1)) => { +/// let _ = step(pid, Signal::SIGUSR1); /// } +/// _ => {}, /// } /// ``` #[cfg( diff --git a/src/sys/select.rs b/src/sys/select.rs index 19ae2f1c..5eb64234 100644 --- a/src/sys/select.rs +++ b/src/sys/select.rs @@ -50,12 +50,10 @@ impl FdSet { /// /// ``` /// # use nix::sys::select::FdSet; - /// # fn main() { /// let mut set = FdSet::new(); /// set.insert(4); /// set.insert(9); /// assert_eq!(set.highest(), Some(9)); - /// # } /// ``` /// /// [`select`]: fn.select.html diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index e4baeb5d..69070463 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -710,7 +710,7 @@ impl ControlMessageOwned { }, (_, _) => { let sl = slice::from_raw_parts(p, len); - let ucmsg = UnknownCmsg(*header, Vec::::from(&sl[..])); + let ucmsg = UnknownCmsg(*header, Vec::::from(sl)); ControlMessageOwned::Unknown(ucmsg) } } diff --git a/src/time.rs b/src/time.rs index e6c3f8de..f7da654a 100644 --- a/src/time.rs +++ b/src/time.rs @@ -185,9 +185,9 @@ impl ClockId { pub const CLOCK_VIRTUAL: ClockId = ClockId(libc::CLOCK_VIRTUAL); } -impl Into for ClockId { - fn into(self) -> clockid_t { - self.as_raw() +impl From for clockid_t { + fn from(clock_id: ClockId) -> Self { + clock_id.as_raw() } } diff --git a/src/unistd.rs b/src/unistd.rs index 11907fa9..8e361bad 100644 --- a/src/unistd.rs +++ b/src/unistd.rs @@ -450,15 +450,13 @@ pub fn fchdir(dirfd: RawFd) -> Result<()> { /// use nix::sys::stat; /// use tempfile::tempdir; /// -/// fn main() { -/// let tmp_dir1 = tempdir().unwrap(); -/// let tmp_dir2 = tmp_dir1.path().join("new_dir"); -/// -/// // create new directory and give read, write and execute rights to the owner -/// match unistd::mkdir(&tmp_dir2, stat::Mode::S_IRWXU) { -/// Ok(_) => println!("created {:?}", tmp_dir2), -/// Err(err) => println!("Error creating directory: {}", err), -/// } +/// let tmp_dir1 = tempdir().unwrap(); +/// let tmp_dir2 = tmp_dir1.path().join("new_dir"); +/// +/// // create new directory and give read, write and execute rights to the owner +/// match unistd::mkdir(&tmp_dir2, stat::Mode::S_IRWXU) { +/// Ok(_) => println!("created {:?}", tmp_dir2), +/// Err(err) => println!("Error creating directory: {}", err), /// } /// ``` #[inline] @@ -490,15 +488,13 @@ pub fn mkdir(path: &P, mode: Mode) -> Result<()> { /// use nix::sys::stat; /// use tempfile::tempdir; /// -/// fn main() { -/// let tmp_dir = tempdir().unwrap(); -/// let fifo_path = tmp_dir.path().join("foo.pipe"); +/// let tmp_dir = tempdir().unwrap(); +/// let fifo_path = tmp_dir.path().join("foo.pipe"); /// -/// // create new fifo and give read, write and execute rights to the owner -/// match unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) { -/// Ok(_) => println!("created {:?}", fifo_path), -/// Err(err) => println!("Error creating fifo: {}", err), -/// } +/// // create new fifo and give read, write and execute rights to the owner +/// match unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) { +/// Ok(_) => println!("created {:?}", fifo_path), +/// Err(err) => println!("Error creating fifo: {}", err), /// } /// ``` #[inline] @@ -587,11 +583,9 @@ fn reserve_double_buffer_size(buf: &mut Vec, limit: usize) -> Result<()> { /// ```rust /// use nix::unistd; /// -/// fn main() { -/// // assume that we are allowed to get current directory -/// let dir = unistd::getcwd().unwrap(); -/// println!("The current directory is {:?}", dir); -/// } +/// // assume that we are allowed to get current directory +/// let dir = unistd::getcwd().unwrap(); +/// println!("The current directory is {:?}", dir); /// ``` #[inline] pub fn getcwd() -> Result { @@ -624,6 +618,8 @@ pub fn getcwd() -> Result { } /// Computes the raw UID and GID values to pass to a `*chown` call. +// The cast is not unnecessary on all platforms. +#[allow(clippy::unnecessary_cast)] fn chown_raw_ids(owner: Option, group: Option) -> (libc::uid_t, libc::gid_t) { // According to the POSIX specification, -1 is used to indicate that owner and group // are not to be changed. Since uid_t and gid_t are unsigned types, we have to wrap @@ -969,20 +965,16 @@ pub fn gethostname(buffer: &mut [u8]) -> Result<&CStr> { /// use std::os::unix::io::AsRawFd; /// use nix::unistd::close; /// -/// fn main() { -/// let f = tempfile::tempfile().unwrap(); -/// close(f.as_raw_fd()).unwrap(); // Bad! f will also close on drop! -/// } +/// let f = tempfile::tempfile().unwrap(); +/// close(f.as_raw_fd()).unwrap(); // Bad! f will also close on drop! /// ``` /// /// ```rust /// use std::os::unix::io::IntoRawFd; /// use nix::unistd::close; /// -/// fn main() { -/// let f = tempfile::tempfile().unwrap(); -/// close(f.into_raw_fd()).unwrap(); // Good. into_raw_fd consumes f -/// } +/// let f = tempfile::tempfile().unwrap(); +/// close(f.into_raw_fd()).unwrap(); // Good. into_raw_fd consumes f /// ``` pub fn close(fd: RawFd) -> Result<()> { let res = unsafe { libc::close(fd) }; @@ -1563,7 +1555,7 @@ pub fn getgrouplist(user: &CStr, group: Gid) -> Result> { // groups as possible, but Linux manpages do not mention this // behavior. reserve_double_buffer_size(&mut groups, ngroups_max as usize) - .or_else(|_| Err(Error::invalid_argument()))?; + .map_err(|_| Error::invalid_argument())?; } } } diff --git a/test/sys/test_ioctl.rs b/test/sys/test_ioctl.rs index fa4510a6..ddb86968 100644 --- a/test/sys/test_ioctl.rs +++ b/test/sys/test_ioctl.rs @@ -56,10 +56,10 @@ mod linux { #[test] fn test_op_write_64() { if cfg!(any(target_arch = "mips64", target_arch="powerpc64")){ - assert_eq!(request_code_write!(b'z', 10, (1 as u64) << 32) as u32, + assert_eq!(request_code_write!(b'z', 10, 1u64 << 32) as u32, 0x8000_7A0A); } else { - assert_eq!(request_code_write!(b'z', 10, (1 as u64) << 32) as u32, + assert_eq!(request_code_write!(b'z', 10, 1u64 << 32) as u32, 0x4000_7A0A); } @@ -80,10 +80,10 @@ mod linux { #[test] fn test_op_read_64() { if cfg!(any(target_arch = "mips64", target_arch="powerpc64")){ - assert_eq!(request_code_read!(b'z', 10, (1 as u64) << 32) as u32, + assert_eq!(request_code_read!(b'z', 10, 1u64 << 32) as u32, 0x4000_7A0A); } else { - assert_eq!(request_code_read!(b'z', 10, (1 as u64) << 32) as u32, + assert_eq!(request_code_read!(b'z', 10, 1u64 << 32) as u32, 0x8000_7A0A); } } @@ -97,7 +97,7 @@ mod linux { #[cfg(target_pointer_width = "64")] #[test] fn test_op_read_write_64() { - assert_eq!(request_code_readwrite!(b'z', 10, (1 as u64) << 32) as u32, + assert_eq!(request_code_readwrite!(b'z', 10, 1u64 << 32) as u32, 0xC000_7A0A); } } @@ -131,7 +131,7 @@ mod bsd { #[cfg(target_pointer_width = "64")] #[test] fn test_op_write_64() { - assert_eq!(request_code_write!(b'z', 10, (1 as u64) << 32), 0x8000_7A0A); + assert_eq!(request_code_write!(b'z', 10, 1u64 << 32), 0x8000_7A0A); } #[test] @@ -143,7 +143,7 @@ mod bsd { #[cfg(target_pointer_width = "64")] #[test] fn test_op_read_64() { - assert_eq!(request_code_read!(b'z', 10, (1 as u64) << 32), 0x4000_7A0A); + assert_eq!(request_code_read!(b'z', 10, 1u64 << 32), 0x4000_7A0A); } #[test] @@ -155,7 +155,7 @@ mod bsd { #[cfg(target_pointer_width = "64")] #[test] fn test_op_read_write_64() { - assert_eq!(request_code_readwrite!(b'z', 10, (1 as u64) << 32), 0xC000_7A0A); + assert_eq!(request_code_readwrite!(b'z', 10, 1u64 << 32), 0xC000_7A0A); } } diff --git a/test/sys/test_signal.rs b/test/sys/test_signal.rs index fdb7f36d..c8c13e52 100644 --- a/test/sys/test_signal.rs +++ b/test/sys/test_signal.rs @@ -1,4 +1,3 @@ -use libc; #[cfg(not(target_os = "redox"))] use nix::Error; use nix::sys::signal::*; @@ -53,9 +52,9 @@ fn test_sigprocmask() { // Make sure the old set doesn't contain the signal, otherwise the following // test don't make sense. - assert_eq!(old_signal_set.contains(SIGNAL), false, - "the {:?} signal is already blocked, please change to a \ - different one", SIGNAL); + assert!(!old_signal_set.contains(SIGNAL), + "the {:?} signal is already blocked, please change to a \ + different one", SIGNAL); // Now block the signal. let mut signal_set = SigSet::empty(); @@ -67,8 +66,8 @@ fn test_sigprocmask() { old_signal_set.clear(); sigprocmask(SigmaskHow::SIG_BLOCK, None, Some(&mut old_signal_set)) .expect("expect to be able to retrieve old signals"); - assert_eq!(old_signal_set.contains(SIGNAL), true, - "expected the {:?} to be blocked", SIGNAL); + assert!(old_signal_set.contains(SIGNAL), + "expected the {:?} to be blocked", SIGNAL); // Reset the signal. sigprocmask(SigmaskHow::SIG_UNBLOCK, Some(&signal_set), None) diff --git a/test/sys/test_socket.rs b/test/sys/test_socket.rs index 32318ef0..c22eaeb1 100644 --- a/test/sys/test_socket.rs +++ b/test/sys/test_socket.rs @@ -7,7 +7,6 @@ use std::path::Path; use std::slice; use std::str::FromStr; use libc::c_char; -use tempfile; #[cfg(any(target_os = "linux", target_os= "android"))] use crate::*; @@ -81,7 +80,7 @@ pub fn test_addr_equality_path() { let path = "/foo/bar"; let actual = Path::new(path); let addr1 = UnixAddr::new(actual).unwrap(); - let mut addr2 = addr1.clone(); + let mut addr2 = addr1; addr2.0.sun_path[10] = 127; @@ -168,7 +167,7 @@ mod recvfrom { use std::thread; use super::*; - const MSG: &'static [u8] = b"Hello, World!"; + const MSG: &[u8] = b"Hello, World!"; fn sendrecv(rsock: RawFd, ssock: RawFd, f_send: Fs, mut f_recv: Fr) -> Option where @@ -318,6 +317,7 @@ mod recvfrom { target_os = "freebsd", target_os = "netbsd", ))] + #[allow(clippy::vec_init_then_push)] #[test] pub fn udp_sendmmsg() { use nix::sys::uio::IoVec; @@ -367,7 +367,7 @@ mod recvfrom { } sendmmsg(s, msgs.iter(), flags) .map(move |sent_bytes| { - assert!(sent_bytes.len() >= 1); + assert!(!sent_bytes.is_empty()); for sent in &sent_bytes { assert_eq!(*sent, m.len()); } @@ -425,7 +425,7 @@ mod recvfrom { for iov in &iovs { msgs.push_back(RecvMmsgData { - iov: iov, + iov, cmsg_buffer: None, }) }; @@ -497,7 +497,7 @@ mod recvfrom { for iov in &iovs { msgs.push_back(RecvMmsgData { - iov: iov, + iov, cmsg_buffer: None, }) }; @@ -835,12 +835,9 @@ pub fn test_sendmsg_ipv6packetinfo() { let inet_addr = InetAddr::from_std(&std_sa); let sock_addr = SockAddr::new_inet(inet_addr); - match bind(sock, &sock_addr) { - Err(Error::Sys(Errno::EADDRNOTAVAIL)) => { - println!("IPv6 not available, skipping test."); - return; - }, - _ => (), + if let Err(Error::Sys(Errno::EADDRNOTAVAIL)) = bind(sock, &sock_addr) { + println!("IPv6 not available, skipping test."); + return; } let slice = [1u8, 2, 3, 4, 5, 6, 7, 8]; @@ -1399,8 +1396,8 @@ pub fn test_recvif() { _ => panic!("unexpected additional control msg"), } } - assert_eq!(rx_recvif, true); - assert_eq!(rx_recvdstaddr, true); + assert!(rx_recvif); + assert!(rx_recvdstaddr); assert_eq!(msg.bytes, 8); assert_eq!( iovec[0].as_slice(), @@ -1479,18 +1476,16 @@ pub fn test_recv_ipv6pktinfo() { ); let mut cmsgs = msg.cmsgs(); - match cmsgs.next() { - Some(ControlMessageOwned::Ipv6PacketInfo(pktinfo)) => { - let i = if_nametoindex(lo_name.as_bytes()).expect("if_nametoindex"); - assert_eq!( - pktinfo.ipi6_ifindex as libc::c_uint, - i, - "unexpected ifindex (expected {}, got {})", - i, - pktinfo.ipi6_ifindex - ); - }, - _ => (), + if let Some(ControlMessageOwned::Ipv6PacketInfo(pktinfo)) = cmsgs.next() + { + let i = if_nametoindex(lo_name.as_bytes()).expect("if_nametoindex"); + assert_eq!( + pktinfo.ipi6_ifindex as libc::c_uint, + i, + "unexpected ifindex (expected {}, got {})", + i, + pktinfo.ipi6_ifindex + ); } assert!(cmsgs.next().is_none(), "unexpected additional control msg"); assert_eq!(msg.bytes, 8); diff --git a/test/sys/test_sockopt.rs b/test/sys/test_sockopt.rs index d151cf55..e0ed0f7c 100644 --- a/test/sys/test_sockopt.rs +++ b/test/sys/test_sockopt.rs @@ -74,7 +74,7 @@ fn test_bindtodevice() { fn test_so_tcp_keepalive() { let fd = socket(AddressFamily::Inet, SockType::Stream, SockFlag::empty(), SockProtocol::Tcp).unwrap(); setsockopt(fd, sockopt::KeepAlive, &true).unwrap(); - assert_eq!(getsockopt(fd, sockopt::KeepAlive).unwrap(), true); + assert!(getsockopt(fd, sockopt::KeepAlive).unwrap()); #[cfg(any(target_os = "android", target_os = "dragonfly", diff --git a/test/sys/test_uio.rs b/test/sys/test_uio.rs index aede530a..9dd4f01d 100644 --- a/test/sys/test_uio.rs +++ b/test/sys/test_uio.rs @@ -214,7 +214,7 @@ fn test_process_vm_readv() { use crate::*; require_capability!(CAP_SYS_PTRACE); - let _ = crate::FORK_MTX.lock().expect("Mutex got poisoned by another test"); + let _m = crate::FORK_MTX.lock().expect("Mutex got poisoned by another test"); // Pre-allocate memory in the child, since allocation isn't safe // post-fork (~= async-signal-safe) diff --git a/test/sys/test_wait.rs b/test/sys/test_wait.rs index 5bb298eb..f68b8b08 100644 --- a/test/sys/test_wait.rs +++ b/test/sys/test_wait.rs @@ -8,7 +8,7 @@ use libc::_exit; #[test] #[cfg(not(target_os = "redox"))] fn test_wait_signal() { - let _ = crate::FORK_MTX.lock().expect("Mutex got poisoned by another test"); + let _m = crate::FORK_MTX.lock().expect("Mutex got poisoned by another test"); // Safe: The child only calls `pause` and/or `_exit`, which are async-signal-safe. match unsafe{fork()}.expect("Error: Fork Failed") { diff --git a/test/test_net.rs b/test/test_net.rs index b8940e71..40ecd6bb 100644 --- a/test/test_net.rs +++ b/test/test_net.rs @@ -8,5 +8,5 @@ const LOOPBACK: &[u8] = b"lo0"; #[test] fn test_if_nametoindex() { - assert!(if_nametoindex(&LOOPBACK[..]).is_ok()); + assert!(if_nametoindex(LOOPBACK).is_ok()); } diff --git a/test/test_stat.rs b/test/test_stat.rs index 98112d61..27fcee59 100644 --- a/test/test_stat.rs +++ b/test/test_stat.rs @@ -44,18 +44,6 @@ use nix::unistd::chdir; #[cfg(not(any(target_os = "netbsd", target_os = "redox")))] use nix::Result; -use tempfile; - -#[allow(unused_comparisons)] -// uid and gid are signed on Windows, but not on other platforms. This function -// allows warning free compiles on all platforms, and can be removed when -// expression-level #[allow] is available. -#[cfg(not(any(target_os = "netbsd", target_os = "redox")))] -fn valid_uid_gid(stat: FileStat) -> bool { - // uid could be 0 for the `root` user. This quite possible when - // the tests are being run on a rooted Android device. - stat.st_uid >= 0 && stat.st_gid >= 0 -} #[cfg(not(any(target_os = "netbsd", target_os = "redox")))] fn assert_stat_results(stat_result: Result) { @@ -64,7 +52,6 @@ fn assert_stat_results(stat_result: Result) { assert!(stats.st_ino > 0); // inode is positive integer, exact number machine dependent assert!(stats.st_mode > 0); // must be positive integer assert_eq!(stats.st_nlink, 1); // there links created, must be 1 - assert!(valid_uid_gid(stats)); // must be positive integers assert_eq!(stats.st_size, 0); // size is 0 because we did not write anything to the file assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent assert!(stats.st_blocks <= 16); // Up to 16 blocks can be allocated for a blank file @@ -84,7 +71,6 @@ fn assert_lstat_results(stat_result: Result) { // On other platforms they are the same (either both are u16 or u32). assert_eq!((stats.st_mode as usize) & (S_IFMT as usize), S_IFLNK as usize); // should be a link assert_eq!(stats.st_nlink, 1); // there links created, must be 1 - assert!(valid_uid_gid(stats)); // must be positive integers assert!(stats.st_size > 0); // size is > 0 because it points to another file assert!(stats.st_blksize > 0); // must be positive integer, exact number machine dependent diff --git a/test/test_unistd.rs b/test/test_unistd.rs index eb811e2d..73341947 100644 --- a/test/test_unistd.rs +++ b/test/test_unistd.rs @@ -441,7 +441,7 @@ fn test_getcwd() { // kicks in. Note: One path cannot be longer than 255 bytes // (NAME_MAX) whole path cannot be longer than PATH_MAX (usually // 4096 on linux, 1024 on macos) - let mut inner_tmp_dir = tmpdir_path.to_path_buf(); + let mut inner_tmp_dir = tmpdir_path; for _ in 0..5 { let newdir = iter::repeat("a").take(100).collect::(); inner_tmp_dir.push(newdir); -- cgit v1.2.3