Adding upstream version 1.67.1+dfsg1.upstream/1.67.1+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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, &times).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", &times, 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", &times, 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", &times, 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", &timestamps, 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, &timestamps) {
-        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
-    );
-}