diff options
Diffstat (limited to 'src/libstd/fs.rs')
| -rw-r--r-- | src/libstd/fs.rs | 335 |
1 files changed, 204 insertions, 131 deletions
diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs index 30db6a58d40..e5cf022f044 100644 --- a/src/libstd/fs.rs +++ b/src/libstd/fs.rs @@ -9,12 +9,12 @@ #![stable(feature = "rust1", since = "1.0.0")] -use crate::fmt; use crate::ffi::OsString; -use crate::io::{self, SeekFrom, Seek, Read, Initializer, Write, IoSlice, IoSliceMut}; +use crate::fmt; +use crate::io::{self, Initializer, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write}; use crate::path::{Path, PathBuf}; use crate::sys::fs as fs_imp; -use crate::sys_common::{AsInnerMut, FromInner, AsInner, IntoInner}; +use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner}; use crate::time::SystemTime; /// A reference to an open file on the filesystem. @@ -585,9 +585,7 @@ impl File { /// ``` #[stable(feature = "file_try_clone", since = "1.9.0")] pub fn try_clone(&self) -> io::Result<File> { - Ok(File { - inner: self.inner.duplicate()? - }) + Ok(File { inner: self.inner.duplicate()? }) } /// Changes the permissions on the underlying file. @@ -629,7 +627,9 @@ impl File { } impl AsInner<fs_imp::File> for File { - fn as_inner(&self) -> &fs_imp::File { &self.inner } + fn as_inner(&self) -> &fs_imp::File { + &self.inner + } } impl FromInner<fs_imp::File> for File { fn from_inner(f: fs_imp::File) -> File { @@ -674,7 +674,9 @@ impl Write for File { self.inner.write_vectored(bufs) } - fn flush(&mut self) -> io::Result<()> { self.inner.flush() } + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } } #[stable(feature = "rust1", since = "1.0.0")] impl Seek for File { @@ -707,7 +709,9 @@ impl Write for &File { self.inner.write_vectored(bufs) } - fn flush(&mut self) -> io::Result<()> { self.inner.flush() } + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } } #[stable(feature = "rust1", since = "1.0.0")] impl Seek for &File { @@ -748,7 +752,8 @@ impl OpenOptions { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn read(&mut self, read: bool) -> &mut OpenOptions { - self.0.read(read); self + self.0.read(read); + self } /// Sets the option for write access. @@ -768,7 +773,8 @@ impl OpenOptions { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn write(&mut self, write: bool) -> &mut OpenOptions { - self.0.write(write); self + self.0.write(write); + self } /// Sets the option for the append mode. @@ -814,7 +820,8 @@ impl OpenOptions { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn append(&mut self, append: bool) -> &mut OpenOptions { - self.0.append(append); self + self.0.append(append); + self } /// Sets the option for truncating a previous file. @@ -833,7 +840,8 @@ impl OpenOptions { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions { - self.0.truncate(truncate); self + self.0.truncate(truncate); + self } /// Sets the option for creating a new file. @@ -856,7 +864,8 @@ impl OpenOptions { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn create(&mut self, create: bool) -> &mut OpenOptions { - self.0.create(create); self + self.0.create(create); + self } /// Sets the option to always create a new file. @@ -889,7 +898,8 @@ impl OpenOptions { /// ``` #[stable(feature = "expand_open_options2", since = "1.9.0")] pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions { - self.0.create_new(create_new); self + self.0.create_new(create_new); + self } /// Opens a file at `path` with the options specified by `self`. @@ -946,11 +956,15 @@ impl OpenOptions { } impl AsInner<fs_imp::OpenOptions> for OpenOptions { - fn as_inner(&self) -> &fs_imp::OpenOptions { &self.0 } + fn as_inner(&self) -> &fs_imp::OpenOptions { + &self.0 + } } impl AsInnerMut<fs_imp::OpenOptions> for OpenOptions { - fn as_inner_mut(&mut self) -> &mut fs_imp::OpenOptions { &mut self.0 } + fn as_inner_mut(&mut self) -> &mut fs_imp::OpenOptions { + &mut self.0 + } } impl Metadata { @@ -994,7 +1008,9 @@ impl Metadata { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_dir(&self) -> bool { self.file_type().is_dir() } + pub fn is_dir(&self) -> bool { + self.file_type().is_dir() + } /// Returns `true` if this metadata is for a regular file. The /// result is mutually exclusive to the result of @@ -1017,7 +1033,9 @@ impl Metadata { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_file(&self) -> bool { self.file_type().is_file() } + pub fn is_file(&self) -> bool { + self.file_type().is_file() + } /// Returns the size of the file, in bytes, this metadata is for. /// @@ -1034,7 +1052,9 @@ impl Metadata { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> u64 { self.0.size() } + pub fn len(&self) -> u64 { + self.0.size() + } /// Returns the permissions of the file this metadata is for. /// @@ -1170,11 +1190,15 @@ impl fmt::Debug for Metadata { } impl AsInner<fs_imp::FileAttr> for Metadata { - fn as_inner(&self) -> &fs_imp::FileAttr { &self.0 } + fn as_inner(&self) -> &fs_imp::FileAttr { + &self.0 + } } impl FromInner<fs_imp::FileAttr> for Metadata { - fn from_inner(attr: fs_imp::FileAttr) -> Metadata { Metadata(attr) } + fn from_inner(attr: fs_imp::FileAttr) -> Metadata { + Metadata(attr) + } } impl Permissions { @@ -1194,7 +1218,9 @@ impl Permissions { /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] - pub fn readonly(&self) -> bool { self.0.readonly() } + pub fn readonly(&self) -> bool { + self.0.readonly() + } /// Modifies the readonly flag for this set of permissions. If the /// `readonly` argument is `true`, using the resulting `Permission` will @@ -1256,7 +1282,9 @@ impl FileType { /// } /// ``` #[stable(feature = "file_type", since = "1.1.0")] - pub fn is_dir(&self) -> bool { self.0.is_dir() } + pub fn is_dir(&self) -> bool { + self.0.is_dir() + } /// Tests whether this file type represents a regular file. /// The result is mutually exclusive to the results of @@ -1280,7 +1308,9 @@ impl FileType { /// } /// ``` #[stable(feature = "file_type", since = "1.1.0")] - pub fn is_file(&self) -> bool { self.0.is_file() } + pub fn is_file(&self) -> bool { + self.0.is_file() + } /// Tests whether this file type represents a symbolic link. /// The result is mutually exclusive to the results of @@ -1314,11 +1344,15 @@ impl FileType { /// } /// ``` #[stable(feature = "file_type", since = "1.1.0")] - pub fn is_symlink(&self) -> bool { self.0.is_symlink() } + pub fn is_symlink(&self) -> bool { + self.0.is_symlink() + } } impl AsInner<fs_imp::FileType> for FileType { - fn as_inner(&self) -> &fs_imp::FileType { &self.0 } + fn as_inner(&self) -> &fs_imp::FileType { + &self.0 + } } impl FromInner<fs_imp::FilePermissions> for Permissions { @@ -1328,7 +1362,9 @@ impl FromInner<fs_imp::FilePermissions> for Permissions { } impl AsInner<fs_imp::FilePermissions> for Permissions { - fn as_inner(&self) -> &fs_imp::FilePermissions { &self.0 } + fn as_inner(&self) -> &fs_imp::FilePermissions { + &self.0 + } } #[stable(feature = "rust1", since = "1.0.0")] @@ -1370,7 +1406,9 @@ impl DirEntry { /// /// The exact text, of course, depends on what files you have in `.`. #[stable(feature = "rust1", since = "1.0.0")] - pub fn path(&self) -> PathBuf { self.0.path() } + pub fn path(&self) -> PathBuf { + self.0.path() + } /// Returns the metadata for the file that this entry points at. /// @@ -1468,14 +1506,14 @@ impl DirEntry { #[stable(feature = "dir_entry_debug", since = "1.13.0")] impl fmt::Debug for DirEntry { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_tuple("DirEntry") - .field(&self.path()) - .finish() + f.debug_tuple("DirEntry").field(&self.path()).finish() } } impl AsInner<fs_imp::DirEntry> for DirEntry { - fn as_inner(&self) -> &fs_imp::DirEntry { &self.0 } + fn as_inner(&self) -> &fs_imp::DirEntry { + &self.0 + } } /// Removes a file from the filesystem. @@ -1744,9 +1782,11 @@ pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<( /// } /// ``` #[stable(feature = "rust1", since = "1.0.0")] -#[rustc_deprecated(since = "1.1.0", - reason = "replaced with std::os::unix::fs::symlink and \ - std::os::windows::fs::{symlink_file, symlink_dir}")] +#[rustc_deprecated( + since = "1.1.0", + reason = "replaced with std::os::unix::fs::symlink and \ + std::os::windows::fs::{symlink_file, symlink_dir}" +)] pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> { fs_imp::symlink(src.as_ref(), dst.as_ref()) } @@ -2089,8 +2129,7 @@ pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> { /// } /// ``` #[stable(feature = "set_permissions", since = "1.1.0")] -pub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) - -> io::Result<()> { +pub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) -> io::Result<()> { fs_imp::set_perm(path.as_ref(), perm.0) } @@ -2107,10 +2146,7 @@ impl DirBuilder { /// ``` #[stable(feature = "dir_builder", since = "1.6.0")] pub fn new() -> DirBuilder { - DirBuilder { - inner: fs_imp::DirBuilder::new(), - recursive: false, - } + DirBuilder { inner: fs_imp::DirBuilder::new(), recursive: false } } /// Indicates that directories should be created recursively, creating all @@ -2157,16 +2193,12 @@ impl DirBuilder { } fn _create(&self, path: &Path) -> io::Result<()> { - if self.recursive { - self.create_dir_all(path) - } else { - self.inner.mkdir(path) - } + if self.recursive { self.create_dir_all(path) } else { self.inner.mkdir(path) } } fn create_dir_all(&self, path: &Path) -> io::Result<()> { if path == Path::new("") { - return Ok(()) + return Ok(()); } match self.inner.mkdir(path) { @@ -2177,7 +2209,9 @@ impl DirBuilder { } match path.parent() { Some(p) => self.create_dir_all(p)?, - None => return Err(io::Error::new(io::ErrorKind::Other, "failed to create whole tree")), + None => { + return Err(io::Error::new(io::ErrorKind::Other, "failed to create whole tree")); + } } match self.inner.mkdir(path) { Ok(()) => Ok(()), @@ -2201,48 +2235,62 @@ mod tests { use crate::io::{ErrorKind, SeekFrom}; use crate::path::Path; use crate::str; - use crate::sys_common::io::test::{TempDir, tmpdir}; + use crate::sys_common::io::test::{tmpdir, TempDir}; use crate::thread; use rand::{rngs::StdRng, RngCore, SeedableRng}; - #[cfg(windows)] - use crate::os::windows::fs::{symlink_dir, symlink_file}; - #[cfg(windows)] - use crate::sys::fs::symlink_junction; #[cfg(unix)] use crate::os::unix::fs::symlink as symlink_dir; #[cfg(unix)] use crate::os::unix::fs::symlink as symlink_file; #[cfg(unix)] use crate::os::unix::fs::symlink as symlink_junction; + #[cfg(windows)] + use crate::os::windows::fs::{symlink_dir, symlink_file}; + #[cfg(windows)] + use crate::sys::fs::symlink_junction; - macro_rules! check { ($e:expr) => ( - match $e { - Ok(t) => t, - Err(e) => panic!("{} failed with: {}", stringify!($e), e), - } - ) } + macro_rules! check { + ($e:expr) => { + match $e { + Ok(t) => t, + Err(e) => panic!("{} failed with: {}", stringify!($e), e), + } + }; + } #[cfg(windows)] - macro_rules! error { ($e:expr, $s:expr) => ( - match $e { - Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), - Err(ref err) => assert!(err.raw_os_error() == Some($s), - format!("`{}` did not have a code of `{}`", err, $s)) - } - ) } + macro_rules! error { + ($e:expr, $s:expr) => { + match $e { + Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), + Err(ref err) => assert!( + err.raw_os_error() == Some($s), + format!("`{}` did not have a code of `{}`", err, $s) + ), + } + }; + } #[cfg(unix)] - macro_rules! error { ($e:expr, $s:expr) => ( error_contains!($e, $s) ) } - - macro_rules! error_contains { ($e:expr, $s:expr) => ( - match $e { - Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), - Err(ref err) => assert!(err.to_string().contains($s), - format!("`{}` did not contain `{}`", err, $s)) - } - ) } + macro_rules! error { + ($e:expr, $s:expr) => { + error_contains!($e, $s) + }; + } + + macro_rules! error_contains { + ($e:expr, $s:expr) => { + match $e { + Ok(_) => panic!("Unexpected success. Should've been: {:?}", $s), + Err(ref err) => assert!( + err.to_string().contains($s), + format!("`{}` did not contain `{}`", err, $s) + ), + } + }; + } // Several test fail on windows if the user does not have permission to // create symlinks (the `SeCreateSymbolicLinkPrivilege`). Instead of @@ -2251,7 +2299,9 @@ mod tests { // tests most of the time, but at least we do if the user has the right // permissions. pub fn got_symlink_permission(tmpdir: &TempDir) -> bool { - if cfg!(unix) { return true } + if cfg!(unix) { + return true; + } let link = tmpdir.join("some_hopefully_unique_link_name"); match symlink_file(r"nonexisting_target", link) { @@ -2276,7 +2326,7 @@ mod tests { let mut read_buf = [0; 1028]; let read_str = match check!(read_stream.read(&mut read_buf)) { 0 => panic!("shouldn't happen"), - n => str::from_utf8(&read_buf[..n]).unwrap().to_string() + n => str::from_utf8(&read_buf[..n]).unwrap().to_string(), }; assert_eq!(read_str, message); } @@ -2363,9 +2413,9 @@ mod tests { #[test] fn file_test_io_seek_and_write() { - let initial_msg = "food-is-yummy"; - let overwrite_msg = "-the-bar!!"; - let final_msg = "foo-the-bar!!"; + let initial_msg = "food-is-yummy"; + let overwrite_msg = "-the-bar!!"; + let final_msg = "foo-the-bar!!"; let seek_idx = 3; let mut read_mem = [0; 13]; let tmpdir = tmpdir(); @@ -2388,7 +2438,7 @@ mod tests { #[test] fn file_test_io_seek_shakedown() { // 01234567890123 - let initial_msg = "qwer-asdf-zxcv"; + let initial_msg = "qwer-asdf-zxcv"; let chunk_one: &str = "qwer"; let chunk_two: &str = "asdf"; let chunk_three: &str = "zxcv"; @@ -2497,13 +2547,11 @@ mod tests { check!(fs::create_dir(filename)); let mask = 0o7777; - check!(fs::set_permissions(filename, - fs::Permissions::from_mode(0))); + check!(fs::set_permissions(filename, fs::Permissions::from_mode(0))); let metadata0 = check!(fs::metadata(filename)); assert_eq!(mask & metadata0.permissions().mode(), 0); - check!(fs::set_permissions(filename, - fs::Permissions::from_mode(0o1777))); + check!(fs::set_permissions(filename, fs::Permissions::from_mode(0o1777))); let metadata1 = check!(fs::metadata(filename)); assert_eq!(mask & metadata1.permissions().mode(), 0o1777); } @@ -2568,8 +2616,7 @@ mod tests { let filename = &tmpdir.join("file_stat_correct_on_is_file.txt"); { let mut opts = OpenOptions::new(); - let mut fs = check!(opts.read(true).write(true) - .create(true).open(filename)); + let mut fs = check!(opts.read(true).write(true).create(true).open(filename)); let msg = "hw"; fs.write(msg.as_bytes()).unwrap(); @@ -2703,7 +2750,7 @@ mod tests { for _ in 0..40 { dir = dir.join("a"); } - let mut join = vec!(); + let mut join = vec![]; for _ in 0..8 { let dir = dir.clone(); join.push(thread::spawn(move || { @@ -2771,7 +2818,9 @@ mod tests { #[cfg(windows)] fn recursive_rmdir_of_file_symlink() { let tmpdir = tmpdir(); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; let f1 = tmpdir.join("f1"); let f2 = tmpdir.join("f2"); @@ -2854,8 +2903,7 @@ mod tests { check!(check!(File::open(&out)).read_to_end(&mut v)); assert_eq!(v, b"hello"); - assert_eq!(check!(input.metadata()).permissions(), - check!(out.metadata()).permissions()); + assert_eq!(check!(input.metadata()).permissions(), check!(out.metadata()).permissions()); } #[test] @@ -2865,7 +2913,8 @@ mod tests { check!(File::create(&out)); match fs::copy(&*out, tmpdir.path()) { - Ok(..) => panic!(), Err(..) => {} + Ok(..) => panic!(), + Err(..) => {} } } @@ -2890,7 +2939,8 @@ mod tests { let out = tmpdir.join("out"); match fs::copy(tmpdir.path(), &out) { - Ok(..) => panic!(), Err(..) => {} + Ok(..) => panic!(), + Err(..) => {} } assert!(!out.exists()); } @@ -2938,7 +2988,9 @@ mod tests { #[test] fn copy_file_follows_dst_symlink() { let tmp = tmpdir(); - if !got_symlink_permission(&tmp) { return }; + if !got_symlink_permission(&tmp) { + return; + }; let in_path = tmp.join("in.txt"); let out_path = tmp.join("out.txt"); @@ -2958,7 +3010,9 @@ mod tests { #[test] fn symlinks_work() { let tmpdir = tmpdir(); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; let input = tmpdir.join("in.txt"); let out = tmpdir.join("out.txt"); @@ -2966,8 +3020,7 @@ mod tests { check!(check!(File::create(&input)).write("foobar".as_bytes())); check!(symlink_file(&input, &out)); assert!(check!(out.symlink_metadata()).file_type().is_symlink()); - assert_eq!(check!(fs::metadata(&out)).len(), - check!(fs::metadata(&input)).len()); + assert_eq!(check!(fs::metadata(&out)).len(), check!(fs::metadata(&input)).len()); let mut v = Vec::new(); check!(check!(File::open(&out)).read_to_end(&mut v)); assert_eq!(v, b"foobar".to_vec()); @@ -2977,31 +3030,40 @@ mod tests { fn symlink_noexist() { // Symlinks can point to things that don't exist let tmpdir = tmpdir(); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; // Use a relative path for testing. Symlinks get normalized by Windows, // so we may not get the same path back for absolute paths check!(symlink_file(&"foo", &tmpdir.join("bar"))); - assert_eq!(check!(fs::read_link(&tmpdir.join("bar"))).to_str().unwrap(), - "foo"); + assert_eq!(check!(fs::read_link(&tmpdir.join("bar"))).to_str().unwrap(), "foo"); } #[test] fn read_link() { if cfg!(windows) { // directory symlink - assert_eq!(check!(fs::read_link(r"C:\Users\All Users")).to_str().unwrap(), - r"C:\ProgramData"); + assert_eq!( + check!(fs::read_link(r"C:\Users\All Users")).to_str().unwrap(), + r"C:\ProgramData" + ); // junction - assert_eq!(check!(fs::read_link(r"C:\Users\Default User")).to_str().unwrap(), - r"C:\Users\Default"); + assert_eq!( + check!(fs::read_link(r"C:\Users\Default User")).to_str().unwrap(), + r"C:\Users\Default" + ); // junction with special permissions - assert_eq!(check!(fs::read_link(r"C:\Documents and Settings\")).to_str().unwrap(), - r"C:\Users"); + assert_eq!( + check!(fs::read_link(r"C:\Documents and Settings\")).to_str().unwrap(), + r"C:\Users" + ); } let tmpdir = tmpdir(); let link = tmpdir.join("link"); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; check!(symlink_file(&"foo", &link)); assert_eq!(check!(fs::read_link(&link)).to_str().unwrap(), "foo"); } @@ -3023,10 +3085,8 @@ mod tests { check!(check!(File::create(&input)).write("foobar".as_bytes())); check!(fs::hard_link(&input, &out)); - assert_eq!(check!(fs::metadata(&out)).len(), - check!(fs::metadata(&input)).len()); - assert_eq!(check!(fs::metadata(&out)).len(), - check!(input.metadata()).len()); + assert_eq!(check!(fs::metadata(&out)).len(), check!(fs::metadata(&input)).len()); + assert_eq!(check!(fs::metadata(&out)).len(), check!(input.metadata()).len()); let mut v = Vec::new(); check!(check!(File::open(&out)).read_to_end(&mut v)); assert_eq!(v, b"foobar".to_vec()); @@ -3134,15 +3194,22 @@ mod tests { #[test] fn open_flavors() { use crate::fs::OpenOptions as OO; - fn c<T: Clone>(t: &T) -> T { t.clone() } + fn c<T: Clone>(t: &T) -> T { + t.clone() + } let tmpdir = tmpdir(); - let mut r = OO::new(); r.read(true); - let mut w = OO::new(); w.write(true); - let mut rw = OO::new(); rw.read(true).write(true); - let mut a = OO::new(); a.append(true); - let mut ra = OO::new(); ra.read(true).append(true); + let mut r = OO::new(); + r.read(true); + let mut w = OO::new(); + w.write(true); + let mut rw = OO::new(); + rw.read(true).write(true); + let mut a = OO::new(); + a.append(true); + let mut ra = OO::new(); + ra.read(true).append(true); #[cfg(windows)] let invalid_options = 87; // ERROR_INVALID_PARAMETER @@ -3201,7 +3268,7 @@ mod tests { // Test opening a file without setting an access mode let mut blank = OO::new(); - error!(blank.create(true).open(&tmpdir.join("f")), invalid_options); + error!(blank.create(true).open(&tmpdir.join("f")), invalid_options); // Test write works check!(check!(File::create(&tmpdir.join("h"))).write("foobar".as_bytes())); @@ -3279,8 +3346,10 @@ mod tests { assert!(v == &bytes[..]); check!(fs::write(&tmpdir.join("not-utf8"), &[0xFF])); - error_contains!(fs::read_to_string(&tmpdir.join("not-utf8")), - "stream did not contain valid UTF-8"); + error_contains!( + fs::read_to_string(&tmpdir.join("not-utf8")), + "stream did not contain valid UTF-8" + ); let s = "𐁁𐀓𐀠𐀴𐀍"; check!(fs::write(&tmpdir.join("utf8"), s.as_bytes())); @@ -3292,11 +3361,9 @@ mod tests { fn file_try_clone() { let tmpdir = tmpdir(); - let mut f1 = check!(OpenOptions::new() - .read(true) - .write(true) - .create(true) - .open(&tmpdir.join("test"))); + let mut f1 = check!( + OpenOptions::new().read(true).write(true).create(true).open(&tmpdir.join("test")) + ); let mut f2 = check!(f1.try_clone()); check!(f1.write_all(b"hello world")); @@ -3341,7 +3408,9 @@ mod tests { #[test] fn realpath_works() { let tmpdir = tmpdir(); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; let tmpdir = fs::canonicalize(tmpdir.path()).unwrap(); let file = tmpdir.join("test"); @@ -3366,7 +3435,9 @@ mod tests { #[test] fn realpath_works_tricky() { let tmpdir = tmpdir(); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; let tmpdir = fs::canonicalize(tmpdir.path()).unwrap(); let a = tmpdir.join("a"); @@ -3452,7 +3523,9 @@ mod tests { assert!(junction.is_dir()); assert!(b.exists()); - if !got_symlink_permission(&tmpdir) { return }; + if !got_symlink_permission(&tmpdir) { + return; + }; check!(symlink_dir(&target, &link)); check!(fs::create_dir_all(&d)); assert!(link.is_dir()); @@ -3482,8 +3555,8 @@ mod tests { // Not always available match (a.created(), b.created()) { (Ok(t1), Ok(t2)) => assert!(t1 <= t2), - (Err(e1), Err(e2)) if e1.kind() == ErrorKind::Other && - e2.kind() == ErrorKind::Other => {} + (Err(e1), Err(e2)) + if e1.kind() == ErrorKind::Other && e2.kind() == ErrorKind::Other => {} (a, b) => panic!( "creation time must be always supported or not supported: {:?} {:?}", a, b, |