2022-07-17 20:54:10 -05:00
|
|
|
//@ignore-target-windows: File handling is not implemented yet
|
2022-07-08 11:08:32 -05:00
|
|
|
//@compile-flags: -Zmiri-disable-isolation
|
2019-09-24 17:28:00 -05:00
|
|
|
|
2020-09-28 14:02:54 -05:00
|
|
|
#![feature(rustc_private)]
|
2022-03-07 17:30:12 -06:00
|
|
|
#![feature(io_error_more)]
|
2020-09-28 14:02:54 -05:00
|
|
|
|
|
|
|
use std::ffi::CString;
|
2022-02-22 16:06:05 -06:00
|
|
|
use std::fs::{
|
2022-07-02 11:26:00 -05:00
|
|
|
create_dir, read_dir, read_link, remove_dir, remove_dir_all, remove_file, rename, File,
|
|
|
|
OpenOptions,
|
2022-02-22 16:06:05 -06:00
|
|
|
};
|
2022-02-05 19:41:29 -06:00
|
|
|
use std::io::{Error, ErrorKind, Read, Result, Seek, SeekFrom, Write};
|
|
|
|
use std::path::{Path, PathBuf};
|
2020-09-28 14:02:54 -05:00
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
fn main() {
|
|
|
|
test_file();
|
|
|
|
test_file_clone();
|
2020-03-29 16:03:05 -05:00
|
|
|
test_file_create_new();
|
2020-02-17 22:36:33 -06:00
|
|
|
test_seek();
|
|
|
|
test_metadata();
|
2020-04-21 21:17:54 -05:00
|
|
|
test_file_set_len();
|
2020-05-19 08:57:31 -05:00
|
|
|
test_file_sync();
|
2020-02-17 22:36:33 -06:00
|
|
|
test_symlink();
|
|
|
|
test_errors();
|
|
|
|
test_rename();
|
2020-01-24 18:56:23 -06:00
|
|
|
test_directory();
|
2022-06-30 12:10:31 -05:00
|
|
|
test_canonicalize();
|
2020-10-03 11:56:32 -05:00
|
|
|
test_dup_stdout_stderr();
|
2022-02-05 19:41:29 -06:00
|
|
|
|
|
|
|
// These all require unix, if the test is changed to no longer `ignore-windows`, move these to a unix test
|
|
|
|
test_file_open_unix_allow_two_args();
|
|
|
|
test_file_open_unix_needs_three_args();
|
|
|
|
test_file_open_unix_extra_third_arg();
|
2019-11-30 14:09:52 -06:00
|
|
|
}
|
|
|
|
|
2020-03-23 17:42:03 -05:00
|
|
|
fn tmp() -> PathBuf {
|
2020-10-04 15:26:09 -05:00
|
|
|
std::env::var("MIRI_TEMP")
|
|
|
|
.map(|tmp| {
|
|
|
|
// MIRI_TEMP is set outside of our emulated
|
|
|
|
// program, so it may have path separators that don't
|
|
|
|
// correspond to our target platform. We normalize them here
|
|
|
|
// before constructing a `PathBuf`
|
|
|
|
|
|
|
|
#[cfg(windows)]
|
|
|
|
return PathBuf::from(tmp.replace("/", "\\"));
|
|
|
|
|
|
|
|
#[cfg(not(windows))]
|
|
|
|
return PathBuf::from(tmp.replace("\\", "/"));
|
2022-02-05 19:41:29 -06:00
|
|
|
})
|
|
|
|
.unwrap_or_else(|_| std::env::temp_dir())
|
2020-03-23 17:42:03 -05:00
|
|
|
}
|
|
|
|
|
2020-02-19 04:04:59 -06:00
|
|
|
/// Prepare: compute filename and make sure the file does not exist.
|
|
|
|
fn prepare(filename: &str) -> PathBuf {
|
2020-03-23 17:42:03 -05:00
|
|
|
let path = tmp().join(filename);
|
2020-01-07 10:09:07 -06:00
|
|
|
// Clean the paths for robustness.
|
2020-01-10 11:01:05 -06:00
|
|
|
remove_file(&path).ok();
|
2020-02-19 04:04:59 -06:00
|
|
|
path
|
|
|
|
}
|
|
|
|
|
2020-01-24 18:56:23 -06:00
|
|
|
/// Prepare directory: compute directory name and make sure it does not exist.
|
|
|
|
fn prepare_dir(dirname: &str) -> PathBuf {
|
2020-03-23 17:42:03 -05:00
|
|
|
let path = tmp().join(&dirname);
|
2020-01-24 18:56:23 -06:00
|
|
|
// Clean the directory for robustness.
|
|
|
|
remove_dir_all(&path).ok();
|
|
|
|
path
|
|
|
|
}
|
|
|
|
|
2020-02-19 04:08:24 -06:00
|
|
|
/// Prepare like above, and also write some initial content to the file.
|
|
|
|
fn prepare_with_content(filename: &str, content: &[u8]) -> PathBuf {
|
|
|
|
let path = prepare(filename);
|
|
|
|
let mut file = File::create(&path).unwrap();
|
|
|
|
file.write(content).unwrap();
|
|
|
|
path
|
|
|
|
}
|
|
|
|
|
2020-02-19 04:04:59 -06:00
|
|
|
fn test_file() {
|
|
|
|
let bytes = b"Hello, World!\n";
|
2020-02-19 04:08:24 -06:00
|
|
|
let path = prepare("miri_test_fs_file.txt");
|
2019-11-30 14:09:52 -06:00
|
|
|
|
2019-09-30 11:46:07 -05:00
|
|
|
// Test creating, writing and closing a file (closing is tested when `file` is dropped).
|
2019-10-11 16:02:04 -05:00
|
|
|
let mut file = File::create(&path).unwrap();
|
2019-10-02 08:50:32 -05:00
|
|
|
// Writing 0 bytes should not change the file contents.
|
|
|
|
file.write(&mut []).unwrap();
|
2020-01-25 22:21:33 -06:00
|
|
|
assert_eq!(file.metadata().unwrap().len(), 0);
|
2019-10-02 08:50:32 -05:00
|
|
|
|
2019-10-02 08:43:23 -05:00
|
|
|
file.write(bytes).unwrap();
|
2020-01-25 22:21:33 -06:00
|
|
|
assert_eq!(file.metadata().unwrap().len(), bytes.len() as u64);
|
2019-09-30 11:46:07 -05:00
|
|
|
// Test opening, reading and closing a file.
|
2019-10-11 16:02:04 -05:00
|
|
|
let mut file = File::open(&path).unwrap();
|
2019-10-02 08:43:23 -05:00
|
|
|
let mut contents = Vec::new();
|
2019-10-02 08:50:32 -05:00
|
|
|
// Reading 0 bytes should not move the file pointer.
|
|
|
|
file.read(&mut []).unwrap();
|
2019-10-02 08:43:23 -05:00
|
|
|
// Reading until EOF should get the whole text.
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(bytes, contents.as_slice());
|
2020-01-30 18:43:34 -06:00
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
// Removing file should succeed.
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2022-02-05 19:41:29 -06:00
|
|
|
fn test_file_open_unix_allow_two_args() {
|
|
|
|
use std::os::unix::ffi::OsStrExt;
|
|
|
|
|
|
|
|
let path = prepare_with_content("test_file_open_unix_allow_two_args.txt", &[]);
|
|
|
|
|
|
|
|
let mut name = path.into_os_string();
|
|
|
|
name.push("\0");
|
|
|
|
let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
|
|
|
|
let _fd = unsafe { libc::open(name_ptr, libc::O_RDONLY) };
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_file_open_unix_needs_three_args() {
|
|
|
|
use std::os::unix::ffi::OsStrExt;
|
|
|
|
|
|
|
|
let path = prepare_with_content("test_file_open_unix_needs_three_args.txt", &[]);
|
|
|
|
|
|
|
|
let mut name = path.into_os_string();
|
|
|
|
name.push("\0");
|
|
|
|
let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
|
|
|
|
let _fd = unsafe { libc::open(name_ptr, libc::O_CREAT, 0o666) };
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_file_open_unix_extra_third_arg() {
|
|
|
|
use std::os::unix::ffi::OsStrExt;
|
|
|
|
|
|
|
|
let path = prepare_with_content("test_file_open_unix_extra_third_arg.txt", &[]);
|
|
|
|
|
|
|
|
let mut name = path.into_os_string();
|
|
|
|
name.push("\0");
|
|
|
|
let name_ptr = name.as_bytes().as_ptr().cast::<libc::c_char>();
|
|
|
|
let _fd = unsafe { libc::open(name_ptr, libc::O_RDONLY, 42) };
|
|
|
|
}
|
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
fn test_file_clone() {
|
|
|
|
let bytes = b"Hello, World!\n";
|
2020-02-19 04:08:24 -06:00
|
|
|
let path = prepare_with_content("miri_test_fs_file_clone.txt", bytes);
|
2020-02-17 22:36:33 -06:00
|
|
|
|
2020-01-30 18:43:34 -06:00
|
|
|
// Cloning a file should be successful.
|
|
|
|
let file = File::open(&path).unwrap();
|
|
|
|
let mut cloned = file.try_clone().unwrap();
|
|
|
|
// Reading from a cloned file should get the same text.
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
cloned.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(bytes, contents.as_slice());
|
2019-11-30 14:09:52 -06:00
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
// Removing file should succeed.
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2020-03-29 16:03:05 -05:00
|
|
|
fn test_file_create_new() {
|
|
|
|
let path = prepare("miri_test_fs_file_create_new.txt");
|
|
|
|
|
|
|
|
// Creating a new file that doesn't yet exist should succeed.
|
|
|
|
OpenOptions::new().write(true).create_new(true).open(&path).unwrap();
|
|
|
|
// Creating a new file that already exists should fail.
|
2022-02-05 19:41:29 -06:00
|
|
|
assert_eq!(
|
|
|
|
ErrorKind::AlreadyExists,
|
|
|
|
OpenOptions::new().write(true).create_new(true).open(&path).unwrap_err().kind()
|
|
|
|
);
|
2020-03-29 16:03:05 -05:00
|
|
|
// Optionally creating a new file that already exists should succeed.
|
|
|
|
OpenOptions::new().write(true).create(true).open(&path).unwrap();
|
|
|
|
|
|
|
|
// Clean up
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
fn test_seek() {
|
2020-02-19 04:08:24 -06:00
|
|
|
let bytes = b"Hello, entire World!\n";
|
|
|
|
let path = prepare_with_content("miri_test_fs_seek.txt", bytes);
|
2020-02-17 22:36:33 -06:00
|
|
|
|
2020-02-09 14:43:45 -06:00
|
|
|
let mut file = File::open(&path).unwrap();
|
2020-02-17 22:36:33 -06:00
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
2020-02-19 04:14:30 -06:00
|
|
|
assert_eq!(bytes, contents.as_slice());
|
2020-01-26 12:36:36 -06:00
|
|
|
// Test that seeking to the beginning and reading until EOF gets the text again.
|
|
|
|
file.seek(SeekFrom::Start(0)).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(bytes, contents.as_slice());
|
2020-02-06 17:50:33 -06:00
|
|
|
// Test seeking relative to the end of the file.
|
|
|
|
file.seek(SeekFrom::End(-1)).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(&bytes[bytes.len() - 1..], contents.as_slice());
|
|
|
|
// Test seeking relative to the current position.
|
|
|
|
file.seek(SeekFrom::Start(5)).unwrap();
|
|
|
|
file.seek(SeekFrom::Current(-3)).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(&bytes[2..], contents.as_slice());
|
2020-01-26 12:36:36 -06:00
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
// Removing file should succeed.
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_metadata(bytes: &[u8], path: &Path) -> Result<()> {
|
|
|
|
// Test that the file metadata is correct.
|
|
|
|
let metadata = path.metadata()?;
|
|
|
|
// `path` should point to a file.
|
|
|
|
assert!(metadata.is_file());
|
|
|
|
// The size of the file must be equal to the number of written bytes.
|
|
|
|
assert_eq!(bytes.len() as u64, metadata.len());
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn test_metadata() {
|
2020-02-19 04:08:24 -06:00
|
|
|
let bytes = b"Hello, meta-World!\n";
|
|
|
|
let path = prepare_with_content("miri_test_fs_metadata.txt", bytes);
|
2020-02-17 22:36:33 -06:00
|
|
|
|
2019-11-30 14:09:52 -06:00
|
|
|
// Test that metadata of an absolute path is correct.
|
2020-02-17 22:36:33 -06:00
|
|
|
check_metadata(bytes, &path).unwrap();
|
2019-11-30 14:09:52 -06:00
|
|
|
// Test that metadata of a relative path is correct.
|
2020-02-19 04:04:59 -06:00
|
|
|
std::env::set_current_dir(path.parent().unwrap()).unwrap();
|
|
|
|
check_metadata(bytes, Path::new(path.file_name().unwrap())).unwrap();
|
2020-02-17 22:36:33 -06:00
|
|
|
|
|
|
|
// Removing file should succeed.
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2020-04-21 21:17:54 -05:00
|
|
|
fn test_file_set_len() {
|
|
|
|
let bytes = b"Hello, World!\n";
|
|
|
|
let path = prepare_with_content("miri_test_fs_set_len.txt", bytes);
|
|
|
|
|
|
|
|
// Test extending the file
|
|
|
|
let mut file = OpenOptions::new().read(true).write(true).open(&path).unwrap();
|
|
|
|
let bytes_extended = b"Hello, World!\n\x00\x00\x00\x00\x00\x00";
|
|
|
|
file.set_len(20).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(bytes_extended, contents.as_slice());
|
|
|
|
|
|
|
|
// Test truncating the file
|
|
|
|
file.seek(SeekFrom::Start(0)).unwrap();
|
|
|
|
file.set_len(10).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(&bytes[..10], contents.as_slice());
|
|
|
|
|
|
|
|
// Can't use set_len on a file not opened for writing
|
|
|
|
let file = OpenOptions::new().read(true).open(&path).unwrap();
|
|
|
|
assert_eq!(ErrorKind::InvalidInput, file.set_len(14).unwrap_err().kind());
|
|
|
|
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2020-05-19 08:57:31 -05:00
|
|
|
fn test_file_sync() {
|
2020-04-21 22:01:40 -05:00
|
|
|
let bytes = b"Hello, World!\n";
|
2020-05-19 08:57:31 -05:00
|
|
|
let path = prepare_with_content("miri_test_fs_sync.txt", bytes);
|
2020-04-21 22:01:40 -05:00
|
|
|
|
2020-05-19 08:57:31 -05:00
|
|
|
// Test that we can call sync_data and sync_all (can't readily test effects of this operation)
|
2020-05-25 13:20:29 -05:00
|
|
|
let file = OpenOptions::new().write(true).open(&path).unwrap();
|
2020-04-21 22:01:40 -05:00
|
|
|
file.sync_data().unwrap();
|
2020-05-19 08:57:31 -05:00
|
|
|
file.sync_all().unwrap();
|
2020-06-06 11:54:13 -05:00
|
|
|
|
|
|
|
// Test that we can call sync_data and sync_all on a file opened for reading.
|
|
|
|
let file = File::open(&path).unwrap();
|
|
|
|
file.sync_data().unwrap();
|
|
|
|
file.sync_all().unwrap();
|
2020-04-21 22:01:40 -05:00
|
|
|
|
|
|
|
remove_file(&path).unwrap();
|
|
|
|
}
|
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
fn test_symlink() {
|
|
|
|
let bytes = b"Hello, World!\n";
|
2020-02-19 04:08:24 -06:00
|
|
|
let path = prepare_with_content("miri_test_fs_link_target.txt", bytes);
|
|
|
|
let symlink_path = prepare("miri_test_fs_symlink.txt");
|
2019-11-30 14:09:52 -06:00
|
|
|
|
2020-01-07 10:09:07 -06:00
|
|
|
// Creating a symbolic link should succeed.
|
2020-03-23 17:48:12 -05:00
|
|
|
#[cfg(unix)]
|
2020-01-06 15:30:17 -06:00
|
|
|
std::os::unix::fs::symlink(&path, &symlink_path).unwrap();
|
2020-03-23 17:48:12 -05:00
|
|
|
#[cfg(windows)]
|
|
|
|
std::os::windows::fs::symlink_file(&path, &symlink_path).unwrap();
|
2020-01-06 15:30:17 -06:00
|
|
|
// Test that the symbolic link has the same contents as the file.
|
|
|
|
let mut symlink_file = File::open(&symlink_path).unwrap();
|
|
|
|
let mut contents = Vec::new();
|
|
|
|
symlink_file.read_to_end(&mut contents).unwrap();
|
|
|
|
assert_eq!(bytes, contents.as_slice());
|
2020-09-28 14:02:54 -05:00
|
|
|
|
|
|
|
#[cfg(unix)]
|
|
|
|
{
|
|
|
|
use std::os::unix::ffi::OsStrExt;
|
|
|
|
|
|
|
|
let expected_path = path.as_os_str().as_bytes();
|
|
|
|
|
|
|
|
// Test that the expected string gets written to a buffer of proper
|
2020-10-03 11:59:23 -05:00
|
|
|
// length, and that a trailing null byte is not written.
|
2020-09-28 14:02:54 -05:00
|
|
|
let symlink_c_str = CString::new(symlink_path.as_os_str().as_bytes()).unwrap();
|
|
|
|
let symlink_c_ptr = symlink_c_str.as_ptr();
|
|
|
|
|
|
|
|
// Make the buf one byte larger than it needs to be,
|
2020-10-03 11:59:23 -05:00
|
|
|
// and check that the last byte is not overwritten.
|
2020-09-28 14:02:54 -05:00
|
|
|
let mut large_buf = vec![0xFF; expected_path.len() + 1];
|
2022-02-05 19:41:29 -06:00
|
|
|
let res = unsafe {
|
|
|
|
libc::readlink(symlink_c_ptr, large_buf.as_mut_ptr().cast(), large_buf.len())
|
|
|
|
};
|
2020-10-03 11:59:23 -05:00
|
|
|
// Check that the resovled path was properly written into the buf.
|
2020-09-28 14:02:54 -05:00
|
|
|
assert_eq!(&large_buf[..(large_buf.len() - 1)], expected_path);
|
|
|
|
assert_eq!(large_buf.last(), Some(&0xFF));
|
2020-10-04 08:41:15 -05:00
|
|
|
assert_eq!(res, large_buf.len() as isize - 1);
|
2020-09-28 14:02:54 -05:00
|
|
|
|
|
|
|
// Test that the resolved path is truncated if the provided buffer
|
|
|
|
// is too small.
|
|
|
|
let mut small_buf = [0u8; 2];
|
2022-02-05 19:41:29 -06:00
|
|
|
let res = unsafe {
|
|
|
|
libc::readlink(symlink_c_ptr, small_buf.as_mut_ptr().cast(), small_buf.len())
|
|
|
|
};
|
2020-09-28 14:02:54 -05:00
|
|
|
assert_eq!(small_buf, &expected_path[..small_buf.len()]);
|
2020-10-04 08:41:15 -05:00
|
|
|
assert_eq!(res, small_buf.len() as isize);
|
2020-09-28 14:02:54 -05:00
|
|
|
|
|
|
|
// Test that we report a proper error for a missing path.
|
|
|
|
let bad_path = CString::new("MIRI_MISSING_FILE_NAME").unwrap();
|
2022-02-05 19:41:29 -06:00
|
|
|
let res = unsafe {
|
|
|
|
libc::readlink(bad_path.as_ptr(), small_buf.as_mut_ptr().cast(), small_buf.len())
|
|
|
|
};
|
2020-09-28 14:02:54 -05:00
|
|
|
assert_eq!(res, -1);
|
|
|
|
assert_eq!(Error::last_os_error().kind(), ErrorKind::NotFound);
|
|
|
|
}
|
|
|
|
|
2022-07-02 11:26:00 -05:00
|
|
|
// Test that metadata of a symbolic link (i.e., the file it points to) is correct.
|
2020-02-17 22:36:33 -06:00
|
|
|
check_metadata(bytes, &symlink_path).unwrap();
|
2020-01-06 15:30:17 -06:00
|
|
|
// Test that the metadata of a symbolic link is correct when not following it.
|
|
|
|
assert!(symlink_path.symlink_metadata().unwrap().file_type().is_symlink());
|
2022-07-02 11:26:00 -05:00
|
|
|
// Check that we can follow the link.
|
|
|
|
assert_eq!(read_link(&symlink_path).unwrap(), path);
|
2020-01-06 15:30:17 -06:00
|
|
|
// Removing symbolic link should succeed.
|
|
|
|
remove_file(&symlink_path).unwrap();
|
|
|
|
|
2019-11-30 14:09:52 -06:00
|
|
|
// Removing file should succeed.
|
2019-10-11 16:02:04 -05:00
|
|
|
remove_file(&path).unwrap();
|
2020-02-17 22:36:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_errors() {
|
|
|
|
let bytes = b"Hello, World!\n";
|
2020-02-19 04:08:24 -06:00
|
|
|
let path = prepare("miri_test_fs_errors.txt");
|
2020-02-17 22:36:33 -06:00
|
|
|
|
|
|
|
// The following tests also check that the `__errno_location()` shim is working properly.
|
|
|
|
// Opening a non-existing file should fail with a "not found" error.
|
|
|
|
assert_eq!(ErrorKind::NotFound, File::open(&path).unwrap_err().kind());
|
2022-04-16 21:50:46 -05:00
|
|
|
// Make sure we can also format this.
|
|
|
|
format!("{0:?}: {0}", File::open(&path).unwrap_err());
|
2020-02-17 22:36:33 -06:00
|
|
|
// Removing a non-existing file should fail with a "not found" error.
|
|
|
|
assert_eq!(ErrorKind::NotFound, remove_file(&path).unwrap_err().kind());
|
|
|
|
// Reading the metadata of a non-existing file should fail with a "not found" error.
|
|
|
|
assert_eq!(ErrorKind::NotFound, check_metadata(bytes, &path).unwrap_err().kind());
|
|
|
|
}
|
2019-10-13 14:48:07 -05:00
|
|
|
|
2020-02-17 22:36:33 -06:00
|
|
|
fn test_rename() {
|
2020-01-26 16:45:05 -06:00
|
|
|
// Renaming a file should succeed.
|
2020-02-19 04:04:59 -06:00
|
|
|
let path1 = prepare("miri_test_fs_rename_source.txt");
|
|
|
|
let path2 = prepare("miri_test_fs_rename_destination.txt");
|
|
|
|
|
2020-01-26 16:45:05 -06:00
|
|
|
let file = File::create(&path1).unwrap();
|
|
|
|
drop(file);
|
2020-02-20 21:54:52 -06:00
|
|
|
|
|
|
|
// Renaming should succeed
|
2020-01-26 16:45:05 -06:00
|
|
|
rename(&path1, &path2).unwrap();
|
2020-02-20 21:54:52 -06:00
|
|
|
// Check that the old file path isn't present
|
2020-02-08 22:40:46 -06:00
|
|
|
assert_eq!(ErrorKind::NotFound, path1.metadata().unwrap_err().kind());
|
2020-02-20 21:54:52 -06:00
|
|
|
// Check that the file has moved successfully
|
2020-01-26 16:45:05 -06:00
|
|
|
assert!(path2.metadata().unwrap().is_file());
|
2020-02-20 21:54:52 -06:00
|
|
|
|
|
|
|
// Renaming a nonexistent file should fail
|
|
|
|
assert_eq!(ErrorKind::NotFound, rename(&path1, &path2).unwrap_err().kind());
|
|
|
|
|
2020-02-14 08:19:16 -06:00
|
|
|
remove_file(&path2).unwrap();
|
2019-09-24 17:28:00 -05:00
|
|
|
}
|
2020-01-24 18:56:23 -06:00
|
|
|
|
2022-06-30 12:10:31 -05:00
|
|
|
fn test_canonicalize() {
|
|
|
|
use std::fs::canonicalize;
|
|
|
|
let dir_path = prepare_dir("miri_test_fs_dir");
|
|
|
|
create_dir(&dir_path).unwrap();
|
|
|
|
let path = dir_path.join("test_file");
|
|
|
|
drop(File::create(&path).unwrap());
|
|
|
|
|
|
|
|
let p = canonicalize(format!("{}/./test_file", dir_path.to_string_lossy())).unwrap();
|
|
|
|
assert_eq!(p.to_string_lossy().find('.'), None);
|
|
|
|
|
|
|
|
remove_dir_all(&dir_path).unwrap();
|
|
|
|
|
|
|
|
// Make sure we get an error for long paths.
|
|
|
|
use std::convert::TryInto;
|
|
|
|
let too_long = "x/".repeat(libc::PATH_MAX.try_into().unwrap());
|
|
|
|
assert!(canonicalize(too_long).is_err());
|
|
|
|
}
|
|
|
|
|
2020-01-24 18:56:23 -06:00
|
|
|
fn test_directory() {
|
|
|
|
let dir_path = prepare_dir("miri_test_fs_dir");
|
|
|
|
// Creating a directory should succeed.
|
|
|
|
create_dir(&dir_path).unwrap();
|
|
|
|
// Test that the metadata of a directory is correct.
|
|
|
|
assert!(dir_path.metadata().unwrap().is_dir());
|
2020-02-24 19:16:41 -06:00
|
|
|
// Creating a directory when it already exists should fail.
|
|
|
|
assert_eq!(ErrorKind::AlreadyExists, create_dir(&dir_path).unwrap_err().kind());
|
2020-01-25 17:36:51 -06:00
|
|
|
|
|
|
|
// Create some files inside the directory
|
2020-01-26 15:45:35 -06:00
|
|
|
let path_1 = dir_path.join("test_file_1");
|
|
|
|
drop(File::create(&path_1).unwrap());
|
|
|
|
let path_2 = dir_path.join("test_file_2");
|
|
|
|
drop(File::create(&path_2).unwrap());
|
2020-01-25 17:36:51 -06:00
|
|
|
// Test that the files are present inside the directory
|
2020-02-08 22:27:26 -06:00
|
|
|
let dir_iter = read_dir(&dir_path).unwrap();
|
|
|
|
let mut file_names = dir_iter.map(|e| e.unwrap().file_name()).collect::<Vec<_>>();
|
|
|
|
file_names.sort_unstable();
|
2022-02-22 16:06:05 -06:00
|
|
|
assert_eq!(file_names, vec!["test_file_1", "test_file_2"]);
|
2022-03-07 17:30:12 -06:00
|
|
|
// Deleting the directory should fail, since it is not empty.
|
|
|
|
assert_eq!(ErrorKind::DirectoryNotEmpty, remove_dir(&dir_path).unwrap_err().kind());
|
2020-01-25 17:36:51 -06:00
|
|
|
// Clean up the files in the directory
|
2020-01-26 15:45:35 -06:00
|
|
|
remove_file(&path_1).unwrap();
|
|
|
|
remove_file(&path_2).unwrap();
|
2020-03-06 07:28:34 -06:00
|
|
|
// Now there should be nothing left in the directory.
|
2022-02-22 16:06:05 -06:00
|
|
|
let dir_iter = read_dir(&dir_path).unwrap();
|
2020-03-06 07:28:34 -06:00
|
|
|
let file_names = dir_iter.map(|e| e.unwrap().file_name()).collect::<Vec<_>>();
|
2022-02-22 16:06:05 -06:00
|
|
|
assert!(file_names.is_empty());
|
2020-01-25 17:36:51 -06:00
|
|
|
|
2020-01-24 18:56:23 -06:00
|
|
|
// Deleting the directory should succeed.
|
|
|
|
remove_dir(&dir_path).unwrap();
|
2020-03-06 07:28:34 -06:00
|
|
|
// Reading the metadata of a non-existent directory should fail with a "not found" error.
|
2020-01-24 18:56:23 -06:00
|
|
|
assert_eq!(ErrorKind::NotFound, check_metadata(&[], &dir_path).unwrap_err().kind());
|
2022-03-12 12:37:46 -06:00
|
|
|
|
|
|
|
// To test remove_dir_all, re-create the directory with a file and a directory in it.
|
|
|
|
create_dir(&dir_path).unwrap();
|
|
|
|
drop(File::create(&path_1).unwrap());
|
|
|
|
create_dir(&path_2).unwrap();
|
|
|
|
remove_dir_all(&dir_path).unwrap();
|
2020-01-24 18:56:23 -06:00
|
|
|
}
|
2020-10-03 11:56:32 -05:00
|
|
|
|
|
|
|
fn test_dup_stdout_stderr() {
|
|
|
|
let bytes = b"hello dup fd\n";
|
|
|
|
unsafe {
|
|
|
|
let new_stdout = libc::fcntl(1, libc::F_DUPFD, 0);
|
|
|
|
let new_stderr = libc::fcntl(2, libc::F_DUPFD, 0);
|
|
|
|
libc::write(new_stdout, bytes.as_ptr() as *const libc::c_void, bytes.len());
|
|
|
|
libc::write(new_stderr, bytes.as_ptr() as *const libc::c_void, bytes.len());
|
|
|
|
}
|
|
|
|
}
|