diff options
Diffstat (limited to 'vendor/rustix/tests')
75 files changed, 0 insertions, 4937 deletions
diff --git a/vendor/rustix/tests/backends.rs b/vendor/rustix/tests/backends.rs deleted file mode 100644 index 4b88bd11c..000000000 --- a/vendor/rustix/tests/backends.rs +++ /dev/null @@ -1,109 +0,0 @@ -use std::process::Command; - -#[test] -fn test_backends() { - // Pick an arbitrary platform where linux_raw is enabled by default and - // ensure that the use-default crate uses it. - #[cfg(all(target_os = "linux", target_arch = "aarch64"))] - { - assert!( - !has_dependency("test-crates/use-default", &[], &[], &["RUSTFLAGS"], "libc"), - "use-default depends on libc" - ); - assert!( - has_dependency( - "test-crates/use-default", - &[], - &[], - &["RUSTFLAGS"], - "linux-raw-sys" - ), - "use-default does not depend on linux-raw-sys" - ); - } - - #[cfg(windows)] - let libc_dep = "windows-sys"; - #[cfg(unix)] - let libc_dep = "libc"; - - // Test the use-libc crate, which enables the "use-libc" cargo feature. - assert!( - has_dependency("test-crates/use-libc", &[], &[], &["RUSTFLAGS"], libc_dep), - "use-libc doesn't depend on {}", - libc_dep - ); - - // Test the use-default crate with `--cfg=rustix_use_libc`. - assert!( - has_dependency( - "test-crates/use-default", - &[], - &[("RUSTFLAGS", "--cfg=rustix_use_libc")], - &[], - libc_dep - ), - "use-default with --cfg=rustix_use_libc does not depend on {}", - libc_dep - ); - assert!( - !has_dependency( - "test-crates/use-default", - &[], - &[("RUSTFLAGS", "--cfg=rustix_use_libc")], - &[], - "linux-raw-sys" - ), - "use-default with --cfg=rustix_use_libc depends on linux-raw-sys" - ); - - // Test the use-default crate with `--features=rustix/use-libc`. - assert!( - has_dependency( - "test-crates/use-default", - &["--features=rustix/use-libc"], - &[], - &[], - libc_dep - ), - "use-default with --features=rustix/use-libc does not depend on {}", - libc_dep - ); -} - -/// Test whether the crate at directory `dir` has a dependency on `dependency`, -/// setting the environment variables `envs` and unsetting the environment -/// variables `remove_envs` when running `cargo`. -fn has_dependency( - dir: &str, - args: &[&str], - envs: &[(&str, &str)], - remove_envs: &[&str], - dependency: &str, -) -> bool { - let mut command = Command::new("cargo"); - - command - .arg("tree") - .arg("--quiet") - .arg("--edges=normal") - .arg(&format!("--invert={}", dependency)) - .current_dir(dir); - - command.args(args); - for (key, value) in envs { - command.env(key, value); - } - for key in remove_envs { - command.env_remove(key); - } - - let child = command.output().unwrap(); - - // `cargo tree --invert=foo` can fail in two different ways: it exits with - // a non-zero status if the dependency is not present in the Cargo.toml - // configuration, and it exists with a zero status and prints nothing if - // the dependency is present but optional and not enabled. So we check for - // both here. - child.status.success() && !child.stdout.is_empty() -} diff --git a/vendor/rustix/tests/fs/cwd.rs b/vendor/rustix/tests/fs/cwd.rs deleted file mode 100644 index 749c84f24..000000000 --- a/vendor/rustix/tests/fs/cwd.rs +++ /dev/null @@ -1,3 +0,0 @@ -/// Make sure we can use `cwd` in const contexts. -#[allow(dead_code)] -const CWD: rustix::fd::BorrowedFd<'static> = rustix::fs::cwd(); diff --git a/vendor/rustix/tests/fs/dir.rs b/vendor/rustix/tests/fs/dir.rs deleted file mode 100644 index f5120be96..000000000 --- a/vendor/rustix/tests/fs/dir.rs +++ /dev/null @@ -1,37 +0,0 @@ -#[test] -fn test_dir() { - let t = rustix::fs::openat( - rustix::fs::cwd(), - rustix::cstr!("."), - rustix::fs::OFlags::RDONLY | rustix::fs::OFlags::CLOEXEC, - rustix::fs::Mode::empty(), - ) - .unwrap(); - - let dir = rustix::fs::Dir::read_from(&t).unwrap(); - - let _file = rustix::fs::openat( - &t, - rustix::cstr!("Cargo.toml"), - rustix::fs::OFlags::RDONLY | rustix::fs::OFlags::CLOEXEC, - rustix::fs::Mode::empty(), - ) - .unwrap(); - - let mut saw_dot = false; - let mut saw_dotdot = false; - let mut saw_cargo_toml = false; - for entry in dir { - let entry = entry.unwrap(); - if entry.file_name() == rustix::cstr!(".") { - saw_dot = true; - } else if entry.file_name() == rustix::cstr!("..") { - saw_dotdot = true; - } else if entry.file_name() == rustix::cstr!("Cargo.toml") { - saw_cargo_toml = true; - } - } - assert!(saw_dot); - assert!(saw_dotdot); - assert!(saw_cargo_toml); -} diff --git a/vendor/rustix/tests/fs/fcntl.rs b/vendor/rustix/tests/fs/fcntl.rs deleted file mode 100644 index 1f8b78387..000000000 --- a/vendor/rustix/tests/fs/fcntl.rs +++ /dev/null @@ -1,17 +0,0 @@ -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_fcntl_dupfd_cloexec() { - use rustix::fd::AsFd; - use std::os::unix::io::AsRawFd; - - let file = rustix::fs::openat( - rustix::fs::cwd(), - "Cargo.toml", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .unwrap(); - - let new = rustix::fs::fcntl_dupfd_cloexec(&file, 700).unwrap(); - assert_eq!(new.as_fd().as_raw_fd(), 700); -} diff --git a/vendor/rustix/tests/fs/file.rs b/vendor/rustix/tests/fs/file.rs deleted file mode 100644 index 5c09f640d..000000000 --- a/vendor/rustix/tests/fs/file.rs +++ /dev/null @@ -1,83 +0,0 @@ -#[cfg(not(target_os = "redox"))] -#[test] -fn test_file() { - #[cfg(not(target_os = "illumos"))] - rustix::fs::accessat( - rustix::fs::cwd(), - "Cargo.toml", - rustix::fs::Access::READ_OK, - rustix::fs::AtFlags::empty(), - ) - .unwrap(); - - assert_eq!( - rustix::fs::openat( - rustix::fs::cwd(), - "Cagro.motl", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .unwrap_err(), - rustix::io::Errno::NOENT - ); - - let file = rustix::fs::openat( - rustix::fs::cwd(), - "Cargo.toml", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .unwrap(); - - assert_eq!( - rustix::fs::openat( - &file, - "Cargo.toml", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .unwrap_err(), - rustix::io::Errno::NOTDIR - ); - - #[cfg(not(any( - target_os = "dragonfly", - target_os = "illumos", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - target_os = "redox", - )))] - rustix::fs::fadvise(&file, 0, 10, rustix::fs::Advice::Normal).unwrap(); - - assert_eq!( - rustix::fs::fcntl_getfd(&file).unwrap(), - rustix::fs::FdFlags::empty() - ); - assert_eq!( - rustix::fs::fcntl_getfl(&file).unwrap(), - rustix::fs::OFlags::empty() - ); - - let stat = rustix::fs::fstat(&file).unwrap(); - assert!(stat.st_size > 0); - assert!(stat.st_blocks > 0); - - #[cfg(not(any( - target_os = "illumos", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", - )))] - // not implemented in libc for netbsd yet - { - let statfs = rustix::fs::fstatfs(&file).unwrap(); - assert!(statfs.f_blocks > 0); - } - - #[cfg(feature = "net")] - assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false)); - - assert_ne!(rustix::io::ioctl_fionread(&file).unwrap(), 0); -} diff --git a/vendor/rustix/tests/fs/flock.rs b/vendor/rustix/tests/fs/flock.rs deleted file mode 100644 index 1b7df6ffd..000000000 --- a/vendor/rustix/tests/fs/flock.rs +++ /dev/null @@ -1,34 +0,0 @@ -#[cfg(not(target_os = "redox"))] -#[test] -fn test_flock() { - use rustix::fs::{cwd, flock, openat, FlockOperation, Mode, OFlags}; - - let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&f, FlockOperation::LockExclusive).unwrap(); - flock(&f, FlockOperation::Unlock).unwrap(); - let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&g, FlockOperation::LockExclusive).unwrap(); - flock(&g, FlockOperation::Unlock).unwrap(); - drop(f); - drop(g); - - let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&f, FlockOperation::LockShared).unwrap(); - let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&g, FlockOperation::LockShared).unwrap(); - flock(&f, FlockOperation::Unlock).unwrap(); - flock(&g, FlockOperation::Unlock).unwrap(); - drop(f); - drop(g); - - let f = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&f, FlockOperation::LockShared).unwrap(); - flock(&f, FlockOperation::LockExclusive).unwrap(); - flock(&f, FlockOperation::Unlock).unwrap(); - let g = openat(cwd(), "Cargo.toml", OFlags::RDONLY, Mode::empty()).unwrap(); - flock(&g, FlockOperation::LockShared).unwrap(); - flock(&g, FlockOperation::LockExclusive).unwrap(); - flock(&g, FlockOperation::Unlock).unwrap(); - drop(f); - drop(g); -} diff --git a/vendor/rustix/tests/fs/futimens.rs b/vendor/rustix/tests/fs/futimens.rs deleted file mode 100644 index 81f8b8a27..000000000 --- a/vendor/rustix/tests/fs/futimens.rs +++ /dev/null @@ -1,42 +0,0 @@ -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_futimens() { - use rustix::fs::{cwd, fstat, futimens, openat, Mode, OFlags, Timespec, Timestamps}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - let foo = openat( - &dir, - "foo", - OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let times = Timestamps { - last_access: Timespec { - tv_sec: 44000, - tv_nsec: 45000, - }, - last_modification: Timespec { - tv_sec: 46000, - tv_nsec: 47000, - }, - }; - futimens(&foo, ×).unwrap(); - - let after = fstat(&foo).unwrap(); - - assert_eq!(times.last_modification.tv_sec as u64, after.st_mtime as u64); - #[cfg(not(target_os = "netbsd"))] - assert_eq!( - times.last_modification.tv_nsec as u64, - after.st_mtime_nsec as u64 - ); - #[cfg(target_os = "netbsd")] - assert_eq!( - times.last_modification.tv_nsec as u64, - after.st_mtimensec as u64 - ); -} diff --git a/vendor/rustix/tests/fs/invalid_offset.rs b/vendor/rustix/tests/fs/invalid_offset.rs deleted file mode 100644 index 995e302a1..000000000 --- a/vendor/rustix/tests/fs/invalid_offset.rs +++ /dev/null @@ -1,182 +0,0 @@ -//! Tests for extreme `u64` file offsets. -//! -//! POSIX-ish interfaces tend to use signed integers for file offsets, while -//! Rust APIs tend to use `u64`. Test that extreme `u64` values in APIs that -//! take file offsets are properly diagnosed. -//! -//! These tests are disabled on ios/macos since those platforms kill the -//! process with `SIGXFSZ` instead of returning an error. - -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] - -use rustix::io::SeekFrom; - -#[test] -fn invalid_offset_seek() { - use rustix::fs::{cwd, openat, seek, Mode, OFlags}; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let file = openat( - &dir, - "foo", - OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - seek(&file, SeekFrom::Start(u64::MAX)).unwrap_err(); - seek(&file, SeekFrom::Start(i64::MAX as u64 + 1)).unwrap_err(); - seek(&file, SeekFrom::End(-1)).unwrap_err(); - seek(&file, SeekFrom::End(i64::MIN)).unwrap_err(); - seek(&file, SeekFrom::Current(-1)).unwrap_err(); - seek(&file, SeekFrom::Current(i64::MIN)).unwrap_err(); -} - -#[cfg(not(any( - target_os = "dragonfly", - target_os = "illumos", - target_os = "netbsd", - target_os = "openbsd", - target_os = "redox", -)))] -#[test] -fn invalid_offset_fallocate() { - use rustix::fs::{cwd, fallocate, openat, FallocateFlags, Mode, OFlags}; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let file = openat( - &dir, - "foo", - OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - fallocate(&file, FallocateFlags::empty(), u64::MAX, 1).unwrap_err(); - fallocate(&file, FallocateFlags::empty(), i64::MAX as u64 + 1, 1).unwrap_err(); - fallocate(&file, FallocateFlags::empty(), 0, u64::MAX).unwrap_err(); - fallocate(&file, FallocateFlags::empty(), 0, i64::MAX as u64 + 1).unwrap_err(); -} - -#[cfg(not(any( - target_os = "dragonfly", - target_os = "illumos", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - target_os = "redox", -)))] -#[test] -fn invalid_offset_fadvise() { - use rustix::fs::{cwd, fadvise, openat, Advice, Mode, OFlags}; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let file = openat( - &dir, - "foo", - OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - // `fadvise` never fails on invalid offsets. - fadvise(&file, i64::MAX as u64, i64::MAX as u64, Advice::Normal).unwrap(); - fadvise(&file, u64::MAX, 0, Advice::Normal).unwrap(); - fadvise(&file, i64::MAX as u64, 1, Advice::Normal).unwrap(); - fadvise(&file, 1, i64::MAX as u64, Advice::Normal).unwrap(); - fadvise(&file, i64::MAX as u64 + 1, 0, Advice::Normal).unwrap(); - fadvise(&file, u64::MAX, i64::MAX as u64, Advice::Normal).unwrap(); - - // `fadvise` fails on invalid lengths. - fadvise(&file, u64::MAX, u64::MAX, Advice::Normal).unwrap_err(); - fadvise(&file, i64::MAX as u64, u64::MAX, Advice::Normal).unwrap_err(); - fadvise(&file, 0, u64::MAX, Advice::Normal).unwrap_err(); - fadvise(&file, u64::MAX, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); - fadvise(&file, i64::MAX as u64 + 1, u64::MAX, Advice::Normal).unwrap_err(); - fadvise(&file, i64::MAX as u64, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); - fadvise(&file, 0, i64::MAX as u64 + 1, Advice::Normal).unwrap_err(); -} - -#[test] -fn invalid_offset_pread() { - use rustix::fs::{cwd, openat, Mode, OFlags}; - use rustix::io::pread; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let file = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - let mut buf = [0_u8; 1]; - pread(&file, &mut buf, u64::MAX).unwrap_err(); - pread(&file, &mut buf, i64::MAX as u64 + 1).unwrap_err(); -} - -#[cfg(not(any(target_os = "ios", target_os = "macos")))] -#[test] -fn invalid_offset_pwrite() { - use rustix::fs::{cwd, openat, Mode, OFlags}; - use rustix::io::pwrite; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let file = openat( - &dir, - "foo", - OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - let buf = [0_u8; 1]; - pwrite(&file, &buf, u64::MAX).unwrap_err(); - pwrite(&file, &buf, i64::MAX as u64 + 1).unwrap_err(); -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn invalid_offset_copy_file_range() { - use rustix::fs::{copy_file_range, cwd, openat, Mode, OFlags}; - use rustix::io::write; - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let foo = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - let bar = openat( - &dir, - "bar", - OFlags::WRONLY | OFlags::TRUNC | OFlags::CREATE, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - write(&foo, b"a").unwrap(); - - let mut off_in = u64::MAX; - let mut off_out = 0; - copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); - - let mut off_in = i64::MAX as u64 + 1; - let mut off_out = 0; - copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); - - let mut off_in = 0; - let mut off_out = u64::MAX; - copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); - - let mut off_in = 0; - let mut off_out = i64::MAX as u64; - copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); - - let mut off_in = 0; - let mut off_out = i64::MAX as u64 + 1; - copy_file_range(&foo, Some(&mut off_in), &bar, Some(&mut off_out), 1).unwrap_err(); -} diff --git a/vendor/rustix/tests/fs/long_paths.rs b/vendor/rustix/tests/fs/long_paths.rs deleted file mode 100644 index dbc2fa6ea..000000000 --- a/vendor/rustix/tests/fs/long_paths.rs +++ /dev/null @@ -1,28 +0,0 @@ -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_long_paths() { - use rustix::fs::{cwd, mkdirat, openat, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - #[cfg(libc)] - const PATH_MAX: usize = libc::PATH_MAX as usize; - #[cfg(linux_raw)] - const PATH_MAX: usize = linux_raw_sys::general::PATH_MAX as usize; - - mkdirat(&dir, "a", Mode::RUSR | Mode::XUSR | Mode::WUSR).unwrap(); - - let mut long_path = String::new(); - for _ in 0..PATH_MAX / 5 { - long_path.push_str("a/../"); - } - - let mut too_long_path = String::new(); - for _ in 0..PATH_MAX / 4 { - too_long_path.push_str("a/../"); - } - - let _ = openat(&dir, &long_path, OFlags::RDONLY, Mode::empty()).unwrap(); - let _ = openat(&dir, &too_long_path, OFlags::RDONLY, Mode::empty()).unwrap_err(); -} diff --git a/vendor/rustix/tests/fs/main.rs b/vendor/rustix/tests/fs/main.rs deleted file mode 100644 index 23928a6ba..000000000 --- a/vendor/rustix/tests/fs/main.rs +++ /dev/null @@ -1,47 +0,0 @@ -//! Tests for [`rustix::fs`]. - -#![cfg(feature = "fs")] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg_attr(core_c_str, feature(core_c_str))] - -mod cwd; -mod dir; -mod fcntl; -mod file; -#[cfg(not(target_os = "wasi"))] -mod flock; -mod futimens; -mod invalid_offset; -mod long_paths; -#[cfg(not(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "illumos", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -mod makedev; -mod mkdirat; -mod mknodat; -#[cfg(any(target_os = "android", target_os = "linux"))] -mod openat; -#[cfg(any(target_os = "android", target_os = "linux"))] -mod openat2; -mod readdir; -mod renameat; -#[cfg(not(any( - target_os = "illumos", - target_os = "netbsd", - target_os = "redox", - target_os = "wasi", -)))] -// not implemented in libc for netbsd yet -mod statfs; -mod utimensat; -mod y2038; diff --git a/vendor/rustix/tests/fs/makedev.rs b/vendor/rustix/tests/fs/makedev.rs deleted file mode 100644 index 79b5199e8..000000000 --- a/vendor/rustix/tests/fs/makedev.rs +++ /dev/null @@ -1,10 +0,0 @@ -use rustix::fs::{major, makedev, minor}; - -#[test] -fn makedev_roundtrip() { - let maj = 0x2324_2526; - let min = 0x6564_6361; - let dev = makedev(maj, min); - assert_eq!(maj, major(dev)); - assert_eq!(min, minor(dev)); -} diff --git a/vendor/rustix/tests/fs/mkdirat.rs b/vendor/rustix/tests/fs/mkdirat.rs deleted file mode 100644 index 884588037..000000000 --- a/vendor/rustix/tests/fs/mkdirat.rs +++ /dev/null @@ -1,33 +0,0 @@ -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_mkdirat() { - use rustix::fs::{cwd, mkdirat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - mkdirat(&dir, "foo", Mode::RWXU).unwrap(); - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Directory); - unlinkat(&dir, "foo", AtFlags::REMOVEDIR).unwrap(); -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_mkdirat_with_o_path() { - use rustix::fs::{cwd, mkdirat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::PATH, - Mode::empty(), - ) - .unwrap(); - - mkdirat(&dir, "foo", Mode::RWXU).unwrap(); - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Directory); - unlinkat(&dir, "foo", AtFlags::REMOVEDIR).unwrap(); -} diff --git a/vendor/rustix/tests/fs/mknodat.rs b/vendor/rustix/tests/fs/mknodat.rs deleted file mode 100644 index fa1c84f69..000000000 --- a/vendor/rustix/tests/fs/mknodat.rs +++ /dev/null @@ -1,27 +0,0 @@ -#[cfg(not(any( - target_os = "ios", - target_os = "macos", - target_os = "redox", - target_os = "wasi", -)))] -#[test] -fn test_mknodat() { - use rustix::fs::{cwd, mknodat, openat, statat, unlinkat, AtFlags, FileType, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - // Create a regular file. Not supported on FreeBSD or OpenBSD. - #[cfg(not(any(target_os = "freebsd", target_os = "openbsd")))] - { - mknodat(&dir, "foo", FileType::RegularFile, Mode::empty(), 0).unwrap(); - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::RegularFile); - unlinkat(&dir, "foo", AtFlags::empty()).unwrap(); - } - - mknodat(&dir, "foo", FileType::Fifo, Mode::empty(), 0).unwrap(); - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - assert_eq!(FileType::from_raw_mode(stat.st_mode), FileType::Fifo); - unlinkat(&dir, "foo", AtFlags::empty()).unwrap(); -} diff --git a/vendor/rustix/tests/fs/openat.rs b/vendor/rustix/tests/fs/openat.rs deleted file mode 100644 index 564574dc1..000000000 --- a/vendor/rustix/tests/fs/openat.rs +++ /dev/null @@ -1,33 +0,0 @@ -use std::fs::File; - -use io_lifetimes::{FromFd, IntoFd}; -use rustix::fs::{cwd, openat, Mode, OFlags}; -use std::io::Write; - -#[test] -fn test_openat_tmpfile() { - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - let f = match openat( - &dir, - ".", - OFlags::WRONLY | OFlags::CLOEXEC | OFlags::TMPFILE, - Mode::from_bits_truncate(0o644), - ) { - Ok(f) => Ok(Some(File::from_fd(f.into_fd()))), - // TODO: Factor out the `Err`, once we no longer support Rust 1.48. - Err(rustix::io::Errno::OPNOTSUPP) - | Err(rustix::io::Errno::ISDIR) - | Err(rustix::io::Errno::NOENT) => Ok(None), - Err(e) => Err(e), - }; - if let Some(mut f) = f.unwrap() { - write!(f, "hello world").unwrap(); - } -} diff --git a/vendor/rustix/tests/fs/openat2.rs b/vendor/rustix/tests/fs/openat2.rs deleted file mode 100644 index 0b1d86fe2..000000000 --- a/vendor/rustix/tests/fs/openat2.rs +++ /dev/null @@ -1,184 +0,0 @@ -use rustix::fd::AsFd; -use rustix::fs::{cwd, mkdirat, openat, openat2, symlinkat, Mode, OFlags, ResolveFlags}; -use rustix::io::OwnedFd; -use rustix::{io, path}; -use std::os::unix::io::AsRawFd; - -/// Like `openat2`, but keep retrying until it fails or succeeds. -fn openat2_more<Fd: AsFd, P: path::Arg>( - dirfd: Fd, - path: P, - oflags: OFlags, - mode: Mode, - resolve: ResolveFlags, -) -> io::Result<OwnedFd> { - let path = path.as_cow_c_str().unwrap().into_owned(); - loop { - match openat2(dirfd.as_fd(), &path, oflags, mode, resolve) { - Ok(file) => return Ok(file), - Err(io::Errno::AGAIN) => continue, - Err(err) => return Err(err), - } - } -} - -#[test] -fn test_openat2() { - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - // Detect whether `openat2` is available. - match openat2( - &dir, - ".", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) { - Ok(_file) => (), - Err(io::Errno::NOSYS) => return, - Err(_err) => return, - } - - // Create a file. - let _ = openat2_more( - &dir, - "test.txt", - OFlags::WRONLY | OFlags::CREATE | OFlags::TRUNC | OFlags::CLOEXEC, - Mode::RUSR, - ResolveFlags::empty(), - ) - .unwrap(); - - // Test `NO_SYMLINKS`. - symlinkat("test.txt", &dir, "symlink.txt").unwrap(); - let _ = openat2_more( - &dir, - "symlink.txt", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &dir, - "symlink.txt", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::NO_MAGICLINKS, - ) - .unwrap(); - let _ = openat2_more( - &dir, - "symlink.txt", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::NO_SYMLINKS, - ) - .unwrap_err(); - - // Test `NO_MAGICLINKS`. - let test = openat2_more( - &dir, - "test.txt", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &dir, - &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &dir, - &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::NO_SYMLINKS, - ) - .unwrap_err(); - let _ = openat2_more( - &dir, - &format!("/proc/self/fd/{}", test.as_fd().as_raw_fd()), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::NO_MAGICLINKS, - ) - .unwrap_err(); - - // Test `NO_XDEV`. - let root = openat2_more( - &dir, - "/", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &root, - "proc", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &root, - "proc", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::NO_XDEV, - ) - .unwrap_err(); - - // Test `BENEATH`. - let _ = openat2_more( - &dir, - "..", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &dir, - "..", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::BENEATH, - ) - .unwrap_err(); - - // Test `IN_ROOT`. - let _ = openat2_more( - &dir, - "/proc", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::empty(), - ) - .unwrap(); - let _ = openat2_more( - &dir, - "/proc", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::IN_ROOT, - ) - .unwrap_err(); - mkdirat(&dir, "proc", Mode::RUSR | Mode::XUSR).unwrap(); - let _ = openat2_more( - &dir, - "/proc", - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ResolveFlags::IN_ROOT, - ) - .unwrap(); -} diff --git a/vendor/rustix/tests/fs/readdir.rs b/vendor/rustix/tests/fs/readdir.rs deleted file mode 100644 index 8925660a9..000000000 --- a/vendor/rustix/tests/fs/readdir.rs +++ /dev/null @@ -1,68 +0,0 @@ -#![cfg(not(target_os = "redox"))] - -use rustix::fs::{Dir, DirEntry}; -use std::collections::HashMap; - -#[test] -fn dir_entries() { - let tmpdir = tempfile::tempdir().expect("construct tempdir"); - let dirfd = std::fs::File::open(tmpdir.path()).expect("open tempdir as file"); - let mut dir = Dir::read_from(dirfd).expect("construct Dir from dirfd"); - - let entries = read_entries(&mut dir); - assert_eq!(entries.len(), 0, "no files in directory"); - - let _f1 = std::fs::File::create(tmpdir.path().join("file1")).expect("create file1"); - - let entries = read_entries(&mut dir); - assert!( - entries.get("file1").is_some(), - "directory contains `file1`: {:?}", - entries - ); - assert_eq!(entries.len(), 1); - - let _f2 = std::fs::File::create(tmpdir.path().join("file2")).expect("create file1"); - let entries = read_entries(&mut dir); - assert!( - entries.get("file1").is_some(), - "directory contains `file1`: {:?}", - entries - ); - assert!( - entries.get("file2").is_some(), - "directory contains `file2`: {:?}", - entries - ); - assert_eq!(entries.len(), 2); -} - -fn read_entries(dir: &mut Dir) -> HashMap<String, DirEntry> { - dir.rewind(); - let mut out = HashMap::new(); - loop { - match dir.read() { - Some(e) => { - let e = e.expect("non-error entry"); - let name = e.file_name().to_str().expect("utf8 filename").to_owned(); - if name != "." && name != ".." { - out.insert(name, e); - } - } - None => break, - } - } - out -} - -#[test] -fn dir_from_openat() { - let dirfd = rustix::fs::openat( - rustix::fs::cwd(), - ".", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .expect("open cwd as file"); - let _dir = Dir::read_from(dirfd).expect("construct Dir from dirfd"); -} diff --git a/vendor/rustix/tests/fs/renameat.rs b/vendor/rustix/tests/fs/renameat.rs deleted file mode 100644 index 2eea2e77a..000000000 --- a/vendor/rustix/tests/fs/renameat.rs +++ /dev/null @@ -1,104 +0,0 @@ -#[cfg(any(target_os = "android", target_os = "linux"))] -use rustix::fs::Stat; - -#[cfg(any(target_os = "android", target_os = "linux"))] -fn same(a: &Stat, b: &Stat) -> bool { - a.st_ino == b.st_ino && a.st_dev == b.st_dev -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_renameat() { - use rustix::fs::{cwd, openat, renameat, statat, AtFlags, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::PATH, - Mode::empty(), - ) - .unwrap(); - - let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); - let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); - renameat(&dir, "foo", &dir, "bar").unwrap(); - let renamed = statat(&dir, "bar", AtFlags::empty()).unwrap(); - assert!(same(&before, &renamed)); -} - -/// Like `test_renameat` but the file already exists, so `renameat` -/// overwrites it. -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_renameat_overwrite() { - use rustix::fs::{cwd, openat, renameat, statat, AtFlags, Mode, OFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::PATH, - Mode::empty(), - ) - .unwrap(); - - let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); - let _ = openat(&dir, "bar", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); - let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); - renameat(&dir, "foo", &dir, "bar").unwrap(); - let renamed = statat(&dir, "bar", AtFlags::empty()).unwrap(); - assert!(same(&before, &renamed)); -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_renameat_with() { - use rustix::fs::{cwd, openat, renameat_with, statat, AtFlags, Mode, OFlags, RenameFlags}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::PATH, - Mode::empty(), - ) - .unwrap(); - - let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::empty()).unwrap(); - let before = statat(&dir, "foo", AtFlags::empty()).unwrap(); - - match renameat_with(&dir, "foo", &dir, "red", RenameFlags::empty()) { - Ok(()) => (), - Err(e) if e == rustix::io::Errno::NOSYS => return, - Err(e) => unreachable!("unexpected error from renameat_with: {:?}", e), - } - - let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); - assert!(same(&before, &renamed)); - - let _ = openat( - &dir, - "green", - OFlags::CREATE | OFlags::WRONLY, - Mode::empty(), - ) - .unwrap(); - - #[cfg(all(target_os = "linux", target_env = "gnu"))] - { - let green = statat(&dir, "green", AtFlags::empty()).unwrap(); - - renameat_with(&dir, "red", &dir, "green", RenameFlags::NOREPLACE).unwrap_err(); - let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); - assert!(same(&before, &renamed)); - let orig = statat(&dir, "green", AtFlags::empty()).unwrap(); - assert!(same(&green, &orig)); - - renameat_with(&dir, "red", &dir, "green", RenameFlags::EXCHANGE).unwrap(); - let renamed = statat(&dir, "red", AtFlags::empty()).unwrap(); - assert!(same(&green, &renamed)); - let orig = statat(&dir, "green", AtFlags::empty()).unwrap(); - assert!(same(&before, &orig)); - } -} diff --git a/vendor/rustix/tests/fs/statfs.rs b/vendor/rustix/tests/fs/statfs.rs deleted file mode 100644 index f8bf2e350..000000000 --- a/vendor/rustix/tests/fs/statfs.rs +++ /dev/null @@ -1,49 +0,0 @@ -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_statfs_abi() { - use rustix::fs::{FsWord, StatFs, NFS_SUPER_MAGIC, PROC_SUPER_MAGIC}; - - // Ensure these all have consistent types. - let t: StatFs = unsafe { std::mem::zeroed() }; - let _s: FsWord = t.f_type; - let _u: FsWord = PROC_SUPER_MAGIC; - let _v: FsWord = NFS_SUPER_MAGIC; - - // Ensure that after all the platform-specific dancing we have to do, this - // constant comes out with the correct value. - #[cfg(all(libc, not(target_env = "musl")))] - { - assert_eq!( - i128::from(PROC_SUPER_MAGIC), - i128::from(libc::PROC_SUPER_MAGIC) - ); - assert_eq!( - i128::from(NFS_SUPER_MAGIC), - i128::from(libc::NFS_SUPER_MAGIC) - ); - } - - #[cfg(linux_raw)] - { - assert_eq!( - i128::from(PROC_SUPER_MAGIC), - i128::from(linux_raw_sys::general::PROC_SUPER_MAGIC) - ); - assert_eq!( - i128::from(NFS_SUPER_MAGIC), - i128::from(linux_raw_sys::general::NFS_SUPER_MAGIC) - ); - } - - assert_eq!(PROC_SUPER_MAGIC, 0x0000_9fa0); - assert_eq!(NFS_SUPER_MAGIC, 0x0000_6969); -} - -#[test] -fn test_statfs() { - let statfs = rustix::fs::statfs("Cargo.toml").unwrap(); - let f_blocks = statfs.f_blocks; - assert_ne!(f_blocks, 0); - // Previously we checked f_files != 0 here, but at least btrfs doesn't set - // that. -} diff --git a/vendor/rustix/tests/fs/utimensat.rs b/vendor/rustix/tests/fs/utimensat.rs deleted file mode 100644 index f0fb7e27b..000000000 --- a/vendor/rustix/tests/fs/utimensat.rs +++ /dev/null @@ -1,127 +0,0 @@ -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_utimensat() { - use rustix::fs::{cwd, openat, statat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let _ = openat( - &dir, - "foo", - OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let times = Timestamps { - last_access: Timespec { - tv_sec: 44000, - tv_nsec: 45000, - }, - last_modification: Timespec { - tv_sec: 46000, - tv_nsec: 47000, - }, - }; - utimensat(&dir, "foo", ×, AtFlags::empty()).unwrap(); - - let after = statat(&dir, "foo", AtFlags::empty()).unwrap(); - - assert_eq!(times.last_modification.tv_sec as u64, after.st_mtime as u64); - #[cfg(not(target_os = "netbsd"))] - assert_eq!( - times.last_modification.tv_nsec as u64, - after.st_mtime_nsec as u64 - ); - #[cfg(target_os = "netbsd")] - assert_eq!( - times.last_modification.tv_nsec as u64, - after.st_mtimensec as u64 - ); - assert!(times.last_access.tv_sec as u64 >= after.st_atime as u64); - #[cfg(not(target_os = "netbsd"))] - assert!( - times.last_access.tv_sec as u64 > after.st_atime as u64 - || times.last_access.tv_nsec as u64 >= after.st_atime_nsec as u64 - ); - #[cfg(target_os = "netbsd")] - assert!( - times.last_access.tv_sec as u64 > after.st_atime as u64 - || times.last_access.tv_nsec as u64 >= after.st_atimensec as u64 - ); -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_utimensat_noent() { - use rustix::fs::{cwd, openat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let times = Timestamps { - last_access: Timespec { - tv_sec: 44000, - tv_nsec: 45000, - }, - last_modification: Timespec { - tv_sec: 46000, - tv_nsec: 47000, - }, - }; - assert_eq!( - utimensat(&dir, "foo", ×, AtFlags::empty()).unwrap_err(), - rustix::io::Errno::NOENT - ); -} - -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -#[test] -fn test_utimensat_notdir() { - use rustix::fs::{cwd, openat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat( - cwd(), - tmp.path(), - OFlags::RDONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let foo = openat( - &dir, - "foo", - OFlags::CREATE | OFlags::WRONLY | OFlags::CLOEXEC, - Mode::empty(), - ) - .unwrap(); - - let times = Timestamps { - last_access: Timespec { - tv_sec: 44000, - tv_nsec: 45000, - }, - last_modification: Timespec { - tv_sec: 46000, - tv_nsec: 47000, - }, - }; - assert_eq!( - utimensat(&foo, "bar", ×, AtFlags::empty()).unwrap_err(), - rustix::io::Errno::NOTDIR - ); -} diff --git a/vendor/rustix/tests/fs/y2038.rs b/vendor/rustix/tests/fs/y2038.rs deleted file mode 100644 index 4299d709b..000000000 --- a/vendor/rustix/tests/fs/y2038.rs +++ /dev/null @@ -1,146 +0,0 @@ -/// Test that we can set a file timestamp to a date past the year 2038 with -/// `utimensat` and read it back again. -/// -/// See tests/time/y2038.rs for more information about y2038 testing. -#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] -#[test] -fn test_y2038_with_utimensat() { - use rustix::fs::{ - cwd, fstat, openat, statat, utimensat, AtFlags, Mode, OFlags, Timespec, Timestamps, - }; - use std::convert::TryInto; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(&cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - let m_sec = 1_u64 << 32; - let m_nsec = 17_u32; - let a_sec = m_sec + 1; - let a_nsec = m_nsec + 1; - - let timestamps = Timestamps { - last_modification: Timespec { - tv_sec: m_sec as _, - tv_nsec: m_nsec as _, - }, - last_access: Timespec { - tv_sec: a_sec as _, - tv_nsec: a_nsec as _, - }, - }; - let _ = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::RUSR).unwrap(); - - match utimensat(&dir, "foo", ×tamps, AtFlags::empty()) { - Ok(()) => (), - - // On 32-bit platforms, accept `EOVERFLOW`, meaning that y2038 support - // is not available in this version of the OS. - #[cfg(target_pointer_width = "32")] - Err(rustix::io::Errno::OVERFLOW) => return, - - Err(e) => panic!("unexpected error: {:?}", e), - } - - // Use `statat` to read back the timestamp. - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - - assert_eq!( - TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, - m_sec - ); - assert_eq!(stat.st_mtime_nsec as u32, m_nsec); - assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); - assert!( - TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec - || stat.st_atime_nsec as u32 >= a_nsec - ); - - // Now test the same thing, but with `fstat`. - let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); - let stat = fstat(&file).unwrap(); - - assert_eq!( - TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, - m_sec - ); - assert_eq!(stat.st_mtime_nsec as u32, m_nsec); - assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); - assert!( - TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec - || stat.st_atime_nsec as u32 >= a_nsec - ); -} - -/// Test that we can set a file timestamp to a date past the year 2038 with -/// `futimens` and read it back again. -/// -/// See tests/time/y2038.rs for more information about y2038 testing. -#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] -#[test] -fn test_y2038_with_futimens() { - use rustix::fs::{ - cwd, fstat, futimens, openat, statat, AtFlags, Mode, OFlags, Timespec, Timestamps, - }; - use std::convert::TryInto; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(&cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - let m_sec = 1_u64 << 32; - let m_nsec = 17_u32; - let a_sec = m_sec + 1; - let a_nsec = m_nsec + 1; - - let timestamps = Timestamps { - last_modification: Timespec { - tv_sec: m_sec as _, - tv_nsec: m_nsec as _, - }, - last_access: Timespec { - tv_sec: a_sec as _, - tv_nsec: a_nsec as _, - }, - }; - let file = openat(&dir, "foo", OFlags::CREATE | OFlags::WRONLY, Mode::RUSR).unwrap(); - - match futimens(&file, ×tamps) { - Ok(()) => (), - - // On 32-bit platforms, accept `EOVERFLOW`, meaning that y2038 support - // is not available in this version of the OS. - #[cfg(target_pointer_width = "32")] - Err(rustix::io::Errno::OVERFLOW) => return, - - Err(e) => panic!("unexpected error: {:?}", e), - } - - // Use `statat` to read back the timestamp. - let stat = statat(&dir, "foo", AtFlags::empty()).unwrap(); - - assert_eq!(TryInto::<u64>::try_into(stat.st_mtime).unwrap(), m_sec); - assert_eq!(stat.st_mtime_nsec as u32, m_nsec); - assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() >= a_sec); - assert!( - TryInto::<u64>::try_into(stat.st_atime).unwrap() > a_sec - || stat.st_atime_nsec as u32 >= a_nsec - ); - - // Now test the same thing, but with `fstat`. - let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); - let stat = fstat(&file).unwrap(); - - assert_eq!( - TryInto::<u64>::try_into(stat.st_mtime).unwrap() as u64, - m_sec - ); - assert_eq!(stat.st_mtime_nsec as u32, m_nsec); - assert!(TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 >= a_sec); - assert!( - TryInto::<u64>::try_into(stat.st_atime).unwrap() as u64 > a_sec - || stat.st_atime_nsec as u32 >= a_nsec - ); -} diff --git a/vendor/rustix/tests/io/dup2_to_replace_stdio.rs b/vendor/rustix/tests/io/dup2_to_replace_stdio.rs deleted file mode 100644 index b07ec17f0..000000000 --- a/vendor/rustix/tests/io/dup2_to_replace_stdio.rs +++ /dev/null @@ -1,18 +0,0 @@ -#![cfg(not(target_os = "wasi"))] - -use std::env; -use std::process::Command; - -/// Use `dup2` to replace the stdin and stdout file descriptors. -#[test] -fn dup2_to_replace_stdio() { - // This test modifies the stdio file descriptors, so we run it in a - // separate process so that it doesn't interfere with the test harness. - assert!(Command::new(env::var("CARGO").unwrap()) - .arg("run") - .arg("--example") - .arg("dup2_to_replace_stdio") - .status() - .unwrap() - .success()); -} diff --git a/vendor/rustix/tests/io/epoll.rs b/vendor/rustix/tests/io/epoll.rs deleted file mode 100644 index 4cfe305fe..000000000 --- a/vendor/rustix/tests/io/epoll.rs +++ /dev/null @@ -1,103 +0,0 @@ -#![cfg(any(target_os = "android", target_os = "linux"))] - -use rustix::fd::AsFd; -use rustix::io::epoll::{self, Epoll}; -use rustix::io::{ioctl_fionbio, read, write, OwnedFd}; -use rustix::net::{ - accept, bind_v4, connect_v4, getsockname, listen, socket, AddressFamily, Ipv4Addr, Protocol, - SocketAddrAny, SocketAddrV4, SocketType, -}; -use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; - -const BUFFER_SIZE: usize = 20; - -fn server(ready: Arc<(Mutex<u16>, Condvar)>) { - let listen_sock = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); - bind_v4(&listen_sock, &SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0)).unwrap(); - listen(&listen_sock, 1).unwrap(); - - let who = match getsockname(&listen_sock).unwrap() { - SocketAddrAny::V4(addr) => addr, - _ => panic!(), - }; - - { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - *port = who.port(); - cvar.notify_all(); - } - - let epoll = Epoll::new(epoll::CreateFlags::CLOEXEC, epoll::Owning::<OwnedFd>::new()).unwrap(); - - // Test into conversions. - let fd: OwnedFd = epoll.into(); - let epoll: Epoll<epoll::Owning<OwnedFd>> = fd.into(); - let fd: RawFd = epoll.into_raw_fd(); - let epoll = unsafe { Epoll::<epoll::Owning<OwnedFd>>::from_raw_fd(fd) }; - - let raw_listen_sock = listen_sock.as_fd().as_raw_fd(); - epoll.add(listen_sock, epoll::EventFlags::IN).unwrap(); - - let mut event_list = epoll::EventVec::with_capacity(4); - loop { - epoll.wait(&mut event_list, -1).unwrap(); - for (_event_flags, target) in &event_list { - if target.as_raw_fd() == raw_listen_sock { - let conn_sock = accept(&*target).unwrap(); - ioctl_fionbio(&conn_sock, true).unwrap(); - epoll - .add(conn_sock, epoll::EventFlags::OUT | epoll::EventFlags::ET) - .unwrap(); - } else { - write(&*target, b"hello\n").unwrap(); - let _ = epoll.del(target).unwrap(); - } - } - } -} - -fn client(ready: Arc<(Mutex<u16>, Condvar)>) { - let port = { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - while *port == 0 { - port = cvar.wait(port).unwrap(); - } - *port - }; - - let addr = SocketAddrV4::new(Ipv4Addr::LOCALHOST, port); - let mut buffer = vec![0; BUFFER_SIZE]; - - for _ in 0..16 { - let data_socket = - socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); - connect_v4(&data_socket, &addr).unwrap(); - - let nread = read(&data_socket, &mut buffer).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello\n"); - } -} - -#[test] -fn test_epoll() { - let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); - let ready_clone = Arc::clone(&ready); - - let _server = thread::Builder::new() - .name("server".to_string()) - .spawn(move || { - server(ready); - }) - .unwrap(); - let client = thread::Builder::new() - .name("client".to_string()) - .spawn(move || { - client(ready_clone); - }) - .unwrap(); - client.join().unwrap(); -} diff --git a/vendor/rustix/tests/io/error.rs b/vendor/rustix/tests/io/error.rs deleted file mode 100644 index 128d3b59a..000000000 --- a/vendor/rustix/tests/io/error.rs +++ /dev/null @@ -1,14 +0,0 @@ -#[test] -fn test_error() { - assert_eq!( - rustix::io::Errno::INVAL, - rustix::io::Errno::from_raw_os_error(rustix::io::Errno::INVAL.raw_os_error()) - ); - #[cfg(not(windows))] - assert_eq!(rustix::io::Errno::INVAL.raw_os_error(), libc::EINVAL); - #[cfg(windows)] - assert_eq!( - rustix::io::Errno::INVAL.raw_os_error(), - windows_sys::Win32::Networking::WinSock::WSAEINVAL - ); -} diff --git a/vendor/rustix/tests/io/eventfd.rs b/vendor/rustix/tests/io/eventfd.rs deleted file mode 100644 index 11bc8ae55..000000000 --- a/vendor/rustix/tests/io/eventfd.rs +++ /dev/null @@ -1,24 +0,0 @@ -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_eventfd() { - use rustix::io::{eventfd, read, write, EventfdFlags}; - use std::mem::size_of; - use std::thread; - - let efd = eventfd(0, EventfdFlags::CLOEXEC).unwrap(); - - let child = thread::spawn(move || { - for u in [1_u64, 3, 6, 11, 5000].iter() { - assert_eq!(write(&efd, &u.to_ne_bytes()).unwrap(), size_of::<u64>()); - } - efd - }); - - let efd = child.join().unwrap(); - - let mut bytes = [0_u8; size_of::<u64>()]; - let s = read(&efd, &mut bytes).unwrap(); - assert_eq!(s, bytes.len()); - let u = u64::from_ne_bytes(bytes); - assert_eq!(u, 5021); -} diff --git a/vendor/rustix/tests/io/from_into.rs b/vendor/rustix/tests/io/from_into.rs deleted file mode 100644 index 94d915993..000000000 --- a/vendor/rustix/tests/io/from_into.rs +++ /dev/null @@ -1,28 +0,0 @@ -#[cfg(feature = "fs")] -#[cfg(not(target_os = "redox"))] -#[test] -fn test_owned() { - use rustix::fd::AsFd; - #[cfg(unix)] - use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd}; - #[cfg(target_os = "wasi")] - use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd}; - - let file = rustix::fs::openat( - rustix::fs::cwd(), - "Cargo.toml", - rustix::fs::OFlags::RDONLY, - rustix::fs::Mode::empty(), - ) - .unwrap(); - - let raw = file.as_raw_fd(); - assert_eq!(raw, file.as_fd().as_raw_fd()); - - let inner = file.into_raw_fd(); - assert_eq!(raw, inner); - - let new = unsafe { rustix::io::OwnedFd::from_raw_fd(inner) }; - let mut buf = [0_u8; 4]; - let _ = rustix::io::read(&new, &mut buf).unwrap(); -} diff --git a/vendor/rustix/tests/io/ioctl.rs b/vendor/rustix/tests/io/ioctl.rs deleted file mode 100644 index e260e4884..000000000 --- a/vendor/rustix/tests/io/ioctl.rs +++ /dev/null @@ -1,14 +0,0 @@ -// `is_read_write` is not yet implemented on Windows. And `ioctl_fionread` -// on Windows doesn't work on files. -#[cfg(not(windows))] -#[test] -fn test_ioctls() { - let file = std::fs::File::open("Cargo.toml").unwrap(); - - assert_eq!(rustix::io::is_read_write(&file).unwrap(), (true, false)); - - assert_eq!( - rustix::io::ioctl_fionread(&file).unwrap(), - file.metadata().unwrap().len() - ); -} diff --git a/vendor/rustix/tests/io/main.rs b/vendor/rustix/tests/io/main.rs deleted file mode 100644 index bdd044809..000000000 --- a/vendor/rustix/tests/io/main.rs +++ /dev/null @@ -1,31 +0,0 @@ -//! Tests for [`rustix::io`]. - -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] - -#[cfg(not(feature = "rustc-dep-of-std"))] -#[cfg(not(windows))] -#[cfg(not(target_os = "wasi"))] -mod dup2_to_replace_stdio; -#[cfg(not(feature = "rustc-dep-of-std"))] // TODO -#[cfg(not(windows))] -#[cfg(feature = "net")] -#[cfg(not(target_os = "wasi"))] -mod epoll; -mod error; -#[cfg(not(windows))] -#[cfg(not(target_os = "wasi"))] -mod eventfd; -#[cfg(not(windows))] -mod from_into; -#[cfg(not(target_os = "redox"))] -mod ioctl; -mod poll; -#[cfg(all(feature = "procfs", any(target_os = "android", target_os = "linux")))] -mod procfs; -#[cfg(not(windows))] -#[cfg(not(target_os = "redox"))] // redox doesn't have cwd/openat -#[cfg(not(target_os = "wasi"))] // wasi support for S_IRUSR etc. submitted to libc in #2264 -mod read_write; -#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "android"))] -mod seals; diff --git a/vendor/rustix/tests/io/poll.rs b/vendor/rustix/tests/io/poll.rs deleted file mode 100644 index ff2da695b..000000000 --- a/vendor/rustix/tests/io/poll.rs +++ /dev/null @@ -1,63 +0,0 @@ -use rustix::fd::{AsFd, AsRawFd, FromRawFd, IntoRawFd, OwnedFd}; -#[cfg(not(windows))] -use rustix::io::{poll, retry_on_intr}; -use rustix::io::{PollFd, PollFlags}; - -#[cfg(not(windows))] -#[test] -fn test_poll() { - use rustix::io::{pipe, read, write}; - - // Create a pipe. - let (reader, writer) = pipe().unwrap(); - let mut poll_fds = [PollFd::new(&reader, PollFlags::IN)]; - assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); - - // `poll` should say there's nothing ready to be read from the pipe. - let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap(); - assert_eq!(num, 0); - assert!(poll_fds[0].revents().is_empty()); - assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); - - // Write a byte to the pipe. - assert_eq!(retry_on_intr(|| write(&writer, b"a")).unwrap(), 1); - - // `poll` should now say there's data to be read. - let num = retry_on_intr(|| poll(&mut poll_fds, -1)).unwrap(); - assert_eq!(num, 1); - assert_eq!(poll_fds[0].revents(), PollFlags::IN); - assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); - - let mut temp = poll_fds[0].clone(); - assert_eq!(temp.revents(), PollFlags::IN); - temp.clear_revents(); - assert!(temp.revents().is_empty()); - - // Read the byte from the pipe. - let mut buf = [b'\0']; - assert_eq!(retry_on_intr(|| read(&reader, &mut buf)).unwrap(), 1); - assert_eq!(buf[0], b'a'); - assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); - - // Poll should now say there's no more data to be read. - let num = retry_on_intr(|| poll(&mut poll_fds, 0)).unwrap(); - assert_eq!(num, 0); - assert!(poll_fds[0].revents().is_empty()); - assert_eq!(poll_fds[0].as_fd().as_raw_fd(), reader.as_fd().as_raw_fd()); -} - -#[test] -fn test_poll_fd_set_fd() { - // Make up some file descriptors so that we can test that set_fd works. - let a = unsafe { OwnedFd::from_raw_fd(777) }; - let mut poll_fd = PollFd::new(&a, PollFlags::empty()); - assert_eq!(poll_fd.as_fd().as_raw_fd(), 777); - - let b = unsafe { OwnedFd::from_raw_fd(888) }; - poll_fd.set_fd(&b); - assert_eq!(poll_fd.as_fd().as_raw_fd(), 888); - - // Don't attempt to close our made-up file descriptors. - let _ = a.into_raw_fd(); - let _ = b.into_raw_fd(); -} diff --git a/vendor/rustix/tests/io/procfs.rs b/vendor/rustix/tests/io/procfs.rs deleted file mode 100644 index 4c4256bd7..000000000 --- a/vendor/rustix/tests/io/procfs.rs +++ /dev/null @@ -1,8 +0,0 @@ -use io_lifetimes::raw::AsRawFilelike; - -#[test] -fn test_proc_self() { - // Verify that this API works at all - let fd = rustix::io::proc_self_fd().unwrap(); - assert_ne!(fd.as_raw_filelike(), 0); -} diff --git a/vendor/rustix/tests/io/read_write.rs b/vendor/rustix/tests/io/read_write.rs deleted file mode 100644 index 65186bf21..000000000 --- a/vendor/rustix/tests/io/read_write.rs +++ /dev/null @@ -1,118 +0,0 @@ -#[cfg(feature = "fs")] -use std::io::{IoSlice, IoSliceMut}; - -#[cfg(feature = "fs")] -#[test] -fn test_readwrite_pv() { - use rustix::fs::{cwd, openat, Mode, OFlags}; - use rustix::io::{preadv, pwritev}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let foo = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - // For most targets, just call `pwritev`. - #[cfg(not(any(target_os = "ios", target_os = "macos")))] - { - pwritev(&foo, &[IoSlice::new(b"hello")], 200).unwrap(); - } - // macOS only has pwritev in newer versions; allow it to fail with `ENOSYS`. - #[cfg(any(target_os = "ios", target_os = "macos"))] - { - match pwritev(&foo, &[IoSlice::new(b"hello")], 200) { - Ok(_) => (), - Err(rustix::io::Errno::NOSYS) => return, - Err(err) => Err(err).unwrap(), - } - } - pwritev(&foo, &[IoSlice::new(b"world")], 300).unwrap(); - let mut buf = [0_u8; 5]; - preadv(&foo, &mut [IoSliceMut::new(&mut buf)], 200).unwrap(); - assert_eq!(&buf, b"hello"); - preadv(&foo, &mut [IoSliceMut::new(&mut buf)], 300).unwrap(); - assert_eq!(&buf, b"world"); -} - -#[cfg(feature = "fs")] -#[test] -fn test_readwrite_p() { - use rustix::fs::{cwd, openat, Mode, OFlags}; - use rustix::io::{pread, pwrite}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let foo = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - pwrite(&foo, b"hello", 200).unwrap(); - pwrite(&foo, b"world", 300).unwrap(); - let mut buf = [0_u8; 5]; - pread(&foo, &mut buf, 200).unwrap(); - assert_eq!(&buf, b"hello"); - pread(&foo, &mut buf, 300).unwrap(); - assert_eq!(&buf, b"world"); -} - -#[cfg(feature = "fs")] -#[test] -fn test_readwrite_v() { - use rustix::fs::{cwd, openat, seek, Mode, OFlags}; - use rustix::io::{readv, writev, SeekFrom}; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let foo = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - writev(&foo, &[IoSlice::new(b"hello")]).unwrap(); - writev(&foo, &[IoSlice::new(b"world")]).unwrap(); - seek(&foo, SeekFrom::Start(0)).unwrap(); - let mut buf = [0_u8; 5]; - readv(&foo, &mut [IoSliceMut::new(&mut buf)]).unwrap(); - assert_eq!(&buf, b"hello"); - readv(&foo, &mut [IoSliceMut::new(&mut buf)]).unwrap(); - assert_eq!(&buf, b"world"); -} - -#[cfg(feature = "fs")] -#[test] -fn test_readwrite() { - use rustix::fs::{cwd, openat, seek, Mode, OFlags}; - use rustix::io::{read, write}; - use std::io::SeekFrom; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - let foo = openat( - &dir, - "foo", - OFlags::RDWR | OFlags::CREATE | OFlags::TRUNC, - Mode::RUSR | Mode::WUSR, - ) - .unwrap(); - - write(&foo, b"hello").unwrap(); - write(&foo, b"world").unwrap(); - seek(&foo, SeekFrom::Start(0)).unwrap(); - let mut buf = [0_u8; 5]; - read(&foo, &mut buf).unwrap(); - assert_eq!(&buf, b"hello"); - read(&foo, &mut buf).unwrap(); - assert_eq!(&buf, b"world"); -} diff --git a/vendor/rustix/tests/io/seals.rs b/vendor/rustix/tests/io/seals.rs deleted file mode 100644 index ff971fa75..000000000 --- a/vendor/rustix/tests/io/seals.rs +++ /dev/null @@ -1,41 +0,0 @@ -#[cfg(feature = "fs")] -#[test] -fn test_seals() { - use rustix::fd::FromFd; - use rustix::fs::{ - fcntl_add_seals, fcntl_get_seals, ftruncate, memfd_create, MemfdFlags, SealFlags, - }; - use std::fs::File; - use std::io::Write; - - let fd = match memfd_create("test", MemfdFlags::CLOEXEC | MemfdFlags::ALLOW_SEALING) { - Ok(fd) => fd, - Err(rustix::io::Errno::NOSYS) => return, - Err(err) => Err(err).unwrap(), - }; - let mut file = File::from_fd(fd.into()); - - let old = fcntl_get_seals(&file).unwrap(); - assert_eq!(old, SealFlags::empty()); - - writeln!(&mut file, "Hello!").unwrap(); - - fcntl_add_seals(&file, SealFlags::GROW).unwrap(); - - let now = fcntl_get_seals(&file).unwrap(); - assert_eq!(now, SealFlags::GROW); - - // We sealed growing, so this should fail. - writeln!(&mut file, "World?").unwrap_err(); - - // We can still shrink for now. - ftruncate(&mut file, 1).unwrap(); - - fcntl_add_seals(&file, SealFlags::SHRINK).unwrap(); - - let now = fcntl_get_seals(&file).unwrap(); - assert_eq!(now, SealFlags::GROW | SealFlags::SHRINK); - - // We sealed shrinking, so this should fail. - ftruncate(&mut file, 0).unwrap_err(); -} diff --git a/vendor/rustix/tests/mm/main.rs b/vendor/rustix/tests/mm/main.rs deleted file mode 100644 index ee746d900..000000000 --- a/vendor/rustix/tests/mm/main.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! Tests for [`rustix::mm`]. - -#![cfg(feature = "mm")] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] - -#[cfg(not(windows))] -#[cfg(not(target_os = "wasi"))] -mod mlock; -#[cfg(not(windows))] -mod mmap; -#[cfg(not(windows))] -mod prot; diff --git a/vendor/rustix/tests/mm/mlock.rs b/vendor/rustix/tests/mm/mlock.rs deleted file mode 100644 index c4a1a83b5..000000000 --- a/vendor/rustix/tests/mm/mlock.rs +++ /dev/null @@ -1,79 +0,0 @@ -//! Tests for `mlock`. -//! -//! We can't easily test that it actually locks memory, but we can test that we -//! can call it and either get success or a reasonable error message. - -use std::ffi::c_void; - -#[test] -fn test_mlock() { - let mut buf = vec![0_u8; 4096]; - - unsafe { - match rustix::mm::mlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()) { - Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), - // Tests won't always have enough memory or permissions, and that's ok. - Err(rustix::io::Errno::PERM) | Err(rustix::io::Errno::NOMEM) => {} - // But they shouldn't fail otherwise. - Err(other) => Err(other).unwrap(), - } - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_mlock_with() { - let mut buf = vec![0_u8; 4096]; - - unsafe { - match rustix::mm::mlock_with( - buf.as_mut_ptr().cast::<c_void>(), - buf.len(), - rustix::mm::MlockFlags::empty(), - ) { - Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), - // Tests won't always have enough memory or permissions, and that's ok. - Err(rustix::io::Errno::PERM) - | Err(rustix::io::Errno::NOMEM) - | Err(rustix::io::Errno::NOSYS) => {} - // But they shouldn't fail otherwise. - Err(other) => Err(other).unwrap(), - } - } -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_mlock_with_onfault() { - // With glibc, `mlock2` with `MLOCK_ONFAULT` returns `EINVAL` if the - // `mlock2` system call returns `ENOSYS`. That's not what we want - // here though, because `ENOSYS` just means the OS doesn't have - // `mlock2`, while `EINVAL` may indicate a bug in rustix. - // - // To work around this, we use `libc::syscall` to make a `mlock2` - // syscall directly to test for `ENOSYS`, before running the main - // test below. - unsafe { - if libc::syscall(libc::SYS_mlock2, 0, 0) == -1 && libc_errno::errno().0 == libc::ENOSYS { - return; - } - } - - let mut buf = vec![0_u8; 4096]; - - unsafe { - match rustix::mm::mlock_with( - buf.as_mut_ptr().cast::<c_void>(), - buf.len(), - rustix::mm::MlockFlags::ONFAULT, - ) { - Ok(()) => rustix::mm::munlock(buf.as_mut_ptr().cast::<c_void>(), buf.len()).unwrap(), - // Tests won't always have enough memory or permissions, and that's ok. - Err(rustix::io::Errno::PERM) - | Err(rustix::io::Errno::NOMEM) - | Err(rustix::io::Errno::NOSYS) => {} - // But they shouldn't fail otherwise. - Err(other) => Err(other).unwrap(), - } - } -} diff --git a/vendor/rustix/tests/mm/mmap.rs b/vendor/rustix/tests/mm/mmap.rs deleted file mode 100644 index 6b27287d7..000000000 --- a/vendor/rustix/tests/mm/mmap.rs +++ /dev/null @@ -1,163 +0,0 @@ -#![cfg(not(target_os = "wasi"))] - -#[cfg(feature = "fs")] -#[cfg(not(target_os = "redox"))] -#[test] -fn test_mmap() { - use rustix::fs::{cwd, openat, Mode, OFlags}; - use rustix::io::write; - use rustix::mm::{mmap, munmap, MapFlags, ProtFlags}; - use std::ptr::null_mut; - use std::slice; - - let tmp = tempfile::tempdir().unwrap(); - let dir = openat(cwd(), tmp.path(), OFlags::RDONLY, Mode::empty()).unwrap(); - - let file = openat( - &dir, - "foo", - OFlags::CREATE | OFlags::WRONLY | OFlags::TRUNC, - Mode::RUSR, - ) - .unwrap(); - write(&file, &[b'a'; 8192]).unwrap(); - drop(file); - - let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); - unsafe { - let addr = mmap( - null_mut(), - 8192, - ProtFlags::READ, - MapFlags::PRIVATE, - &file, - 0, - ) - .unwrap(); - let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); - assert_eq!(slice, &[b'a'; 8192]); - - munmap(addr, 8192).unwrap(); - } - - let file = openat(&dir, "foo", OFlags::RDONLY, Mode::empty()).unwrap(); - unsafe { - assert_eq!( - mmap( - null_mut(), - 8192, - ProtFlags::READ, - MapFlags::PRIVATE, - &file, - u64::MAX, - ) - .unwrap_err() - .raw_os_error(), - libc::EINVAL - ); - } -} - -#[test] -fn test_mmap_anonymous() { - use rustix::mm::{mmap_anonymous, munmap, MapFlags, ProtFlags}; - use std::ptr::null_mut; - use std::slice; - - unsafe { - let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); - let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); - assert_eq!(slice, &[b'\0'; 8192]); - - munmap(addr, 8192).unwrap(); - } -} - -#[test] -fn test_mprotect() { - use rustix::mm::{mmap_anonymous, mprotect, munmap, MapFlags, MprotectFlags, ProtFlags}; - use std::ptr::null_mut; - use std::slice; - - unsafe { - let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); - - mprotect(addr, 8192, MprotectFlags::empty()).unwrap(); - mprotect(addr, 8192, MprotectFlags::READ).unwrap(); - - let slice = slice::from_raw_parts(addr.cast::<u8>(), 8192); - assert_eq!(slice, &[b'\0'; 8192]); - - munmap(addr, 8192).unwrap(); - } -} - -#[test] -fn test_mlock() { - use rustix::mm::{mlock, mmap_anonymous, munlock, munmap, MapFlags, ProtFlags}; - #[cfg(any(target_os = "android", target_os = "linux"))] - use rustix::mm::{mlock_with, MlockFlags}; - use std::ptr::null_mut; - - unsafe { - let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); - - mlock(addr, 8192).unwrap(); - munlock(addr, 8192).unwrap(); - - #[cfg(any(target_os = "android", target_os = "linux"))] - { - match mlock_with(addr, 8192, MlockFlags::empty()) { - Err(rustix::io::Errno::NOSYS) => (), - Err(err) => Err(err).unwrap(), - Ok(()) => munlock(addr, 8192).unwrap(), - } - - #[cfg(linux_raw)] // libc doesn't expose `MLOCK_UNFAULT` yet. - { - match mlock_with(addr, 8192, MlockFlags::ONFAULT) { - Err(rustix::io::Errno::NOSYS) => (), - Err(err) => Err(err).unwrap(), - Ok(()) => munlock(addr, 8192).unwrap(), - } - munlock(addr, 8192).unwrap(); - } - } - - munmap(addr, 8192).unwrap(); - } -} - -#[cfg(not(target_os = "redox"))] -#[test] -fn test_madvise() { - use rustix::mm::{madvise, mmap_anonymous, munmap, Advice, MapFlags, ProtFlags}; - use std::ptr::null_mut; - - unsafe { - let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); - - madvise(addr, 8192, Advice::Normal).unwrap(); - madvise(addr, 8192, Advice::DontNeed).unwrap(); - - #[cfg(any(target_os = "android", target_os = "linux"))] - madvise(addr, 8192, Advice::LinuxDontNeed).unwrap(); - - munmap(addr, 8192).unwrap(); - } -} - -#[test] -fn test_msync() { - use rustix::mm::{mmap_anonymous, msync, munmap, MapFlags, MsyncFlags, ProtFlags}; - use std::ptr::null_mut; - - unsafe { - let addr = mmap_anonymous(null_mut(), 8192, ProtFlags::READ, MapFlags::PRIVATE).unwrap(); - - msync(addr, 8192, MsyncFlags::SYNC).unwrap(); - msync(addr, 8192, MsyncFlags::ASYNC).unwrap(); - - munmap(addr, 8192).unwrap(); - } -} diff --git a/vendor/rustix/tests/mm/prot.rs b/vendor/rustix/tests/mm/prot.rs deleted file mode 100644 index 6c86a8f2a..000000000 --- a/vendor/rustix/tests/mm/prot.rs +++ /dev/null @@ -1,4 +0,0 @@ -#[test] -fn test_prot_flags() { - assert_eq!(libc::PROT_NONE, 0); -} diff --git a/vendor/rustix/tests/net/addr.rs b/vendor/rustix/tests/net/addr.rs deleted file mode 100644 index 124413132..000000000 --- a/vendor/rustix/tests/net/addr.rs +++ /dev/null @@ -1,92 +0,0 @@ -#[test] -fn encode_decode() { - #[cfg(unix)] - use rustix::net::SocketAddrUnix; - use rustix::net::{ - Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrStorage, SocketAddrV4, SocketAddrV6, - }; - - unsafe { - let orig = SocketAddrV4::new(Ipv4Addr::new(2, 3, 5, 6), 33); - let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); - let len = SocketAddrAny::V4(orig).write(encoded.as_mut_ptr()); - let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); - assert_eq!(decoded, SocketAddrAny::V4(orig)); - - let orig = SocketAddrV6::new(Ipv6Addr::new(2, 3, 5, 6, 8, 9, 11, 12), 33, 34, 36); - let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); - let len = SocketAddrAny::V6(orig).write(encoded.as_mut_ptr()); - let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); - assert_eq!(decoded, SocketAddrAny::V6(orig)); - - #[cfg(not(windows))] - { - let orig = SocketAddrUnix::new("/path/to/socket").unwrap(); - let mut encoded = std::mem::MaybeUninit::<SocketAddrStorage>::uninit(); - let len = SocketAddrAny::Unix(orig.clone()).write(encoded.as_mut_ptr()); - let decoded = SocketAddrAny::read(encoded.as_ptr(), len).unwrap(); - assert_eq!(decoded, SocketAddrAny::Unix(orig)); - } - } -} - -#[cfg(not(windows))] -#[test] -fn test_unix_addr() { - use rustix::cstr; - use rustix::net::SocketAddrUnix; - - assert_eq!( - SocketAddrUnix::new("/").unwrap().path().unwrap(), - cstr!("/") - ); - assert_eq!( - SocketAddrUnix::new("//").unwrap().path().unwrap(), - cstr!("//") - ); - assert_eq!( - SocketAddrUnix::new("/foo/bar").unwrap().path().unwrap(), - cstr!("/foo/bar") - ); - assert_eq!( - SocketAddrUnix::new("foo").unwrap().path().unwrap(), - cstr!("foo") - ); - SocketAddrUnix::new("/foo\0/bar").unwrap_err(); - assert!(SocketAddrUnix::new("").unwrap().path().is_none()); - - #[cfg(any(target_os = "android", target_os = "linux"))] - { - assert!(SocketAddrUnix::new("foo") - .unwrap() - .abstract_name() - .is_none()); - - assert_eq!( - SocketAddrUnix::new_abstract_name(b"test") - .unwrap() - .abstract_name() - .unwrap(), - b"test" - ); - assert_eq!( - SocketAddrUnix::new_abstract_name(b"") - .unwrap() - .abstract_name() - .unwrap(), - b"" - ); - assert_eq!( - SocketAddrUnix::new_abstract_name(b"this\0that") - .unwrap() - .abstract_name() - .unwrap(), - b"this\0that" - ); - SocketAddrUnix::new_abstract_name(&[b'a'; 500]).unwrap_err(); - assert!(SocketAddrUnix::new_abstract_name(b"test") - .unwrap() - .path() - .is_none()); - } -} diff --git a/vendor/rustix/tests/net/connect_bind_send.rs b/vendor/rustix/tests/net/connect_bind_send.rs deleted file mode 100644 index 84720975f..000000000 --- a/vendor/rustix/tests/net/connect_bind_send.rs +++ /dev/null @@ -1,487 +0,0 @@ -use rustix::net::{ - AddressFamily, Ipv6Addr, Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4, - SocketAddrV6, SocketType, -}; -use std::net::{IpAddr, Ipv4Addr, SocketAddr}; - -/// Test `connect_any`. -#[test] -fn net_v4_connect_any() -> std::io::Result<()> { - let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Similar, but with V6. -#[test] -fn net_v6_connect_any() -> std::io::Result<()> { - let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Test `connect` with a `SocketAddr`. -#[test] -fn net_v4_connect() -> std::io::Result<()> { - let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let local_addr = match local_addr { - SocketAddrAny::V4(v4) => SocketAddr::V4(v4), - other => panic!("unexpected socket address {:?}", other), - }; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Similar, but use V6. -#[test] -fn net_v6_connect() -> std::io::Result<()> { - let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let local_addr = match local_addr { - SocketAddrAny::V6(v6) => SocketAddr::V6(v6), - other => panic!("unexpected socket address {:?}", other), - }; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Test `bind_any`. -#[test] -fn net_v4_bind_any() -> std::io::Result<()> { - let localhost = Ipv4Addr::LOCALHOST; - let addr = SocketAddrAny::V4(SocketAddrV4::new(localhost, 0)); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind_any(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Similar, but use V6. -#[test] -fn net_v6_bind_any() -> std::io::Result<()> { - let localhost = Ipv6Addr::LOCALHOST; - let addr = SocketAddrAny::V6(SocketAddrV6::new(localhost, 0, 0, 0)); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind_any(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Test `sendto`. -#[test] -fn net_v4_sendto() -> std::io::Result<()> { - let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let local_addr = match local_addr { - SocketAddrAny::V4(v4) => SocketAddr::V4(v4), - other => panic!("unexpected socket address {:?}", other), - }; - let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let (n, from) = - rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - assert!(from.is_none()); - - Ok(()) -} - -/// Similar, but with V6. -#[test] -fn net_v6_sendto() -> std::io::Result<()> { - let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let local_addr = match local_addr { - SocketAddrAny::V6(v6) => SocketAddr::V6(v6), - other => panic!("unexpected socket address {:?}", other), - }; - let n = rustix::net::sendto(&sender, request, SendFlags::empty(), &local_addr).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let (n, from) = - rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - assert!(from.is_none()); - - Ok(()) -} - -/// Test `sendto_any`. -#[test] -fn net_v4_sendto_any() -> std::io::Result<()> { - let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = - rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let (n, from) = - rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - assert!(from.is_none()); - - Ok(()) -} - -/// Test `sendto_any`. -#[test] -fn net_v6_sendto_any() -> std::io::Result<()> { - let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = - rustix::net::sendto_any(&sender, request, SendFlags::empty(), &local_addr).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let accepted = rustix::net::accept(&listener).expect("accept"); - let mut response = [0_u8; 128]; - let (n, from) = - rustix::net::recvfrom(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - assert!(from.is_none()); - - Ok(()) -} - -/// Test `acceptfrom`. -#[test] -fn net_v4_acceptfrom() -> std::io::Result<()> { - let localhost = IpAddr::V4(Ipv4Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default())?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept"); - - assert_ne!(from.clone().unwrap(), local_addr); - - let from = match from.unwrap() { - SocketAddrAny::V4(v4) => v4, - other => panic!("unexpected socket address {:?}", other), - }; - let local_addr = match local_addr { - SocketAddrAny::V4(v4) => v4, - other => panic!("unexpected socket address {:?}", other), - }; - - assert_eq!(from.clone().ip(), local_addr.ip()); - assert_ne!(from.clone().port(), local_addr.port()); - - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} - -/// Similar, but with V6. -#[test] -fn net_v6_acceptfrom() -> std::io::Result<()> { - let localhost = IpAddr::V6(Ipv6Addr::LOCALHOST); - let addr = SocketAddr::new(localhost, 0); - let listener = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::bind(&listener, &addr).expect("bind"); - rustix::net::listen(&listener, 1).expect("listen"); - - let local_addr = rustix::net::getsockname(&listener)?; - let sender = rustix::net::socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - )?; - rustix::net::connect_any(&sender, &local_addr).expect("connect"); - let request = b"Hello, World!!!"; - let n = rustix::net::send(&sender, request, SendFlags::empty()).expect("send"); - drop(sender); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - let (accepted, from) = rustix::net::acceptfrom(&listener).expect("accept"); - - assert_ne!(from.clone().unwrap(), local_addr); - - let from = match from.unwrap() { - SocketAddrAny::V6(v6) => v6, - other => panic!("unexpected socket address {:?}", other), - }; - let local_addr = match local_addr { - SocketAddrAny::V6(v6) => v6, - other => panic!("unexpected socket address {:?}", other), - }; - - assert_eq!(from.clone().ip(), local_addr.ip()); - assert_ne!(from.clone().port(), local_addr.port()); - - let mut response = [0_u8; 128]; - let n = rustix::net::recv(&accepted, &mut response, RecvFlags::empty()).expect("recv"); - - // Not strictly required, but it makes the test simpler. - assert_eq!(n, request.len()); - - assert_eq!(request, &response[..n]); - - Ok(()) -} diff --git a/vendor/rustix/tests/net/main.rs b/vendor/rustix/tests/net/main.rs deleted file mode 100644 index 0745282aa..000000000 --- a/vendor/rustix/tests/net/main.rs +++ /dev/null @@ -1,32 +0,0 @@ -//! Tests for [`rustix::net`]. - -#![cfg(feature = "net")] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg_attr(core_c_str, feature(core_c_str))] - -mod addr; -mod connect_bind_send; -mod poll; -mod sockopt; -#[cfg(unix)] -mod unix; -mod v4; -mod v6; - -/// Windows requires us to call a setup function before using any of the -/// socket APIs. -#[cfg(windows)] -#[ctor::ctor] -fn windows_startup() { - let _ = rustix::net::wsa_startup().unwrap(); -} - -/// Windows requires us to call a cleanup function after using any of the -/// socket APIs. -#[cfg(windows)] -#[ctor::dtor] -fn windows_shutdown() { - rustix::net::wsa_cleanup().unwrap(); -} diff --git a/vendor/rustix/tests/net/poll.rs b/vendor/rustix/tests/net/poll.rs deleted file mode 100644 index 7933983f2..000000000 --- a/vendor/rustix/tests/net/poll.rs +++ /dev/null @@ -1,119 +0,0 @@ -//! The same as v6.rs, but with `poll` calls. - -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] - -use rustix::io::{poll, PollFd, PollFlags}; -use rustix::net::{ - accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr, - Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType, -}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; - -const BUFFER_SIZE: usize = 20; - -fn server(ready: Arc<(Mutex<u16>, Condvar)>) { - let connection_socket = socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - ) - .unwrap(); - - let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0); - bind_v6(&connection_socket, &name).unwrap(); - - let who = match getsockname(&connection_socket).unwrap() { - SocketAddrAny::V6(addr) => addr, - _ => panic!(), - }; - - listen(&connection_socket, 1).unwrap(); - - { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - *port = who.port(); - cvar.notify_all(); - } - - let mut buffer = vec![0; BUFFER_SIZE]; - let data_socket = accept(&connection_socket).unwrap(); - - let mut fds = [PollFd::new(&data_socket, PollFlags::IN)]; - assert_eq!(poll(&mut fds, -1).unwrap(), 1); - assert!(fds[0].revents().intersects(PollFlags::IN)); - assert!(!fds[0].revents().intersects(PollFlags::OUT)); - - let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap(); - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); - assert_eq!(expected_nread, nread as u64); - - let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)]; - assert_eq!(poll(&mut fds, -1).unwrap(), 1); - assert!(!fds[0].revents().intersects(PollFlags::IN)); - assert!(fds[0].revents().intersects(PollFlags::OUT)); - - send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); -} - -fn client(ready: Arc<(Mutex<u16>, Condvar)>) { - let port = { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - while *port == 0 { - port = cvar.wait(port).unwrap(); - } - *port - }; - - let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0); - let mut buffer = vec![0; BUFFER_SIZE]; - - let data_socket = socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - ) - .unwrap(); - connect_v6(&data_socket, &addr).unwrap(); - - let mut fds = [PollFd::new(&data_socket, PollFlags::OUT)]; - assert_eq!(poll(&mut fds, -1).unwrap(), 1); - assert!(!fds[0].revents().intersects(PollFlags::IN)); - assert!(fds[0].revents().intersects(PollFlags::OUT)); - - send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); - - let mut fds = [PollFd::new(&data_socket, PollFlags::IN)]; - assert_eq!(poll(&mut fds, -1).unwrap(), 1); - assert!(fds[0].revents().intersects(PollFlags::IN)); - assert!(!fds[0].revents().intersects(PollFlags::OUT)); - - let expected_nread = rustix::io::ioctl_fionread(&data_socket).unwrap(); - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); - assert_eq!(expected_nread, nread as u64); -} - -#[test] -fn test_poll() { - let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); - let ready_clone = Arc::clone(&ready); - - let server = thread::Builder::new() - .name("server".to_string()) - .spawn(move || { - server(ready); - }) - .unwrap(); - let client = thread::Builder::new() - .name("client".to_string()) - .spawn(move || { - client(ready_clone); - }) - .unwrap(); - client.join().unwrap(); - server.join().unwrap(); -} diff --git a/vendor/rustix/tests/net/sockopt.rs b/vendor/rustix/tests/net/sockopt.rs deleted file mode 100644 index 8e4cf52e8..000000000 --- a/vendor/rustix/tests/net/sockopt.rs +++ /dev/null @@ -1,158 +0,0 @@ -#[test] -fn test_sockopts() { - use rustix::net::{AddressFamily, Protocol, SocketType}; - use std::time::Duration; - - let s = - rustix::net::socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); - - // On a new socket we shouldn't have a timeout yet. - assert!( - rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) - .unwrap() - .is_none() - ); - assert_eq!( - rustix::net::sockopt::get_socket_type(&s).unwrap(), - SocketType::STREAM - ); - #[cfg(not(windows))] - assert_eq!( - rustix::net::sockopt::get_socket_broadcast(&s).unwrap(), - false - ); - // On a new socket we shouldn't have a linger yet. - assert!(rustix::net::sockopt::get_socket_linger(&s) - .unwrap() - .is_none()); - #[cfg(any(target_os = "android", target_os = "linux"))] - assert_eq!( - rustix::net::sockopt::get_socket_passcred(&s).unwrap(), - false - ); - assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 0); - assert_ne!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77); - #[cfg(not(any( - windows, - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - )))] - assert_eq!( - rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(), - true - ); - #[cfg(not(any( - windows, - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - )))] - assert_eq!(rustix::net::sockopt::get_ip_multicast_ttl(&s).unwrap(), 1); - assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), false); - - // Set a timeout. - rustix::net::sockopt::set_socket_timeout( - &s, - rustix::net::sockopt::Timeout::Recv, - Some(Duration::new(1, 1)), - ) - .unwrap(); - - // Check that we have a timeout of at least the time we set. - if cfg!(not(target_os = "freebsd")) { - assert!( - rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) - .unwrap() - .unwrap() - >= Duration::new(1, 1) - ); - } else { - // On FreeBSD <= 12, it appears the system rounds the timeout down. - assert!( - rustix::net::sockopt::get_socket_timeout(&s, rustix::net::sockopt::Timeout::Recv) - .unwrap() - .unwrap() - >= Duration::new(1, 0) - ); - } - - #[cfg(not(windows))] - { - // Set the broadcast flag; - rustix::net::sockopt::set_socket_broadcast(&s, true).unwrap(); - - // Check that the broadcast flag is set. This has no effect on stream - // sockets, and not all platforms even remember the value. - #[cfg(not(any( - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - )))] - assert_eq!( - rustix::net::sockopt::get_socket_broadcast(&s).unwrap(), - true - ); - } - - // Set a linger. - rustix::net::sockopt::set_socket_linger(&s, Some(Duration::new(1, 1))).unwrap(); - - // Check that we have a linger of at least the time we set. - assert!( - dbg!(rustix::net::sockopt::get_socket_linger(&s) - .unwrap() - .unwrap()) - >= Duration::new(1, 1) - ); - - #[cfg(any(target_os = "android", target_os = "linux"))] - { - // Set the passcred flag; - rustix::net::sockopt::set_socket_passcred(&s, true).unwrap(); - - // Check that the passcred flag is set. - assert_eq!(rustix::net::sockopt::get_socket_passcred(&s).unwrap(), true); - } - - // Set the ip ttl. - rustix::net::sockopt::set_ip_ttl(&s, 77).unwrap(); - - // Check the ip ttl. - assert_eq!(rustix::net::sockopt::get_ip_ttl(&s).unwrap(), 77); - - #[cfg(not(any( - windows, - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd", - )))] - { - // Set the multicast loop flag; - rustix::net::sockopt::set_ip_multicast_loop(&s, false).unwrap(); - - // Check that the multicast loop flag is set. - assert_eq!( - rustix::net::sockopt::get_ip_multicast_loop(&s).unwrap(), - false - ); - } - - // Set the nodelay flag; - rustix::net::sockopt::set_tcp_nodelay(&s, true).unwrap(); - - // Check that the nodelay flag is set. - assert_eq!(rustix::net::sockopt::get_tcp_nodelay(&s).unwrap(), true); -} diff --git a/vendor/rustix/tests/net/unix.rs b/vendor/rustix/tests/net/unix.rs deleted file mode 100644 index 21a6542f8..000000000 --- a/vendor/rustix/tests/net/unix.rs +++ /dev/null @@ -1,147 +0,0 @@ -//! Test a simple Unix-domain socket server and client. -//! -//! The client sends lists of integers and the server sends back sums. - -// This test uses `AF_UNIX` with `SOCK_SEQPACKET` which is unsupported on macOS. -#![cfg(not(any( - target_os = "ios", - target_os = "macos", - target_os = "redox", - target_os = "wasi", -)))] -// This test uses `DecInt`. -#![cfg(feature = "itoa")] -#![cfg(feature = "fs")] - -use rustix::fs::{cwd, unlinkat, AtFlags}; -use rustix::io::{read, write}; -use rustix::net::{ - accept, bind_unix, connect_unix, listen, socket, AddressFamily, Protocol, SocketAddrUnix, - SocketType, -}; -use rustix::path::DecInt; -use std::path::Path; -use std::str::FromStr; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; - -const BUFFER_SIZE: usize = 20; - -fn server(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path) { - let connection_socket = socket( - AddressFamily::UNIX, - SocketType::SEQPACKET, - Protocol::default(), - ) - .unwrap(); - - let name = SocketAddrUnix::new(path).unwrap(); - bind_unix(&connection_socket, &name).unwrap(); - listen(&connection_socket, 1).unwrap(); - - { - let (lock, cvar) = &*ready; - let mut started = lock.lock().unwrap(); - *started = true; - cvar.notify_all(); - } - - let mut buffer = vec![0; BUFFER_SIZE]; - 'exit: loop { - let data_socket = accept(&connection_socket).unwrap(); - let mut sum = 0; - loop { - let nread = read(&data_socket, &mut buffer).unwrap(); - - if &buffer[..nread] == b"exit" { - break 'exit; - } - if &buffer[..nread] == b"sum" { - break; - } - - sum += i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap(); - } - - write(&data_socket, DecInt::new(sum).as_bytes()).unwrap(); - } - - unlinkat(cwd(), path, AtFlags::empty()).unwrap(); -} - -fn client(ready: Arc<(Mutex<bool>, Condvar)>, path: &Path, runs: &[(&[&str], i32)]) { - { - let (lock, cvar) = &*ready; - let mut started = lock.lock().unwrap(); - while !*started { - started = cvar.wait(started).unwrap(); - } - } - - let addr = SocketAddrUnix::new(path).unwrap(); - let mut buffer = vec![0; BUFFER_SIZE]; - - for (args, sum) in runs { - let data_socket = socket( - AddressFamily::UNIX, - SocketType::SEQPACKET, - Protocol::default(), - ) - .unwrap(); - connect_unix(&data_socket, &addr).unwrap(); - - for arg in *args { - write(&data_socket, arg.as_bytes()).unwrap(); - } - write(&data_socket, b"sum").unwrap(); - - let nread = read(&data_socket, &mut buffer).unwrap(); - assert_eq!( - i32::from_str(&String::from_utf8_lossy(&buffer[..nread])).unwrap(), - *sum - ); - } - - let data_socket = socket( - AddressFamily::UNIX, - SocketType::SEQPACKET, - Protocol::default(), - ) - .unwrap(); - connect_unix(&data_socket, &addr).unwrap(); - write(&data_socket, b"exit").unwrap(); -} - -#[test] -fn test_unix() { - let ready = Arc::new((Mutex::new(false), Condvar::new())); - let ready_clone = Arc::clone(&ready); - - let tmp = tempfile::tempdir().unwrap(); - let path = tmp.path().join("soccer"); - let send_path = path.to_owned(); - let server = thread::Builder::new() - .name("server".to_string()) - .spawn(move || { - server(ready, &send_path); - }) - .unwrap(); - let send_path = path.to_owned(); - let client = thread::Builder::new() - .name("client".to_string()) - .spawn(move || { - client( - ready_clone, - &send_path, - &[ - (&["1", "2"], 3), - (&["4", "77", "103"], 184), - (&["5", "78", "104"], 187), - (&[], 0), - ], - ); - }) - .unwrap(); - client.join().unwrap(); - server.join().unwrap(); -} diff --git a/vendor/rustix/tests/net/v4.rs b/vendor/rustix/tests/net/v4.rs deleted file mode 100644 index 0908057be..000000000 --- a/vendor/rustix/tests/net/v4.rs +++ /dev/null @@ -1,86 +0,0 @@ -//! Test a simple IPv4 socket server and client. -//! -//! The client send a message and the server sends one back. - -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] - -use rustix::net::{ - accept, bind_v4, connect_v4, getsockname, listen, recv, send, socket, AddressFamily, Ipv4Addr, - Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV4, SocketType, -}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; - -const BUFFER_SIZE: usize = 20; - -fn server(ready: Arc<(Mutex<u16>, Condvar)>) { - let connection_socket = - socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); - - let name = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 0); - bind_v4(&connection_socket, &name).unwrap(); - - let who = match getsockname(&connection_socket).unwrap() { - SocketAddrAny::V4(addr) => addr, - _ => panic!(), - }; - - listen(&connection_socket, 1).unwrap(); - - { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - *port = who.port(); - cvar.notify_all(); - } - - let mut buffer = vec![0; BUFFER_SIZE]; - let data_socket = accept(&connection_socket).unwrap(); - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); - - send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); -} - -fn client(ready: Arc<(Mutex<u16>, Condvar)>) { - let port = { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - while *port == 0 { - port = cvar.wait(port).unwrap(); - } - *port - }; - - let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), port); - let mut buffer = vec![0; BUFFER_SIZE]; - - let data_socket = socket(AddressFamily::INET, SocketType::STREAM, Protocol::default()).unwrap(); - connect_v4(&data_socket, &addr).unwrap(); - - send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); - - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); -} - -#[test] -fn test_v4() { - let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); - let ready_clone = Arc::clone(&ready); - - let server = thread::Builder::new() - .name("server".to_string()) - .spawn(move || { - server(ready); - }) - .unwrap(); - let client = thread::Builder::new() - .name("client".to_string()) - .spawn(move || { - client(ready_clone); - }) - .unwrap(); - client.join().unwrap(); - server.join().unwrap(); -} diff --git a/vendor/rustix/tests/net/v6.rs b/vendor/rustix/tests/net/v6.rs deleted file mode 100644 index 07205be89..000000000 --- a/vendor/rustix/tests/net/v6.rs +++ /dev/null @@ -1,95 +0,0 @@ -//! Test a simple IPv6 socket server and client. -//! -//! The client send a message and the server sends one back. - -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] - -use rustix::net::{ - accept, bind_v6, connect_v6, getsockname, listen, recv, send, socket, AddressFamily, Ipv6Addr, - Protocol, RecvFlags, SendFlags, SocketAddrAny, SocketAddrV6, SocketType, -}; -use std::sync::{Arc, Condvar, Mutex}; -use std::thread; - -const BUFFER_SIZE: usize = 20; - -fn server(ready: Arc<(Mutex<u16>, Condvar)>) { - let connection_socket = socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - ) - .unwrap(); - - let name = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 0, 0, 0); - bind_v6(&connection_socket, &name).unwrap(); - - let who = match getsockname(&connection_socket).unwrap() { - SocketAddrAny::V6(addr) => addr, - _ => panic!(), - }; - - listen(&connection_socket, 1).unwrap(); - - { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - *port = who.port(); - cvar.notify_all(); - } - - let mut buffer = vec![0; BUFFER_SIZE]; - let data_socket = accept(&connection_socket).unwrap(); - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "hello, world"); - - send(&data_socket, b"goodnight, moon", SendFlags::empty()).unwrap(); -} - -fn client(ready: Arc<(Mutex<u16>, Condvar)>) { - let port = { - let (lock, cvar) = &*ready; - let mut port = lock.lock().unwrap(); - while *port == 0 { - port = cvar.wait(port).unwrap(); - } - *port - }; - - let addr = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), port, 0, 0); - let mut buffer = vec![0; BUFFER_SIZE]; - - let data_socket = socket( - AddressFamily::INET6, - SocketType::STREAM, - Protocol::default(), - ) - .unwrap(); - connect_v6(&data_socket, &addr).unwrap(); - - send(&data_socket, b"hello, world", SendFlags::empty()).unwrap(); - - let nread = recv(&data_socket, &mut buffer, RecvFlags::empty()).unwrap(); - assert_eq!(String::from_utf8_lossy(&buffer[..nread]), "goodnight, moon"); -} - -#[test] -fn test_v6() { - let ready = Arc::new((Mutex::new(0_u16), Condvar::new())); - let ready_clone = Arc::clone(&ready); - - let server = thread::Builder::new() - .name("server".to_string()) - .spawn(move || { - server(ready); - }) - .unwrap(); - let client = thread::Builder::new() - .name("client".to_string()) - .spawn(move || { - client(ready_clone); - }) - .unwrap(); - client.join().unwrap(); - server.join().unwrap(); -} diff --git a/vendor/rustix/tests/param/auxv.rs b/vendor/rustix/tests/param/auxv.rs deleted file mode 100644 index 90a088101..000000000 --- a/vendor/rustix/tests/param/auxv.rs +++ /dev/null @@ -1,41 +0,0 @@ -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -use rustix::param::linux_hwcap; -use rustix::param::{clock_ticks_per_second, page_size}; - -#[test] -fn test_page_size() { - let size = page_size(); - assert_ne!(size, 0); - assert!(size.is_power_of_two()); - assert_eq!(size, page_size()); - assert_eq!(size, unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }); -} - -#[test] -fn test_clock_ticks_per_second() { - let size = clock_ticks_per_second(); - assert_ne!(size, 0); - assert_eq!(size, unsafe { libc::sysconf(libc::_SC_CLK_TCK) as u64 }); -} - -#[cfg(any( - all(target_os = "android", target_pointer_width = "64"), - target_os = "linux", -))] -#[test] -fn test_linux_hwcap() { - weak!(fn getauxval(libc::c_ulong) -> libc::c_ulong); - - if let Some(libc_getauxval) = getauxval.get() { - let (_hwcap, hwcap2) = linux_hwcap(); - - // GLIBC seems to return a different value than `LD_SHOW_AUXV=1` reports. - #[cfg(not(target_env = "gnu"))] - assert_eq!(_hwcap, unsafe { libc_getauxval(libc::AT_HWCAP) } as usize); - - assert_eq!(hwcap2, unsafe { libc_getauxval(libc::AT_HWCAP2) } as usize); - } -} diff --git a/vendor/rustix/tests/param/main.rs b/vendor/rustix/tests/param/main.rs deleted file mode 100644 index e350a6f1f..000000000 --- a/vendor/rustix/tests/param/main.rs +++ /dev/null @@ -1,14 +0,0 @@ -//! Tests for [`rustix::param`]. - -#![cfg(feature = "param")] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg_attr(core_c_str, feature(core_c_str))] - -#[cfg(not(target_os = "wasi"))] -#[macro_use] -mod weak; - -#[cfg(not(target_os = "wasi"))] -mod auxv; diff --git a/vendor/rustix/tests/param/weak.rs b/vendor/rustix/tests/param/weak.rs deleted file mode 100644 index 377a8a5a1..000000000 --- a/vendor/rustix/tests/param/weak.rs +++ /dev/null @@ -1,201 +0,0 @@ -// Implementation derived from `weak` in Rust's -// library/std/src/sys/unix/weak.rs at revision -// fd0cb0cdc21dd9c06025277d772108f8d42cb25f. - -//! Support for "weak linkage" to symbols on Unix -//! -//! Some I/O operations we do in libstd require newer versions of OSes but we -//! need to maintain binary compatibility with older releases for now. In order -//! to use the new functionality when available we use this module for -//! detection. -//! -//! One option to use here is weak linkage, but that is unfortunately only -//! really workable on Linux. Hence, use dlsym to get the symbol value at -//! runtime. This is also done for compatibility with older versions of glibc, -//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes -//! that we've been dynamically linked to the library the symbol comes from, -//! but that is currently always the case for things like libpthread/libc. -//! -//! A long time ago this used weak linkage for the `__pthread_get_minstack` -//! symbol, but that caused Debian to detect an unnecessarily strict versioned -//! dependency on libc6 (#23628). - -// There are a variety of `#[cfg]`s controlling which targets are involved in -// each instance of `weak!` and `syscall!`. Rather than trying to unify all of -// that, we'll just allow that some unix targets don't use this module at all. -#![allow(dead_code, unused_macros)] -#![allow(clippy::doc_markdown)] - -use core::ffi::c_void; -use core::ptr::null_mut; -use core::sync::atomic::{self, AtomicPtr, Ordering}; -use core::{marker, mem}; -use rustix::ffi::CStr; - -const NULL: *mut c_void = null_mut(); -const INVALID: *mut c_void = 1 as *mut c_void; - -macro_rules! weak { - (fn $name:ident($($t:ty),*) -> $ret:ty) => ( - #[allow(non_upper_case_globals)] - static $name: $crate::weak::Weak<unsafe extern fn($($t),*) -> $ret> = - $crate::weak::Weak::new(concat!(stringify!($name), '\0')); - ) -} - -pub(crate) struct Weak<F> { - name: &'static str, - addr: AtomicPtr<c_void>, - _marker: marker::PhantomData<F>, -} - -impl<F> Weak<F> { - pub(crate) const fn new(name: &'static str) -> Self { - Self { - name, - addr: AtomicPtr::new(INVALID), - _marker: marker::PhantomData, - } - } - - pub(crate) fn get(&self) -> Option<F> { - assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); - unsafe { - // Relaxed is fine here because we fence before reading through the - // pointer (see the comment below). - match self.addr.load(Ordering::Relaxed) { - INVALID => self.initialize(), - NULL => None, - addr => { - let func = mem::transmute_copy::<*mut c_void, F>(&addr); - // The caller is presumably going to read through this value - // (by calling the function we've dlsymed). This means we'd - // need to have loaded it with at least C11's consume - // ordering in order to be guaranteed that the data we read - // from the pointer isn't from before the pointer was - // stored. Rust has no equivalent to memory_order_consume, - // so we use an acquire fence (sorry, ARM). - // - // Now, in practice this likely isn't needed even on CPUs - // where relaxed and consume mean different things. The - // symbols we're loading are probably present (or not) at - // init, and even if they aren't the runtime dynamic loader - // is extremely likely have sufficient barriers internally - // (possibly implicitly, for example the ones provided by - // invoking `mprotect`). - // - // That said, none of that's *guaranteed*, and so we fence. - atomic::fence(Ordering::Acquire); - Some(func) - } - } - } - } - - // Cold because it should only happen during first-time initialization. - #[cold] - unsafe fn initialize(&self) -> Option<F> { - let val = fetch(self.name); - // This synchronizes with the acquire fence in `get`. - self.addr.store(val, Ordering::Release); - - match val { - NULL => None, - addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)), - } - } -} - -unsafe fn fetch(name: &str) -> *mut c_void { - let name = match CStr::from_bytes_with_nul(name.as_bytes()) { - Ok(c_str) => c_str, - Err(..) => return null_mut(), - }; - libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) -} - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - errno::set_errno(errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - unsafe fn $name($($arg_name:$t),*) -> $ret { - // This looks like a hack, but concat_idents only accepts idents - // (not paths). - use libc::*; - - trait AsSyscallArg { - type SyscallArgType; - fn as_syscall_arg(self) -> Self::SyscallArgType; - } - - // Pass pointer types as pointers, to preserve provenance. - impl<T> AsSyscallArg for *mut T { - type SyscallArgType = *mut T; - fn as_syscall_arg(self) -> Self::SyscallArgType { self } - } - impl<T> AsSyscallArg for *const T { - type SyscallArgType = *const T; - fn as_syscall_arg(self) -> Self::SyscallArgType { self } - } - - // Pass `BorrowedFd` values as the integer value. - impl AsSyscallArg for $crate::fd::BorrowedFd<'_> { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { - $crate::fd::AsRawFd::as_raw_fd(&self) as _ - } - } - - // Coerce integer values into `c_long`. - impl AsSyscallArg for i32 { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for u32 { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for usize { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - - syscall( - concat_idents!(SYS_, $name), - $($arg_name.as_syscall_arg()),* - ) as $ret - } - ) -} - -macro_rules! weakcall { - ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - $vis unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` - // interposition, but if it's not found just fail. - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - errno::set_errno(errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} diff --git a/vendor/rustix/tests/path/arg.rs b/vendor/rustix/tests/path/arg.rs deleted file mode 100644 index 0eb511be1..000000000 --- a/vendor/rustix/tests/path/arg.rs +++ /dev/null @@ -1,167 +0,0 @@ -use rustix::ffi::{CStr, CString}; -use rustix::io; -use rustix::path::Arg; -#[cfg(feature = "itoa")] -use rustix::path::DecInt; -use std::borrow::Cow; -use std::ffi::{OsStr, OsString}; -use std::path::{Component, Components, Iter, Path, PathBuf}; - -#[test] -fn test_arg() { - use rustix::cstr; - use std::borrow::Borrow; - - let t: &str = "hello"; - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: String = "hello".to_owned(); - assert_eq!("hello", Arg::as_str(&t).unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: &OsStr = OsStr::new("hello"); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: OsString = OsString::from("hello".to_owned()); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: &Path = Path::new("hello"); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: PathBuf = PathBuf::from("hello".to_owned()); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: &CStr = cstr!("hello"); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: CString = cstr!("hello").to_owned(); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!( - cstr!("hello"), - Borrow::borrow(&Arg::as_cow_c_str(&t).unwrap()) - ); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Components = Path::new("hello").components(); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Component = Path::new("hello").components().next().unwrap(); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Iter = Path::new("hello").iter(); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, str> = Cow::Borrowed("hello"); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, str> = Cow::Owned("hello".to_owned()); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, OsStr> = Cow::Borrowed(OsStr::new("hello")); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, OsStr> = Cow::Owned(OsString::from("hello".to_owned())); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, CStr> = Cow::Borrowed(cstr!("hello")); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Cow<'_, CStr> = Cow::Owned(cstr!("hello").to_owned()); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: &[u8] = b"hello"; - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - let t: Vec<u8> = b"hello".to_vec(); - assert_eq!("hello", t.as_str().unwrap()); - assert_eq!("hello".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("hello"), Borrow::borrow(&t.into_c_str().unwrap())); - - #[cfg(feature = "itoa")] - { - let t: DecInt = DecInt::new(43110); - assert_eq!("43110", t.as_str()); - assert_eq!("43110".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(cstr!("43110"), Borrow::borrow(&t.as_cow_c_str().unwrap())); - assert_eq!(cstr!("43110"), t.as_c_str()); - assert_eq!(cstr!("43110"), Borrow::borrow(&t.into_c_str().unwrap())); - } -} - -#[test] -fn test_invalid() { - use std::borrow::Borrow; - - let t: &[u8] = b"hello\xc0world"; - assert_eq!(t.as_str().unwrap_err(), io::Errno::INVAL); - assert_eq!("hello\u{fffd}world".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!( - b"hello\xc0world\0", - Borrow::<CStr>::borrow(&t.as_cow_c_str().unwrap()).to_bytes_with_nul() - ); - assert_eq!( - b"hello\xc0world\0", - Borrow::<CStr>::borrow(&t.into_c_str().unwrap()).to_bytes_with_nul() - ); -} - -#[test] -fn test_embedded_nul() { - let t: &[u8] = b"hello\0world"; - assert_eq!("hello\0world", t.as_str().unwrap()); - assert_eq!("hello\0world".to_owned(), Arg::to_string_lossy(&t)); - assert_eq!(t.as_cow_c_str().unwrap_err(), io::Errno::INVAL); - assert_eq!(t.into_c_str().unwrap_err(), io::Errno::INVAL); -} diff --git a/vendor/rustix/tests/path/dec_int.rs b/vendor/rustix/tests/path/dec_int.rs deleted file mode 100644 index 6ce1a5123..000000000 --- a/vendor/rustix/tests/path/dec_int.rs +++ /dev/null @@ -1,20 +0,0 @@ -use rustix::path::DecInt; - -#[test] -fn test_dec_int() { - assert_eq!(DecInt::new(0).as_ref().to_str().unwrap(), "0"); - assert_eq!(DecInt::new(-1).as_ref().to_str().unwrap(), "-1"); - assert_eq!(DecInt::new(789).as_ref().to_str().unwrap(), "789"); - assert_eq!( - DecInt::new(i64::MIN).as_ref().to_str().unwrap(), - i64::MIN.to_string() - ); - assert_eq!( - DecInt::new(i64::MAX).as_ref().to_str().unwrap(), - i64::MAX.to_string() - ); - assert_eq!( - DecInt::new(u64::MAX).as_ref().to_str().unwrap(), - u64::MAX.to_string() - ); -} diff --git a/vendor/rustix/tests/path/main.rs b/vendor/rustix/tests/path/main.rs deleted file mode 100644 index 3215c7e5e..000000000 --- a/vendor/rustix/tests/path/main.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! Tests for [`rustix::path`]. - -#![cfg(any(feature = "fs", feature = "net"))] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg_attr(core_c_str, feature(core_c_str))] -#![cfg_attr(alloc_c_string, feature(alloc_c_string))] - -#[cfg(not(feature = "rustc-dep-of-std"))] -mod arg; -#[cfg(feature = "itoa")] -mod dec_int; diff --git a/vendor/rustix/tests/process/cpu_set.rs b/vendor/rustix/tests/process/cpu_set.rs deleted file mode 100644 index c4d9edf08..000000000 --- a/vendor/rustix/tests/process/cpu_set.rs +++ /dev/null @@ -1,14 +0,0 @@ -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_cpu_set() { - let set = rustix::process::sched_getaffinity(None).unwrap(); - - let mut count = 0; - for i in 0..rustix::process::CpuSet::MAX_CPU { - if set.is_set(i) { - count += 1; - } - } - - assert_eq!(count, set.count()); -} diff --git a/vendor/rustix/tests/process/id.rs b/vendor/rustix/tests/process/id.rs deleted file mode 100644 index 10095fa60..000000000 --- a/vendor/rustix/tests/process/id.rs +++ /dev/null @@ -1,65 +0,0 @@ -use rustix::process; - -#[test] -fn test_getuid() { - assert_eq!(process::getuid(), process::getuid()); - unsafe { - assert_eq!(process::getuid().as_raw(), libc::getuid()); - assert_eq!(process::getuid().is_root(), libc::getuid() == 0); - } -} - -#[test] -fn test_getgid() { - assert_eq!(process::getgid(), process::getgid()); - unsafe { - assert_eq!(process::getgid().as_raw(), libc::getgid()); - assert_eq!(process::getgid().is_root(), libc::getgid() == 0); - } -} - -#[test] -fn test_geteuid() { - assert_eq!(process::geteuid(), process::geteuid()); - unsafe { - assert_eq!(process::geteuid().as_raw(), libc::geteuid()); - assert_eq!(process::geteuid().is_root(), libc::geteuid() == 0); - } -} - -#[test] -fn test_getegid() { - assert_eq!(process::getegid(), process::getegid()); - unsafe { - assert_eq!(process::getegid().as_raw(), libc::getegid()); - assert_eq!(process::getegid().is_root(), libc::getegid() == 0); - } -} - -#[test] -fn test_getpid() { - assert_eq!(process::getpid(), process::getpid()); - unsafe { - assert_eq!( - process::getpid().as_raw_nonzero().get() as libc::pid_t, - libc::getpid() - ); - assert_eq!(process::getpid().is_init(), libc::getpid() == 1); - } -} - -#[test] -fn test_getppid() { - assert_eq!(process::getppid(), process::getppid()); - unsafe { - assert_eq!( - process::Pid::as_raw(process::getppid()) as libc::pid_t, - libc::getppid() - ); - if let Some(ppid) = process::getppid() { - assert_eq!(ppid.is_init(), libc::getppid() == 1); - } else { - assert_eq!(libc::getppid(), 0); - } - } -} diff --git a/vendor/rustix/tests/process/main.rs b/vendor/rustix/tests/process/main.rs deleted file mode 100644 index 90aa34c59..000000000 --- a/vendor/rustix/tests/process/main.rs +++ /dev/null @@ -1,28 +0,0 @@ -//! Tests for [`rustix::process`]. - -#![cfg(feature = "process")] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg_attr(core_c_str, feature(core_c_str))] - -#[cfg(not(target_os = "wasi"))] -#[macro_use] -mod weak; - -mod cpu_set; -#[cfg(not(target_os = "wasi"))] // WASI doesn't have get[gpu]id. -mod id; -#[cfg(any(target_os = "android", target_os = "linux"))] -mod membarrier; -#[cfg(not(any(target_os = "fuchsia", target_os = "wasi")))] // WASI doesn't have [gs]etpriority. -mod priority; -#[cfg(not(any(target_os = "fuchsia", target_os = "redox", target_os = "wasi")))] -mod rlimit; -mod sched_yield; -#[cfg(not(target_os = "wasi"))] // WASI doesn't have uname. -mod uname; -#[cfg(not(target_os = "wasi"))] // WASI doesn't have waitpid. -mod wait; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -mod working_directory; diff --git a/vendor/rustix/tests/process/membarrier.rs b/vendor/rustix/tests/process/membarrier.rs deleted file mode 100644 index ed9b00c1a..000000000 --- a/vendor/rustix/tests/process/membarrier.rs +++ /dev/null @@ -1,40 +0,0 @@ -#[test] -fn test_membarrier() { - use rustix::process::{membarrier, membarrier_query, MembarrierCommand, MembarrierQuery}; - - let query: MembarrierQuery = membarrier_query(); - - // Supported registration commands should succeed. - for cmd in [ - MembarrierCommand::RegisterGlobalExpedited, - MembarrierCommand::RegisterPrivateExpedited, - MembarrierCommand::RegisterPrivateExpeditedSyncCore, - MembarrierCommand::RegisterPrivateExpeditedRseq, - ] - .iter() - .copied() - { - if query.contains_command(cmd) { - membarrier(cmd).unwrap(); - } - } - - // All supported commands should now succeed, and all unsupported - // commands should fail. - for cmd in [ - MembarrierCommand::Global, - MembarrierCommand::GlobalExpedited, - MembarrierCommand::PrivateExpedited, - MembarrierCommand::PrivateExpeditedSyncCore, - MembarrierCommand::PrivateExpeditedRseq, - ] - .iter() - .copied() - { - if query.contains_command(cmd) { - membarrier(cmd).unwrap(); - } else { - membarrier(cmd).unwrap_err(); - } - } -} diff --git a/vendor/rustix/tests/process/priority.rs b/vendor/rustix/tests/process/priority.rs deleted file mode 100644 index 7feb1467a..000000000 --- a/vendor/rustix/tests/process/priority.rs +++ /dev/null @@ -1,83 +0,0 @@ -use rustix::process::nice; -#[cfg(not(target_os = "redox"))] -use rustix::process::{getpriority_process, setpriority_process}; - -#[cfg(not(target_os = "freebsd"))] // FreeBSD's nice(3) doesn't return the old value. -#[test] -fn test_priorities() { - let old = nice(0).unwrap(); - - #[cfg(not(target_os = "redox"))] - { - let get_prio = getpriority_process(None).unwrap(); - assert_eq!(get_prio, old); - } - - // Lower the priority by one. - let new = nice(1).unwrap(); - - // If the test wasn't running with the lowest priority initially, test that - // we were able to lower the priority. - if old < 19 { - assert_eq!(old + 1, new); - } - - let get = nice(0).unwrap(); - assert_eq!(new, get); - - #[cfg(not(target_os = "redox"))] - { - let get_prio = getpriority_process(None).unwrap(); - assert_eq!(get_prio, new); - - setpriority_process(None, get + 1).unwrap(); - let now = getpriority_process(None).unwrap(); - - // If the test wasn't running with the lowest priority initially, test - // that we were able to lower the priority. - if get < 19 { - assert_eq!(get + 1, now); - } - setpriority_process(None, get + 10000).unwrap(); - let now = getpriority_process(None).unwrap(); - // Linux's max is 19; Darwin's max is 20. - assert!(now >= 19 && now <= 20); - // Darwin appears to return `EPERM` on an out of range `nice`. - if let Ok(again) = nice(1) { - assert_eq!(now, again); - } - } -} - -/// FreeBSD's `nice` doesn't return the new nice value, so use a specialized -/// test. -#[cfg(target_os = "freebsd")] -#[test] -fn test_priorities() { - let start = getpriority_process(None).unwrap(); - - let _ = nice(0).unwrap(); - - let now = getpriority_process(None).unwrap(); - assert_eq!(start, now); - - let _ = nice(1).unwrap(); - - let now = getpriority_process(None).unwrap(); - assert_eq!(start + 1, now); - - setpriority_process(None, start + 2).unwrap(); - - let now = getpriority_process(None).unwrap(); - assert_eq!(start + 2, now); - - setpriority_process(None, 10000).unwrap(); - - let now = getpriority_process(None).unwrap(); - assert_eq!(now, 20); - - let _ = nice(1).unwrap(); - - let now = getpriority_process(None).unwrap(); - assert_eq!(now, 20); -} diff --git a/vendor/rustix/tests/process/proc.rs b/vendor/rustix/tests/process/proc.rs deleted file mode 100644 index e85d85883..000000000 --- a/vendor/rustix/tests/process/proc.rs +++ /dev/null @@ -1,5 +0,0 @@ -#[test] -fn test_proc_funcs() { - let _maps = rustix::io::proc_self_maps().unwrap(); - let _pagemap = rustix::io::proc_self_pagemap().unwrap(); -} diff --git a/vendor/rustix/tests/process/rlimit.rs b/vendor/rustix/tests/process/rlimit.rs deleted file mode 100644 index b01f9204c..000000000 --- a/vendor/rustix/tests/process/rlimit.rs +++ /dev/null @@ -1,51 +0,0 @@ -use rustix::process::{Resource, Rlimit}; - -#[test] -fn test_getrlimit() { - let lim = rustix::process::getrlimit(Resource::Stack); - assert_ne!(lim.current, Some(0)); - assert_ne!(lim.maximum, Some(0)); -} - -#[test] -fn test_setrlimit() { - let old = rustix::process::getrlimit(Resource::Core); - let new = Rlimit { - current: Some(0), - maximum: Some(4096), - }; - assert_ne!(old, new); - rustix::process::setrlimit(Resource::Core, new.clone()).unwrap(); - - let lim = rustix::process::getrlimit(Resource::Core); - assert_eq!(lim, new); - - #[cfg(any(target_os = "android", target_os = "linux"))] - { - let new = Rlimit { - current: Some(0), - maximum: Some(0), - }; - - let first = rustix::process::getrlimit(Resource::Core); - - let old = match rustix::process::prlimit(None, Resource::Core, new.clone()) { - Ok(rlimit) => rlimit, - Err(rustix::io::Errno::NOSYS) => return, - Err(e) => Err(e).unwrap(), - }; - - assert_eq!(first, old); - - let other = Rlimit { - current: Some(0), - maximum: Some(0), - }; - - let again = - rustix::process::prlimit(Some(rustix::process::getpid()), Resource::Core, other) - .unwrap(); - - assert_eq!(again, new); - } -} diff --git a/vendor/rustix/tests/process/sched_yield.rs b/vendor/rustix/tests/process/sched_yield.rs deleted file mode 100644 index eacf17d5e..000000000 --- a/vendor/rustix/tests/process/sched_yield.rs +++ /dev/null @@ -1,7 +0,0 @@ -use rustix::process::sched_yield; - -#[test] -fn test_sched_yield() { - // Just make sure we can call it. - sched_yield(); -} diff --git a/vendor/rustix/tests/process/uname.rs b/vendor/rustix/tests/process/uname.rs deleted file mode 100644 index bc944c49e..000000000 --- a/vendor/rustix/tests/process/uname.rs +++ /dev/null @@ -1,13 +0,0 @@ -#[test] -fn test_uname() { - let name: rustix::process::Uname = rustix::process::uname(); - - assert!(!name.sysname().to_bytes().is_empty()); - assert!(!name.nodename().to_bytes().is_empty()); - assert!(!name.release().to_bytes().is_empty()); - assert!(!name.version().to_bytes().is_empty()); - assert!(!name.machine().to_bytes().is_empty()); - - #[cfg(any(target_os = "android", target_os = "linux"))] - assert!(!name.domainname().to_bytes().is_empty()); -} diff --git a/vendor/rustix/tests/process/wait.rs b/vendor/rustix/tests/process/wait.rs deleted file mode 100644 index a1f25a631..000000000 --- a/vendor/rustix/tests/process/wait.rs +++ /dev/null @@ -1,25 +0,0 @@ -use libc::{kill, SIGSTOP}; -use rustix::process; -use serial_test::serial; -use std::process::{Command, Stdio}; - -// These tests must execute serially to prevent race condition, where -// `test_wait` waits for the child process spawned in `test_waitpid`, causing -// the tests to get stuck. - -#[test] -#[serial] -fn test_waitpid() { - let child = Command::new("yes") - .stdout(Stdio::null()) - .stderr(Stdio::null()) - .spawn() - .expect("failed to execute child"); - unsafe { kill(child.id() as _, SIGSTOP) }; - - let pid = unsafe { process::Pid::from_raw(child.id() as _) }; - let status = process::waitpid(pid, process::WaitOptions::UNTRACED) - .expect("failed to wait") - .unwrap(); - assert!(status.stopped()); -} diff --git a/vendor/rustix/tests/process/weak.rs b/vendor/rustix/tests/process/weak.rs deleted file mode 100644 index d4f00f999..000000000 --- a/vendor/rustix/tests/process/weak.rs +++ /dev/null @@ -1,201 +0,0 @@ -// Implementation derived from `weak` in Rust's -// library/std/src/sys/unix/weak.rs at revision -// fd0cb0cdc21dd9c06025277d772108f8d42cb25f. - -//! Support for "weak linkage" to symbols on Unix -//! -//! Some I/O operations we do in libstd require newer versions of OSes but we -//! need to maintain binary compatibility with older releases for now. In order -//! to use the new functionality when available we use this module for -//! detection. -//! -//! One option to use here is weak linkage, but that is unfortunately only -//! really workable on Linux. Hence, use dlsym to get the symbol value at -//! runtime. This is also done for compatibility with older versions of glibc, -//! and to avoid creating dependencies on `GLIBC_PRIVATE` symbols. It assumes -//! that we've been dynamically linked to the library the symbol comes from, -//! but that is currently always the case for things like libpthread/libc. -//! -//! A long time ago this used weak linkage for the `__pthread_get_minstack` -//! symbol, but that caused Debian to detect an unnecessarily strict versioned -//! dependency on libc6 (#23628). - -// There are a variety of `#[cfg]`s controlling which targets are involved in -// each instance of `weak!` and `syscall!`. Rather than trying to unify all of -// that, we'll just allow that some unix targets don't use this module at all. -#![allow(dead_code, unused_macros)] -#![allow(clippy::doc_markdown)] - -use core::ffi::c_void; -use core::ptr::null_mut; -use core::sync::atomic::{self, AtomicPtr, Ordering}; -use core::{marker, mem}; -use rustix::ffi::CStr; - -const NULL: *mut c_void = null_mut(); -const INVALID: *mut c_void = 1 as *mut c_void; - -macro_rules! weak { - (fn $name:ident($($t:ty),*) -> $ret:ty) => ( - #[allow(non_upper_case_globals)] - static $name: $crate::weak::Weak<unsafe extern fn($($t),*) -> $ret> = - $crate::weak::Weak::new(concat!(stringify!($name), '\0')); - ) -} - -pub(crate) struct Weak<F> { - name: &'static str, - addr: AtomicPtr<c_void>, - _marker: marker::PhantomData<F>, -} - -impl<F> Weak<F> { - pub(crate) const fn new(name: &'static str) -> Self { - Self { - name, - addr: AtomicPtr::new(INVALID), - _marker: marker::PhantomData, - } - } - - pub(crate) fn get(&self) -> Option<F> { - assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>()); - unsafe { - // Relaxed is fine here because we fence before reading through the - // pointer (see the comment below). - match self.addr.load(Ordering::Relaxed) { - INVALID => self.initialize(), - NULL => None, - addr => { - let func = mem::transmute_copy::<*mut c_void, F>(&addr); - // The caller is presumably going to read through this value - // (by calling the function we've dlsymed). This means we'd - // need to have loaded it with at least C11's consume - // ordering in order to be guaranteed that the data we read - // from the pointer isn't from before the pointer was - // stored. Rust has no equivalent to memory_order_consume, - // so we use an acquire fence (sorry, ARM). - // - // Now, in practice this likely isn't needed even on CPUs - // where relaxed and consume mean different things. The - // symbols we're loading are probably present (or not) at - // init, and even if they aren't the runtime dynamic loader - // is extremely likely have sufficient barriers internally - // (possibly implicitly, for example the ones provided by - // invoking `mprotect`). - // - // That said, none of that's *guaranteed*, and so we fence. - atomic::fence(Ordering::Acquire); - Some(func) - } - } - } - } - - // Cold because it should only happen during first-time initialization. - #[cold] - unsafe fn initialize(&self) -> Option<F> { - let val = fetch(self.name); - // This synchronizes with the acquire fence in `get`. - self.addr.store(val, Ordering::Release); - - match val { - NULL => None, - addr => Some(mem::transmute_copy::<*mut c_void, F>(&addr)), - } - } -} - -unsafe fn fetch(name: &str) -> *mut c_void { - let name = match CStr::from_bytes_with_nul(name.as_bytes()) { - Ok(c_str) => c_str, - Err(..) => return null_mut(), - }; - libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr().cast()) -} - -#[cfg(not(any(target_os = "android", target_os = "linux")))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - errno::set_errno(errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -macro_rules! syscall { - (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - unsafe fn $name($($arg_name:$t),*) -> $ret { - // This looks like a hack, but concat_idents only accepts idents - // (not paths). - use libc::*; - - trait AsSyscallArg { - type SyscallArgType; - fn as_syscall_arg(self) -> Self::SyscallArgType; - } - - // Pass pointer types as pointers, to preserve provenance. - impl<T> AsSyscallArg for *mut T { - type SyscallArgType = *mut T; - fn as_syscall_arg(self) -> Self::SyscallArgType { self } - } - impl<T> AsSyscallArg for *const T { - type SyscallArgType = *const T; - fn as_syscall_arg(self) -> Self::SyscallArgType { self } - } - - // Pass `BorrowedFd` values as the integer value. - impl AsSyscallArg for $crate::fd::BorrowedFd<'_> { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { - $crate::fd::AsRawFd::as_raw_fd(&self) as _ - } - } - - // Coerce integer values into `c_long`. - impl AsSyscallArg for i32 { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for u32 { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - impl AsSyscallArg for usize { - type SyscallArgType = c::c_long; - fn as_syscall_arg(self) -> Self::SyscallArgType { self as _ } - } - - syscall( - concat_idents!(SYS_, $name), - $($arg_name.as_syscall_arg()),* - ) as $ret - } - ) -} - -macro_rules! weakcall { - ($vis:vis fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( - $vis unsafe fn $name($($arg_name: $t),*) -> $ret { - weak! { fn $name($($t),*) -> $ret } - - // Use a weak symbol from libc when possible, allowing `LD_PRELOAD` - // interposition, but if it's not found just fail. - if let Some(fun) = $name.get() { - fun($($arg_name),*) - } else { - errno::set_errno(errno::Errno(libc::ENOSYS)); - -1 - } - } - ) -} diff --git a/vendor/rustix/tests/process/working_directory.rs b/vendor/rustix/tests/process/working_directory.rs deleted file mode 100644 index 1c3262bb9..000000000 --- a/vendor/rustix/tests/process/working_directory.rs +++ /dev/null @@ -1,43 +0,0 @@ -#![cfg(feature = "fs")] - -#[cfg(not(target_os = "macos"))] -use rustix::fs::{Mode, OFlags}; -use tempfile::{tempdir, TempDir}; - -#[allow(unused)] -fn tmpdir() -> TempDir { - tempdir().expect("expected to be able to create a temporary directory") -} - -/// Disable this test on macos because GHA has a weird system folder structure -/// that makes this test fail. -#[cfg(not(target_os = "macos"))] -#[test] -fn test_changing_working_directory() { - let tmpdir = tmpdir(); - - let orig_cwd = rustix::process::getcwd(Vec::new()).expect("get the cwd"); - let orig_fd_cwd = rustix::fs::openat(rustix::fs::cwd(), ".", OFlags::RDONLY, Mode::empty()) - .expect("get a fd for the current directory"); - - rustix::process::chdir(tmpdir.path()).expect("changing dir to the tmp"); - let ch1_cwd = rustix::process::getcwd(Vec::new()).expect("get the cwd"); - - assert_ne!(orig_cwd, ch1_cwd, "The cwd hasn't changed!"); - assert_eq!( - ch1_cwd.to_string_lossy(), - tmpdir.path().to_string_lossy(), - "The cwd is not the same as the tmpdir" - ); - - #[cfg(not(target_os = "fuchsia"))] - rustix::process::fchdir(orig_fd_cwd).expect("changing dir to the original"); - #[cfg(target_os = "fushcia")] - rustix::process::chdir(orig_cwd).expect("changing dir to the original"); - let ch2_cwd = rustix::process::getcwd(ch1_cwd).expect("get the cwd"); - - assert_eq!( - orig_cwd, ch2_cwd, - "The cwd wasn't changed back to the its original position" - ); -} diff --git a/vendor/rustix/tests/rand/getrandom.rs b/vendor/rustix/tests/rand/getrandom.rs deleted file mode 100644 index ac316e447..000000000 --- a/vendor/rustix/tests/rand/getrandom.rs +++ /dev/null @@ -1,7 +0,0 @@ -use rustix::rand::{getrandom, GetRandomFlags}; - -#[test] -fn test_getrandom() { - let mut buf = [0_u8; 256]; - let _ = getrandom(&mut buf, GetRandomFlags::empty()); -} diff --git a/vendor/rustix/tests/rand/main.rs b/vendor/rustix/tests/rand/main.rs deleted file mode 100644 index 9dac8027f..000000000 --- a/vendor/rustix/tests/rand/main.rs +++ /dev/null @@ -1,9 +0,0 @@ -//! Tests for [`rustix::rand`]. - -#![cfg(feature = "rand")] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] - -#[cfg(any(linux_raw, all(libc, target_os = "linux")))] -mod getrandom; diff --git a/vendor/rustix/tests/termios/isatty.rs b/vendor/rustix/tests/termios/isatty.rs deleted file mode 100644 index 5e6fae73d..000000000 --- a/vendor/rustix/tests/termios/isatty.rs +++ /dev/null @@ -1,69 +0,0 @@ -use rustix::fd::AsRawFd; -use rustix::termios::{isatty, tcgetwinsize}; -use tempfile::{tempdir, TempDir}; - -#[allow(unused)] -fn tmpdir() -> TempDir { - tempdir().expect("expected to be able to create a temporary directory") -} - -#[test] -fn std_file_is_not_terminal() { - let tmpdir = tempfile::tempdir().unwrap(); - assert!(!isatty( - &std::fs::File::create(tmpdir.path().join("file")).unwrap() - )); - assert!(!isatty( - &std::fs::File::open(tmpdir.path().join("file")).unwrap() - )); -} - -#[test] -fn stdout_stderr_terminals() { - // This test is flaky under qemu. - if std::env::vars().any(|var| var.0.starts_with("CARGO_TARGET_") && var.0.ends_with("_RUNNER")) - { - return; - } - - // Compare `isatty` against `libc::isatty`. - assert_eq!(isatty(&std::io::stdout()), unsafe { - libc::isatty(std::io::stdout().as_raw_fd()) != 0 - }); - assert_eq!(isatty(&std::io::stderr()), unsafe { - libc::isatty(std::io::stderr().as_raw_fd()) != 0 - }); - - // Compare `isatty` against `tcgetwinsize`. - assert_eq!( - isatty(&std::io::stdout()), - tcgetwinsize(&std::io::stdout()).is_ok() - ); - assert_eq!( - isatty(&std::io::stderr()), - tcgetwinsize(&std::io::stderr()).is_ok() - ); -} - -#[test] -fn stdio_descriptors() { - #[cfg(unix)] - use std::os::unix::io::AsRawFd; - #[cfg(target_os = "wasi")] - use std::os::wasi::io::AsRawFd; - - unsafe { - assert_eq!( - rustix::io::stdin().as_raw_fd(), - std::io::stdin().as_raw_fd() - ); - assert_eq!( - rustix::io::stdout().as_raw_fd(), - std::io::stdout().as_raw_fd() - ); - assert_eq!( - rustix::io::stderr().as_raw_fd(), - std::io::stderr().as_raw_fd() - ); - } -} diff --git a/vendor/rustix/tests/termios/main.rs b/vendor/rustix/tests/termios/main.rs deleted file mode 100644 index d9ad9338b..000000000 --- a/vendor/rustix/tests/termios/main.rs +++ /dev/null @@ -1,10 +0,0 @@ -//! Tests for [`rustix::termios`]. - -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] -#![cfg(feature = "termios")] - -#[cfg(not(windows))] -mod isatty; -#[cfg(not(windows))] -mod ttyname; diff --git a/vendor/rustix/tests/termios/ttyname.rs b/vendor/rustix/tests/termios/ttyname.rs deleted file mode 100644 index 636178c31..000000000 --- a/vendor/rustix/tests/termios/ttyname.rs +++ /dev/null @@ -1,24 +0,0 @@ -use rustix::io; -use rustix::termios::{isatty, ttyname}; -use std::fs::File; - -#[test] -fn test_ttyname_ok() { - let file = File::open("/dev/stdin").unwrap(); - if isatty(&file) { - assert!(ttyname(&file, Vec::new()) - .unwrap() - .into_string() - .unwrap() - .starts_with("/dev/")); - } -} - -#[test] -fn test_ttyname_not_tty() { - let file = File::open("Cargo.toml").unwrap(); - assert_eq!(ttyname(&file, Vec::new()).unwrap_err(), io::Errno::NOTTY); - - let file = File::open("/dev/null").unwrap(); - assert_eq!(ttyname(&file, Vec::new()).unwrap_err(), io::Errno::NOTTY); -} diff --git a/vendor/rustix/tests/thread/clocks.rs b/vendor/rustix/tests/thread/clocks.rs deleted file mode 100644 index cf14df777..000000000 --- a/vendor/rustix/tests/thread/clocks.rs +++ /dev/null @@ -1,212 +0,0 @@ -#[cfg(not(any( - target_os = "emscripten", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -use rustix::thread::{clock_nanosleep_absolute, clock_nanosleep_relative, ClockId}; -#[cfg(not(target_os = "redox"))] -use { - rustix::io, - rustix::thread::{nanosleep, NanosleepRelativeResult, Timespec}, -}; - -#[cfg(not(target_os = "redox"))] -#[test] -fn test_invalid_nanosleep() { - match nanosleep(&Timespec { - tv_sec: 0, - tv_nsec: 1_000_000_000, - }) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match nanosleep(&Timespec { - tv_sec: 0, - tv_nsec: !0, - }) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match nanosleep(&Timespec { - tv_sec: !0, - tv_nsec: 1_000_000_000, - }) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match nanosleep(&Timespec { - tv_sec: !0, - tv_nsec: !0, - }) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} - -#[cfg(not(any( - target_os = "emscripten", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[test] -fn test_invalid_nanosleep_absolute() { - match clock_nanosleep_absolute( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: 1000000000, - }, - ) { - Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_absolute( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: !0, - }, - ) { - Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_absolute( - ClockId::Monotonic, - &Timespec { - tv_sec: !0, - tv_nsec: 1_000_000_000, - }, - ) { - Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_absolute( - ClockId::Monotonic, - &Timespec { - tv_sec: !0, - tv_nsec: !0, - }, - ) { - Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} - -#[cfg(not(any( - target_os = "emscripten", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[test] -fn test_invalid_nanosleep_relative() { - match clock_nanosleep_relative( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: 1_000_000_000, - }, - ) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_relative( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: !0, - }, - ) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_relative( - ClockId::Monotonic, - &Timespec { - tv_sec: !0, - tv_nsec: 1_000_000_000, - }, - ) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } - match clock_nanosleep_relative( - ClockId::Monotonic, - &Timespec { - tv_sec: !0, - tv_nsec: !0, - }, - ) { - NanosleepRelativeResult::Err(io::Errno::INVAL) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} - -#[cfg(not(target_os = "redox"))] -#[test] -fn test_zero_nanosleep() { - match nanosleep(&Timespec { - tv_sec: 0, - tv_nsec: 0, - }) { - NanosleepRelativeResult::Ok => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} - -#[cfg(not(any( - target_os = "emscripten", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[test] -fn test_zero_nanosleep_absolute() { - match clock_nanosleep_absolute( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: 0, - }, - ) { - Ok(()) => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} - -#[cfg(not(any( - target_os = "emscripten", - target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "openbsd", - target_os = "redox", - target_os = "wasi", -)))] -#[test] -fn test_zero_nanosleep_relative() { - match clock_nanosleep_relative( - ClockId::Monotonic, - &Timespec { - tv_sec: 0, - tv_nsec: 0, - }, - ) { - NanosleepRelativeResult::Ok => (), - otherwise => panic!("unexpected resut: {:?}", otherwise), - } -} diff --git a/vendor/rustix/tests/thread/id.rs b/vendor/rustix/tests/thread/id.rs deleted file mode 100644 index 7aa5abba5..000000000 --- a/vendor/rustix/tests/thread/id.rs +++ /dev/null @@ -1,7 +0,0 @@ -use rustix::thread; - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_gettid() { - assert_eq!(thread::gettid(), thread::gettid()); -} diff --git a/vendor/rustix/tests/thread/main.rs b/vendor/rustix/tests/thread/main.rs deleted file mode 100644 index 0fc9b42c4..000000000 --- a/vendor/rustix/tests/thread/main.rs +++ /dev/null @@ -1,9 +0,0 @@ -//! Tests for [`rustix::thread`]. - -#![cfg(feature = "thread")] -#![cfg(not(windows))] - -#[cfg(not(any(target_os = "redox")))] -mod clocks; -#[cfg(any(target_os = "android", target_os = "linux"))] -mod id; diff --git a/vendor/rustix/tests/time/dynamic_clocks.rs b/vendor/rustix/tests/time/dynamic_clocks.rs deleted file mode 100644 index a7e1e6792..000000000 --- a/vendor/rustix/tests/time/dynamic_clocks.rs +++ /dev/null @@ -1,22 +0,0 @@ -#![cfg(not(any(target_os = "redox", target_os = "wasi")))] - -use rustix::fd::AsFd; -use rustix::time::{clock_gettime_dynamic, ClockId, DynamicClockId}; - -#[test] -fn test_known_clocks() { - clock_gettime_dynamic(DynamicClockId::Known(ClockId::Realtime)).unwrap(); - clock_gettime_dynamic(DynamicClockId::Known(ClockId::Monotonic)).unwrap(); -} - -#[test] -fn test_dynamic_clocks() { - let file = std::fs::File::open("Cargo.toml").unwrap(); - clock_gettime_dynamic(DynamicClockId::Dynamic(file.as_fd())).unwrap_err(); -} - -#[cfg(any(target_os = "android", target_os = "linux"))] -#[test] -fn test_conditional_clocks() { - let _ = clock_gettime_dynamic(DynamicClockId::Tai); -} diff --git a/vendor/rustix/tests/time/main.rs b/vendor/rustix/tests/time/main.rs deleted file mode 100644 index 43283bca2..000000000 --- a/vendor/rustix/tests/time/main.rs +++ /dev/null @@ -1,14 +0,0 @@ -//! Tests for [`rustix::time`]. - -#![cfg(feature = "time")] -#![cfg(not(windows))] -#![cfg_attr(target_os = "wasi", feature(wasi_ext))] -#![cfg_attr(io_lifetimes_use_std, feature(io_safety))] - -mod dynamic_clocks; -#[cfg(not(any(target_os = "redox", target_os = "wasi")))] -mod monotonic; -#[cfg(any(target_os = "android", target_os = "linux"))] -mod timerfd; -mod timespec; -mod y2038; diff --git a/vendor/rustix/tests/time/monotonic.rs b/vendor/rustix/tests/time/monotonic.rs deleted file mode 100644 index 89470f2b4..000000000 --- a/vendor/rustix/tests/time/monotonic.rs +++ /dev/null @@ -1,45 +0,0 @@ -#[cfg(feature = "thread")] -use rustix::thread::nanosleep; -use rustix::time::{clock_gettime, ClockId, Timespec}; - -/// Attempt to test that the monotonic clock is monotonic. Time may or may not -/// advance, but it shouldn't regress. -#[test] -fn test_monotonic_clock() { - let a = clock_gettime(ClockId::Monotonic); - let b = clock_gettime(ClockId::Monotonic); - if b.tv_sec == a.tv_sec { - assert!(b.tv_nsec >= a.tv_nsec); - } else { - assert!(b.tv_sec > a.tv_sec); - } -} - -/// With the "thread" feature, we can sleep so that we're guaranteed that time -/// has advanced. -#[cfg(feature = "thread")] -#[test] -fn test_monotonic_clock_with_sleep_1s() { - let a = clock_gettime(ClockId::Monotonic); - let _rem = nanosleep(&Timespec { - tv_sec: 1, - tv_nsec: 0, - }); - let b = clock_gettime(ClockId::Monotonic); - assert!(b.tv_sec > a.tv_sec); -} - -/// With the "thread" feature, we can sleep so that we're guaranteed that time -/// has advanced. -#[cfg(feature = "thread")] -#[test] -fn test_monotonic_clock_with_sleep_1ms() { - let a = clock_gettime(ClockId::Monotonic); - let _rem = nanosleep(&Timespec { - tv_sec: 0, - tv_nsec: 1_000_000, - }); - let b = clock_gettime(ClockId::Monotonic); - assert!(b.tv_sec >= a.tv_sec); - assert!(b.tv_sec != a.tv_sec || b.tv_nsec > a.tv_nsec); -} diff --git a/vendor/rustix/tests/time/timerfd.rs b/vendor/rustix/tests/time/timerfd.rs deleted file mode 100644 index 6ad4dd72e..000000000 --- a/vendor/rustix/tests/time/timerfd.rs +++ /dev/null @@ -1,75 +0,0 @@ -use rustix::time::{ - timerfd_create, timerfd_gettime, timerfd_settime, Itimerspec, TimerfdClockId, TimerfdFlags, - TimerfdTimerFlags, Timespec, -}; - -#[test] -fn test_timerfd() { - let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); - - let set = Itimerspec { - it_interval: Timespec { - tv_sec: 0, - tv_nsec: 0, - }, - it_value: Timespec { - tv_sec: 1, - tv_nsec: 2, - }, - }; - let _old: Itimerspec = timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set).unwrap(); - - // Wait for the timer to expire. - let mut buf = [0_u8; 8]; - assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); - assert!(u64::from_ne_bytes(buf) >= 1); - - let new = timerfd_gettime(&fd).unwrap(); - - // The timer counts down. - assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); - assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); - assert!(new.it_value.tv_sec <= set.it_value.tv_sec); - assert!( - new.it_value.tv_nsec < set.it_value.tv_nsec || new.it_value.tv_sec < set.it_value.tv_sec - ); -} - -/// Similar, but set an interval for a repeated timer. Don't check that the -/// times are monotonic because that would race with the timer repeating. -#[test] -fn test_timerfd_with_interval() { - let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); - - let set = Itimerspec { - it_interval: Timespec { - tv_sec: 0, - tv_nsec: 6, - }, - it_value: Timespec { - tv_sec: 1, - tv_nsec: 7, - }, - }; - let _old: Itimerspec = timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set).unwrap(); - - // Wait for the timer to expire. - let mut buf = [0_u8; 8]; - assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); - assert!(u64::from_ne_bytes(buf) >= 1); - - let new = timerfd_gettime(&fd).unwrap(); - - assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); - assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); - - // Wait for the timer to expire again. - let mut buf = [0_u8; 8]; - assert_eq!(rustix::io::read(&fd, &mut buf), Ok(8)); - assert!(u64::from_ne_bytes(buf) >= 1); - - let new = timerfd_gettime(&fd).unwrap(); - - assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); - assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); -} diff --git a/vendor/rustix/tests/time/timespec.rs b/vendor/rustix/tests/time/timespec.rs deleted file mode 100644 index 6d892dcfe..000000000 --- a/vendor/rustix/tests/time/timespec.rs +++ /dev/null @@ -1,26 +0,0 @@ -#[test] -fn test_timespec_layout() { - #[cfg(not(target_os = "redox"))] - use rustix::fs::{UTIME_NOW, UTIME_OMIT}; - use rustix::time::{Nsecs, Secs, Timespec}; - - let tv_sec: Secs = 0; - let tv_nsec: Nsecs = 0; - let _ = Timespec { tv_sec, tv_nsec }; - - #[cfg(not(target_os = "redox"))] - let _ = Timespec { - tv_sec, - tv_nsec: UTIME_NOW, - }; - #[cfg(not(target_os = "redox"))] - let _ = Timespec { - tv_sec, - tv_nsec: UTIME_OMIT, - }; - let _ = Timespec { tv_sec, tv_nsec: 0 }; - let _ = Timespec { - tv_sec, - tv_nsec: 999_999_999, - }; -} diff --git a/vendor/rustix/tests/time/y2038.rs b/vendor/rustix/tests/time/y2038.rs deleted file mode 100644 index 45a073d19..000000000 --- a/vendor/rustix/tests/time/y2038.rs +++ /dev/null @@ -1,77 +0,0 @@ -/// Test that `Timespec` and `Secs` support a 64-bit number of seconds, -/// avoiding the y2038 bug. -/// -/// The Rust Musl target and libc crate are currently using Musl 1.1. It is -/// expected to update to Musl 1.2 at some point, at which point it'll gain a -/// 64-bit `time_t`. -/// -/// 32-bit Android is [not y2038 compatible]. In theory we could use -/// `libc::syscall` and call the new syscalls ourselves, however that doesn't -/// seem worth the effort on a platform that will likely never support add -/// such support itself. -/// -/// [not y2038 compatible]: https://android.googlesource.com/platform/bionic/+/refs/heads/master/docs/32-bit-abi.md#is-32_bit-on-lp32-y2038 -#[cfg(not(all(target_env = "musl", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "android", target_pointer_width = "32")))] -#[cfg(not(all(target_os = "emscripten", target_pointer_width = "32")))] -#[test] -fn test_y2038() { - use rustix::time::{Secs, Timespec}; - - let tv_sec: i64 = 0; - let _ = Timespec { tv_sec, tv_nsec: 0 }; - let _: Secs = tv_sec; - - #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] - { - use rustix::time::Itimerspec; - - let _ = Itimerspec { - it_interval: Timespec { tv_sec, tv_nsec: 0 }, - it_value: Timespec { tv_sec, tv_nsec: 0 }, - }; - } -} - -#[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))] -#[test] -fn test_y2038_with_timerfd() { - use rustix::time::{ - timerfd_create, timerfd_gettime, timerfd_settime, Itimerspec, TimerfdClockId, TimerfdFlags, - TimerfdTimerFlags, Timespec, - }; - - let fd = timerfd_create(TimerfdClockId::Monotonic, TimerfdFlags::CLOEXEC).unwrap(); - - let set = Itimerspec { - it_interval: Timespec { - tv_sec: (1_u64 << 32) as _, - tv_nsec: 20, - }, - it_value: Timespec { - tv_sec: (1_u64 << 32) as _, - tv_nsec: 21, - }, - }; - let _old: Itimerspec = match timerfd_settime(&fd, TimerfdTimerFlags::ABSTIME, &set) { - Ok(i) => i, - - // On 32-bit and mips64 platforms, accept `EOVERFLOW`, meaning that - // y2038 support in `timerfd` APIs is not available on this platform - // or this version of the platform. - #[cfg(any(target_pointer_width = "32", target_arch = "mips64"))] - Err(rustix::io::Errno::OVERFLOW) => return, - - Err(e) => panic!("unexpected error: {:?}", e), - }; - - let new = timerfd_gettime(&fd).unwrap(); - - // The timer counts down. - assert_eq!(set.it_interval.tv_sec, new.it_interval.tv_sec); - assert_eq!(set.it_interval.tv_nsec, new.it_interval.tv_nsec); - assert!(new.it_value.tv_sec <= set.it_value.tv_sec); - assert!( - new.it_value.tv_nsec < set.it_value.tv_nsec || new.it_value.tv_sec < set.it_value.tv_sec - ); -} |